public void SetupNewBattle(CharacterTeam inPlayerTeam, CharacterTeam inEnemyTeam)
{
turnQueue.Clear();
currentSkillResults.Clear();
currentDeadCharacters.Clear();
activeCharacter = null;
activeSkillCommand = null;
isProcessing = false;
stepIndex = 0;
turnNum = 0;
curBattleTransmuteCount = 0;
playerTeam = inPlayerTeam;
enemyTeam = inEnemyTeam;
RefreshCharactersInBattleList();
playerTeam.PrepareForBattle();
enemyTeam.PrepareForBattle();
/*
* Debug.Log("battle order:");
* foreach (CharacterData c in charactersInBattle)
* {
* Debug.Log(c.name + " : " + c.orderInTeam);
* }
*/
}
public void RunAutocombatForActiveCharacter()
{
CharacterTeam opposingTeam = adventure.GetTeamOppositeOfFaction(activeCharacter.curFaction);
CharacterTeam ownTeam = adventure.GetTeamForFaction(activeCharacter.curFaction);
SodaScript acScript = null;
if (activeCharacter.curFaction == Faction.PLAYER)
{
acScript = activeCharacter.activeSodaScript;
}
else
{
acScript = defaultEnemyScript;
}
acScript.Execute(activeCharacter, adventure, cachedSkillCommand);
//keep track of how many times a team has healed itself in a row. this is used inside of soda script execution to break out of infinite heal loops
if (cachedSkillCommand.skill.isHealing)
{
ownTeam.consecutiveHeals++;
}
else
{
ownTeam.consecutiveHeals = 0;
}
adventure.ReceiveCommand(cachedSkillCommand);
}
private void EnactPendingCharacterTransformations()
{
for (int i = 0; i < pendingCharacterTransformations.Count; i++)
{
CharacterData c1, c2;
c1 = pendingCharacterTransformations[i][0];
c2 = pendingCharacterTransformations[i][1];
CharacterTeam team = c1.IsInFaction(Faction.PLAYER) ? playerTeam : enemyTeam;
turnQueue.Remove(c1);
team.TurnMemberInto(c1, c2);
RefreshCharactersInBattleList();
if (GameContext.DEBUG_WEAK_ENEMIES && team == enemyTeam)
{
c2.stats.Set(Stat.hp, 1);
}
if (ECharacterTransformed != null)
{
ECharacterTransformed(c1, c2);
}
}
pendingCharacterTransformations.Clear();
}
public Fight GetFight(CharacterTeam computerTeam, CharacterTeam playerTeam)
{
IUserImpl cpu = UserGenerator.GetUser(false, computerTeam);
IUserImpl player = UserGenerator.GetUser(true, playerTeam);
return(new Fight(cpu, player));
}
public IUserImpl GetUser(bool isPlayer)
{
CharacterTeam team = TeamGenerator.GenerateRandomTeam(isPlayer);
if (isPlayer)
{
return(new ConsolePlayer(team));
}
return(new ConsoleComputer(team));
}
public SkillCommand PopulateAISkillCommand(SkillCommand inCommand, CharacterTeam opposingTeam)
{
//right now always choose a random target
CharacterData target = opposingTeam.GetRandomLivingMember();
Skill skillToUse = GetDefaultSkill();
inCommand.Reset(skillToUse, this);
inCommand.AddTarget(target);
return(inCommand);
}
public IUserImpl GetUser(bool isPlayer, CharacterTeam team)
{
if (isPlayer)
{
return(new ConsolePlayer(team));
}
else
{
return(new ConsoleComputer(team));
}
}
// Use this for initialization
void Start()
{
Team = GameObject.Find("GameControlCenter").GetComponent<CharacterTeam> ();
enTeam = GameObject.Find("EnemyTeam").GetComponent<CharacterTeam> ();
chDT = GameObject.Find ("GameControlCenter").GetComponent<CharacterData> ();
for (int i=0; i<chDT.character.Count; i++)
if (chDT.character[i].chID == ID) {
ch = i;
break;
}
}
public void Verify_Add_Should_AddTheEntityToTheContext()
{
// Arrange
Mock<IDbSet<CharacterTeam>> mockSetCharacterTeams;
var mockContext = CharacterTeamsMockingSetup.DoMockingSetupForContext(false, out mockSetCharacterTeams);
var repository = new CharacterTeamsRepository(mockContext.Object);
var characterTeams = new CharacterTeam { Active = true, CustomKey = "SALVATORE-RAA", };
// Act
repository.Add(characterTeams);
// Assert
mockSetCharacterTeams.Verify(x => x.Add(characterTeams), Times.Once);
}
private static void TeamBuilding()
{
TeamBuilderDisplay builderDisplay = new TeamBuilderDisplay(false);
CharacterTeam computerTeam = builderDisplay.TeamBuilderHome();
builderDisplay = new TeamBuilderDisplay(true);
CharacterTeam playerTeam = builderDisplay.TeamBuilderHome();
Console.Clear();
Fight fight = generator.GetFight(computerTeam, playerTeam);
EndFight(fight);
}
public CharacterTeam GenerateRandomTeam(bool isPlayer)
{
CharacterTeam team = new CharacterTeam();
for (int i = 0; i < 4; ++i)
{
IWeapon weapon = WeaponGenerator.GetRandomWeapon();
AbstractCharacter character = CharGenerator.GetRandomCharacter();
character.EquipWeapon(weapon);
team.InsertCharacter(character, isPlayer);
}
return(team);
}
public void Verify_Add_Should_AddTheEntityToTheContext()
{
// Arrange
Mock <IDbSet <CharacterTeam> > mockSetCharacterTeams;
var mockContext = CharacterTeamsMockingSetup.DoMockingSetupForContext(false, out mockSetCharacterTeams);
var repository = new CharacterTeamsRepository(mockContext.Object);
var characterTeams = new CharacterTeam {
Active = true, CustomKey = "SALVATORE-RAA",
};
// Act
repository.Add(characterTeams);
// Assert
mockSetCharacterTeams.Verify(x => x.Add(characterTeams), Times.Once);
}
private void EndBattle(CharacterTeam inWinningTeam)
{
Pause();
if (!adventure.isInteractiveCutscene)
{
//REMOVED: awarding mastery xp to player team
}
//REMOVED: increase pet xp
if (EBattleEnded != null)
{
EBattleEnded(inWinningTeam);
}
}
public void PrepareForAdventure(CharacterTeam inTeam)
{
team = inTeam;
UpdateCurFaction(team.faction);
RebuildSkillList();
CalculateModifiedStats();
_statusEffects = new List <StatusEffect>();
stats.Set(Stat.max_hp, stats.Get(Stat.hp));
stats.Set(Stat.max_mp, stats.Get(Stat.mp));
cooldowns = new List <CooldownData>();
_dead = false;
isDefending = false;
exhaustionTurnCount = 0;
}
private void CheckForBattleEnd()
{
CharacterTeam winningTeam = null;
if (playerTeam.AllMembersDefeated())
{
winningTeam = enemyTeam;
}
else if (enemyTeam.AllMembersDefeated())
{
winningTeam = playerTeam;
}
if (winningTeam != null)
{
EndBattle(winningTeam);
}
}
public void ExecuteTriggers(CharacterData inActiveCharacter, Adventure inAdventure, SkillCommand inCommandToPopulate)
{
//store some data up front that will probably be useful
activeCharacter = inActiveCharacter;
adventure = inAdventure;
opposingTeam = inAdventure.GetTeamOppositeOfFaction(activeCharacter.curFaction);
ownTeam = inAdventure.GetTeamForFaction(activeCharacter.curFaction);
if (potentialTargets == null)
{
potentialTargets = new List <CharacterData>();
}
if (culledTargets == null)
{
culledTargets = new List <CharacterData>();
}
potentialSkill = null;
//for a trigger to eval it needs a valid target, and the ability to cast the requested spell
bool atLeastOneTriggerEvaluated = false;
for (int i = 0; i < triggers.Count; i++)
{
if (EvalTrigger(triggers[i], inCommandToPopulate))
{
atLeastOneTriggerEvaluated = true;
break;
}
}
//if we made it this far, fall back to the default trigger that will always fire
if (!atLeastOneTriggerEvaluated)
{
EvalTrigger(defaultTrigger, inCommandToPopulate);
}
//cleanup
potentialTargets.Clear();
culledTargets.Clear();
potentialSkill = null;
}
public void Verify_MapToEntity_WithExistingEntity_AssignsCharacterTeamProperties()
{
// Arrange
var mapper = new CharacterTeamMapper();
var model = CharacterTeamsMockingSetup.DoMockingSetupForCharacterTeamModel();
// Act
ICharacterTeam existingEntity = new CharacterTeam {
Id = 1
};
mapper.MapToEntity(model.Object, ref existingEntity);
// Assert
// <None>
// Related Objects
Assert.Equal(model.Object.CharacterId, existingEntity.CharacterId);
Assert.Equal(model.Object.TeamId, existingEntity.TeamId);
// Associated Objects
// <None>
}
public void SetUp()
{
Fixture = new CharacterTeam();
}
public void ResolveActiveSkillCommand()
{
SkillResult curResult;
CharacterData source = activeSkillCommand.source;
CharacterData curTarget;
currentSkillResults.Clear();
//tally up damage that was reflected back at the source
float accumulatedDamageReflected = 0;
//tally up other properties to be used for stats
float accumulatedHpChange = 0;
float accumulatedDamageAbsorbed = 0;
uint totalCrits = 0;
uint totalEvades = 0;
uint totalBackAttacks = 0;
uint totalDefends = 0;
//we take special actions for the defend and surrender skills
if (activeSkillCommand.skill.id == SkillId.DEFEND)
{
source.isDefending = true;
curResult = PoolManager.poolSkillResults.GetNext();
curResult.Init(activeSkillCommand.skill, source, activeSkillCommand.targets[0]);
currentSkillResults.Add(curResult);
}
else if (activeSkillCommand.skill.id == SkillId.SURRENDER)
{
//no action taken here; battle will be ended before anything meaningful can happen
}
else
{
for (int i = 0; i < activeSkillCommand.targets.Count; i++)
{
curTarget = activeSkillCommand.targets[i];
curResult = activeSkillCommand.skill.GenerateResultToTarget(source, curTarget);
Stats statChanges = curResult.statChanges;
//make adjustments to the damage based on battle conditions AND the target's stats/conditions
float hpChange = statChanges.Get(Stat.hp);
//check this value here before any kind of absorb or defend is applied
if (hpChange < 0)
{
curResult.skillAttemptedToInflictDamage = true;
}
//REMOVED: add extra damage for huntress kill count, also increase damage if target is "marked"
//check for special case where pickaxe deals bonus damage to something turned to stone
if (curTarget.HasStatusEffect(StatusEffectType.STONE) && curResult.skill.id == SkillId.PICKAXE)
{
hpChange *= GameContext.PICKAXE_AGAINST_STONE_MULTIPLIER;
}
//back attack? can't back attack mineable ore
if (curResult.skill.canBackAttack && !curTarget.isOre)
{
if (curTarget.BackIsTurnedTo(source) && !curTarget.IsImmuneToBackAttackBonus())
{
hpChange *= GameContext.BACK_ATTACK_MULTIPLIER;
curResult.wasBackAttack = true;
totalBackAttacks++;
}
}
//boost magic attack and phys attacks
if (curResult.skill.IsType(SkillType.MAGICAL))
{
long magBoost = source.stats.Get(Stat.magic_boost);
if (magBoost != 0)
{
float boostAmt = 1f + (magBoost / 100f);
hpChange *= boostAmt;
}
//hard max for group heal: cannot exceed half of target's max hp
if (curResult.skill.id == SkillId.GROUP_HEAL)
{
long max = curTarget.stats.Get(Stat.max_hp) / 2;
if (hpChange > max)
{
hpChange = max;
}
}
}
else if (curResult.skill.IsType(SkillType.PHYSICAL))
{
long physBoost = source.stats.Get(Stat.phys_boost);
if (physBoost != 0)
{
float boostAmt = 1f + (physBoost / 100f);
hpChange *= boostAmt;
}
}
//crit. right now just manually check when using the strike skill. can't crit ore
if (curResult.skill.id == SkillId.STRIKE && !curTarget.isOre)
{
if (activeSkillCommand.source.RollPrimaryCritChance())
{
hpChange = activeSkillCommand.source.GetPrimaryCritBonusAppliedToDamage(hpChange);
curResult.wasCrit = true;
}
}
if (curResult.wasDoubleCrit)
{
totalCrits += 2;
}
else if (curResult.wasCrit)
{
totalCrits++;
}
//apply super bonus crit damage?
if (curResult.wasCrit || curResult.wasDoubleCrit)
{
if (adventure.nextCritDamageBoostPercent > 0)
{
float boostAmt = 1f + (adventure.nextCritDamageBoostPercent / 100f);
hpChange *= boostAmt;
adventure.nextCritDamageBoostPercent = 0;
}
}
bool sourceMissed = false;
bool targetEvaded = false;
//additional checks for non-friendly skills: (evade, reduce damage, defend, etc)
if (!curResult.skill.isFriendly)
{
//damage absorb/reduce?
long reduction = curTarget.stats.Get(Stat.dmg_reduction);
if (curTarget.HasStatusEffect(StatusEffectType.STONE) && curResult.skill.id != SkillId.PICKAXE)
{
reduction += 50;
}
if (reduction != 0)
{
float prevHpChange = hpChange;
float reductionAmt = 1f - (reduction / 100f);
hpChange *= reductionAmt;
accumulatedDamageAbsorbed += (Math.Abs(prevHpChange) - Math.Abs(hpChange));
}
//is target defending? cut damage in half
if (curTarget.isDefending)
{
hpChange = hpChange / 2f;
totalDefends++;
}
//if the skill attempted to inflict damage but damage was reduced below 1, make it 1
if (curResult.skillAttemptedToInflictDamage && Math.Abs(hpChange) < 1)
{
hpChange = -1;
}
//did the source miss because they were confused?
sourceMissed = activeSkillCommand.source.HasStatusEffect(StatusEffectType.CONFUSION) && Utils.PercentageChance(75);
//did the target evade successfully? note that they would never evade a friendly attack
CharacterTeam targetsTeam = adventure.GetTeamForFaction(curTarget.curFaction);
bool targetHasPartyProtection = curTarget.HasSkill(SkillId.PARTY_PROTECTION) && targetsTeam.GetNumLivingMembers() > 1;
if (curResult.source.curFaction != curResult.target.curFaction &&
(curTarget.PassesEvasionCheck() || targetHasPartyProtection))
{
targetEvaded = true;
totalEvades++;
}
}
//is target an ore? they take damage from the ore bust stat instead (min 1)
if (curTarget.isOre && curResult.skillAttemptedToInflictDamage)
{
//ore bust is a mixture of our existing ore bust stat plus whatever the attack itself specified. it's always at least 1
long oreBust = activeSkillCommand.source.stats.Get(Stat.ore_bust);
oreBust += statChanges.Get(Stat.ore_bust);
oreBust = Math.Max(oreBust, 1);
//ore bust is stored as a positive number but must be converted to negative for damage
hpChange = -oreBust;
}
//finalize damage
statChanges.Set(Stat.hp, (long)hpChange);
//debug invincible characters
if ((GameContext.DEBUG_INVINCIBLE_CHARACTERS && curTarget.curFaction == Faction.PLAYER) ||
(GameContext.DEBUG_INVINCIBLE_ENEMIES && curTarget.curFaction == Faction.ENEMY))
{
if (statChanges.Get(Stat.hp) < 0)
{
statChanges.Set(Stat.hp, 0);
}
}
//this line will always knock the target down to 1hp
//statChanges.Set(Stat.hp, -(curTarget.stats.Get(Stat.max_hp) - 1) );
if (sourceMissed || targetEvaded)
{
curResult.SetAsEvaded();
}
else
{
curResult.ResolveEffects(adventure);
//resolve team effects for the first result (we only do this once because technically all results contain copies of the same team effects
if (i == 0)
{
curResult.ResolveTeamEffects(adventure);
}
//NOW THAT THE ATTACK CONNECTED AND WAS RESOLVED:
//tally it
accumulatedHpChange += hpChange;
//damage reflect
long damageReflect = curTarget.stats.Get(Stat.dmg_reflection);
if (damageReflect > 0 && hpChange < 0)
{
float reflectValue = (hpChange * (damageReflect / 100f));
accumulatedDamageReflected += Math.Abs(reflectValue);
}
//dark savior
if (curTarget.stats.Get(Stat.hp) == 0)
{
CharacterData savior = curTarget.GetCurTeam().GetMemberWhoCanUseDarkSaviorThatIsnt(curTarget);
if (savior != null)
{
curTarget.stats.Set(Stat.hp, 1);
savior.IncrementDarkSaviorUseCount();
curResult.invokedDarkSavior = true;
}
}
//was this a transmute? max one per battle, and must be a common enemy
if (curResult.transmutesTarget)
{
bool isCommonEnemy = false;
if (curResult.target is EnemyCharacterData && !curResult.target.isOre)
{
if (((EnemyCharacterData)curResult.target).rank == EnemyRank.NORM)
{
isCommonEnemy = true;
}
}
//special exception for the grill which currently counts as a NORM enemy
if (curResult.target.id == EnemyId.GRILL)
{
isCommonEnemy = false;
}
if (isCommonEnemy && !CurBattleTransmuteLimitReached())
{
curBattleTransmuteCount++;
CharacterData newOre = CharacterData.Get(adventure.curOreTable.RollSpawn()).GetCopy();
newOre.UnsetFlags(CharacterFlags.DEATH_OPTIONAL); //unset the death optional flag, since the player transmuted them on purpose (it would be weird to instantly end the battle now)
curResult.transmuteResult = newOre;
curTarget.GetCurTeam().TurnMemberInto(curTarget, newOre);
turnQueue.Remove(curTarget);
RefreshCharactersInBattleList();
}
else
{
curResult.transmutesTarget = false;
curResult.failedATransmute = true;
}
}
}
currentSkillResults.Add(curResult);
}
}
//last step is to see if we create an additional result to send reflected damage back to the source
if (accumulatedDamageReflected > 0 && !source.HasSkill(SkillId.PARTY_PROTECTION))
{
curResult = PoolManager.poolSkillResults.GetNext();
curResult.Init(Skill.GetSkill(SkillId.STRIKE), source, source);
curResult.statChanges.Set(Stat.hp, -accumulatedDamageReflected);
curResult.ResolveEffects(adventure);
currentSkillResults.Add(curResult);
}
//REMOVED: some local stat reporting to the save file
if (ESkillResolved != null)
{
ESkillResolved(currentSkillResults);
}
}
public void TearDown()
{
Fixture = null;
}
public void Verify_MapToEntity_WithExistingEntity_AssignsCharacterTeamProperties()
{
// Arrange
var mapper = new CharacterTeamMapper();
var model = CharacterTeamsMockingSetup.DoMockingSetupForCharacterTeamModel();
// Act
ICharacterTeam existingEntity = new CharacterTeam { Id = 1 };
mapper.MapToEntity(model.Object, ref existingEntity);
// Assert
// <None>
// Related Objects
Assert.Equal(model.Object.CharacterId, existingEntity.CharacterId);
Assert.Equal(model.Object.TeamId, existingEntity.TeamId);
// Associated Objects
// <None>
}
public void CreateTeam()
{
Team = new CharacterTeam();
}
public override AbstractUser GetUser(CharacterTeam team)
{
IUserImpl user = new ConsoleComputer(team);
return(new User(user));
}
void Awake()
{
//初始化定義
Team = GameObject.Find("GameControlCenter").GetComponent<CharacterTeam> ();
enTeam = GameObject.Find("EnemyTeam").GetComponent<CharacterTeam> ();
chUnitWindow = GameObject.Find ("CH_UNIT");
enUnitWindow = GameObject.Find ("EN_UNIT");
}
// Use this for initialization
void Start()
{
Team = GameObject.FindGameObjectWithTag ("GCC").GetComponent<CharacterTeam> ();
chUnitWindow = GameObject.Find ("CH_UNIT");
chFace = GameObject.Find("CharacterFace").GetComponent<Image>();
NAME = GameObject.Find ("NAME").GetComponent<Text>();
LV= GameObject.Find ("LV").GetComponent<Text>();
STR= GameObject.Find ("STR").GetComponent<Text>();
INT= GameObject.Find ("INT").GetComponent<Text>();
AGI= GameObject.Find ("AGI").GetComponent<Text>();
CHA= GameObject.Find ("CHA").GetComponent<Text>();
COU= GameObject.Find ("COU").GetComponent<Text>();
DrawGrid ();
DrawCH ();
}
public ConsolePlayer(CharacterTeam team) : base(team)
{
}
public abstract AbstractUser GetUser(CharacterTeam team);
public ConsoleComputer(CharacterTeam team) : base(team)
{
}
//return true if this evals true for any target provided
private void EvalCondition(SodaScriptCondition inCondition, SodaScriptComparison inComparison, string inCompareValue, List <CharacterData> inTargets)
{
CharacterData targ;
EnemyCharacterData ecd;
PlayerCharacterData pcd;
culledTargets.Clear();
if (inCondition == SodaScriptCondition.WEAKEST)
{
culledTargets.Add(GetLowestHpPercentTarget(inTargets));
}
else if (inCondition == SodaScriptCondition.TEAM_ALIVE)
{
targ = inTargets[0];
CharacterTeam team = targ.IsInFaction(Faction.PLAYER) ? adventure.playerTeam : adventure.enemyTeam;
if (EvalNumericComparison(team.GetNumLivingMembers(), int.Parse(inCompareValue), inComparison))
{
culledTargets.Add(targ);
}
}
else if (inCondition == SodaScriptCondition.TEAM_HP)
{
targ = inTargets[0];
CharacterTeam team = targ.IsInFaction(Faction.PLAYER) ? adventure.playerTeam : adventure.enemyTeam;
if (EvalNumericComparison(team.GetTeamHPPercent(), int.Parse(inCompareValue), inComparison))
{
culledTargets.Add(targ);
}
}
else if (inCondition == SodaScriptCondition.TEAM_NUM_BACK_TURNED)
{
targ = inTargets[0];
CharacterTeam team = targ.IsInFaction(Faction.PLAYER) ? adventure.playerTeam : adventure.enemyTeam;
int numBackTurned = team.GetNumMembersWithBackTurnedTo(activeCharacter);
if (EvalNumericComparison(numBackTurned, int.Parse(inCompareValue), inComparison))
{
culledTargets.Add(targ);
}
}
else
{
for (int i = 0; i < inTargets.Count; i++)
{
targ = inTargets[i];
if (inCondition == SodaScriptCondition.HP)
{
if (EvalNumericComparison(targ.GetHpPercent(), int.Parse(inCompareValue), inComparison))
{
culledTargets.Add(targ);
}
}
else if (inCondition == SodaScriptCondition.MP)
{
if (EvalNumericComparison(targ.GetMpPercent(), int.Parse(inCompareValue), inComparison))
{
culledTargets.Add(targ);
}
}
else if (inCondition == SodaScriptCondition.POSITION)
{
if (EvalNumericComparison(targ.originalOrderInTeam + 1, int.Parse(inCompareValue), inComparison))
{
culledTargets.Add(targ);
}
}
else if (inCondition == SodaScriptCondition.RANK)
{
bool foundRank = false;
EnemyRank enemyRank = EnemyRank.NORM;
EnemyRank parsedRank = (EnemyRank)Enum.Parse(typeof(EnemyRank), inCompareValue);
if (targ is EnemyCharacterData)
{
foundRank = true;
ecd = (EnemyCharacterData)targ;
enemyRank = ecd.rank;
}
else if (targ.id == CharId.JANITOR)
{
foundRank = true;
enemyRank = EnemyRank.BOSS;
}
if (foundRank)
{
if (EvalNumericComparison((int)enemyRank, (int)parsedRank, inComparison))
{
culledTargets.Add(targ);
}
}
}
else if (inCondition == SodaScriptCondition.IS_ORE)
{
if (targ.isOre)
{
culledTargets.Add(targ);
}
}
else if (inCondition == SodaScriptCondition.ISNT_ORE)
{
if (!targ.isOre)
{
culledTargets.Add(targ);
}
}
else if (inCondition == SodaScriptCondition.IS_JANITOR)
{
if (targ.id == CharId.JANITOR)
{
culledTargets.Add(targ);
}
}
else if (inCondition == SodaScriptCondition.ISNT_JANITOR)
{
if (targ.id != CharId.JANITOR)
{
culledTargets.Add(targ);
}
}
else if (inCondition == SodaScriptCondition.BACK_IS_TURNED)
{
if (!targ.isOre && targ.BackIsTurnedTo(activeCharacter))
{
culledTargets.Add(targ);
}
}
else if (inCondition == SodaScriptCondition.BACK_ISNT_TURNED)
{
if (!targ.isOre && !targ.BackIsTurnedTo(activeCharacter))
{
culledTargets.Add(targ);
}
}
else if (inCondition == SodaScriptCondition.HAS_ESSENCE)
{
if (targ.hasEssence)
{
culledTargets.Add(targ);
}
}
else if (inCondition == SodaScriptCondition.NO_ESSENCE)
{
if (!targ.hasEssence)
{
culledTargets.Add(targ);
}
}
else if (inCondition == SodaScriptCondition.STATUS)
{
StatusEffectCategory parsedCategory = (StatusEffectCategory)Enum.Parse(typeof(StatusEffectCategory), inCompareValue);
if (parsedCategory == StatusEffectCategory.POSITIVE)
{
bool hasPos = targ.HasPostiveStatusEffect();
if ((inComparison == SodaScriptComparison.EQUALS && hasPos) ||
(inComparison == SodaScriptComparison.NOT_EQUALS && !hasPos))
{
culledTargets.Add(targ);
}
}
else if (parsedCategory == StatusEffectCategory.NEGATIVE)
{
bool hasNeg = targ.HasNegativeStatusEffect();
if ((inComparison == SodaScriptComparison.EQUALS && hasNeg) ||
(inComparison == SodaScriptComparison.NOT_EQUALS && !hasNeg))
{
culledTargets.Add(targ);
}
}
else if (parsedCategory == StatusEffectCategory.NONE)
{
bool hasAny = targ.HasAnyStatusEffect();
if ((inComparison == SodaScriptComparison.EQUALS && !hasAny) ||
(inComparison == SodaScriptComparison.NOT_EQUALS && hasAny))
{
culledTargets.Add(targ);
}
}
}
else
{
throw new Exception("Trigger condition " + inCondition + " is not supported as a condition");
}
}
//do a final list sort based on the condition?
if (inCondition == SodaScriptCondition.HP)
{
if (inComparison == SodaScriptComparison.GREATER_THAN)
{
culledTargets = culledTargets.OrderByDescending(t => t.GetHpPercent()).ToList <CharacterData>();
}
else if (inComparison == SodaScriptComparison.LESS_THAN)
{
culledTargets = culledTargets.OrderBy(t => t.GetHpPercent()).ToList <CharacterData>();
}
}
else if (inCondition == SodaScriptCondition.MP)
{
if (inComparison == SodaScriptComparison.GREATER_THAN)
{
culledTargets = culledTargets.OrderByDescending(t => t.GetMpPercent()).ToList <CharacterData>();
}
else if (inComparison == SodaScriptComparison.LESS_THAN)
{
culledTargets = culledTargets.OrderBy(t => t.GetMpPercent()).ToList <CharacterData>();
}
}
}
potentialTargets.Clear();
potentialTargets.AddRange(culledTargets);
}
