public PassiveEffect hasPassiveEffectForTime(EWhenToApply aTimeToApply,float aTargetHPVal,float aMyHP,ElementalType aAttackerType,ElementalType aDefendentType,BetterList<BattleMonster> aAllies,BetterList<BattleMonster> aOpponents,ERangedStatus aRange,BattleMonster aAttacker,ElementalType aAttackingMoveElement,EStatusEffects aStatusEffectInduced = EStatusEffects.None) {
for(int i = 0;i<_effects.size;i++) {
if(_effects[i].applyAt==aTimeToApply) {
if((_effects[i].applyAt==EWhenToApply.AtEndOfMoveQueue)||
(_effects[i].applyAt==EWhenToApply.BattleStart)||
(_effects[i].applyAt==EWhenToApply.WhenHit)
) {
return _effects[i];
}
if((_effects[i].applyAt==EWhenToApply.WhenAttackingWithMoveType)&&(aAttackingMoveElement==_effects[i].whenMoveElementType)) {
return _effects[i];
}
if((_effects[i].applyAt==EWhenToApply.WhenTheirHPHigherThan)&&(aTargetHPVal>_effects[i].HPPercentage)) {
return _effects[i];
}
if((_effects[i].applyAt==EWhenToApply.WhenTheirHPLowerThan)&&(aTargetHPVal<_effects[i].HPPercentage)) {
return _effects[i];
}
if((_effects[i].applyAt==EWhenToApply.WhenMyHPHigherThan)&&(aMyHP>(1/_effects[i].HPPercentage))) {
return _effects[i];
}
if((_effects[i].applyAt==EWhenToApply.WhenMyHPLowerThan)&&(aMyHP<(1/_effects[i].HPPercentage))) {
return _effects[i];
}
if((_effects[i].applyAt==EWhenToApply.WhenAttackerIsType)&&(aAttackerType==_effects[i].whenMoveElementType)) {
return _effects[i];
}
if((_effects[i].applyAt==EWhenToApply.WhenDefendentIsType)&&(aDefendentType==_effects[i].whenMoveElementType)) {
return _effects[i];
}
if((_effects[i].applyAt==EWhenToApply.WhenAlliesAreType)&&(listContainsElement(_effects[i].whenMoveElementType,aAllies).size>0)) {
return _effects[i];
}
if((_effects[i].applyAt==EWhenToApply.WhenDefendentIsType)&&(listContainsElement(_effects[i].whenMoveElementType,aOpponents).size>0)) {
return _effects[i];
}
if((_effects[i].applyAt==EWhenToApply.WhenOneOpponentisSameAsEffectOwner)&&(listContainsElement(aAttackerType,aOpponents).size>0)) {
return _effects[i];
}
if((_effects[i].applyAt==EWhenToApply.WhenHitByMoveType)&&(aAttackerType==_effects[i].whenMoveElementType)) {
return _effects[i];
}
if((_effects[i].applyAt==EWhenToApply.WhenHitByRangeType)&&(aRange==_effects[i].whenRangeType)) {
return _effects[i];
}
if((_effects[i].applyAt==EWhenToApply.WhenOpponentHasStatusEffect)&&(listContainsStatusEffect(_effects[i].whenStatusEffects,aOpponents).size>0)) {
return _effects[i];
}
if((_effects[i].applyAt==EWhenToApply.WhenStatusEffectsSuffered)&&((_effects[i].whenStatusEffects&aAttacker.statusEffects)!=EStatusEffects.None)) {
return _effects[i];
}
if((_effects[i].applyAt==EWhenToApply.WhenHitByMoveTypeAtEndOfMoveQueue)&&(_effects[i].whenMoveElementType==aAttackingMoveElement)) {
return _effects[i];
}
}
}
return null;
}
public PassiveEffect (PassiveEffectsRow aRow) {
id = aRow._ID;
name = aRow._EffectName;
elementType = ElementalLibrary.REF.getElement(aRow._EffectType);
description = aRow._Description;
moveRef = MovesLib.REF.getMove(aRow._TakeEffectsFromMove);
switch(aRow._EffectClass) {
case("Class 1"):effectClass = 1;break;
case("Class 2"):effectClass = 2;break;
case("Class 3"):effectClass = 4;break;
case("Class 4"):effectClass = 8;break;
}
weighting = aRow._Weighting;
switch(aRow._ApplyWhen) {
case("At battle start"):applyAt = EWhenToApply.BattleStart;break;
case("When hit by %FIELDMOVETYPE%"):applyAt = EWhenToApply.WhenHitByMoveType;break;
case("When using move of type %FIELDMOVETYPE%"):applyAt = EWhenToApply.WhenAttackingWithMoveType;break;
case("When %STATUSEFFECTSUFFERED%"):applyAt = EWhenToApply.WhenStatusEffectsSuffered;break;
case("When defendant is same type"):applyAt = EWhenToApply.WhenDefendentIsType;break;
case("When allies are of type %FIELDMOVETYPE%"):applyAt = EWhenToApply.WhenAlliesAreType;break;
case("When hit"):applyAt = EWhenToApply.WhenHit;break;
case("When HP Higher than %HPPERCENTAGE%"):applyAt = EWhenToApply.WhenMyHPHigherThan;break;
case("When HP Lower than %HPPERCENTAGE%"):applyAt = EWhenToApply.WhenMyHPLowerThan;break;
case("When defendant HP Lower than %HPPERCENTAGE%"):applyAt = EWhenToApply.WhenTheirHPLowerThan;break;
case("When defendant HP Higher than %HPPERCENTAGE%"):applyAt = EWhenToApply.WhenTheirHPHigherThan;break;
case("When hit by %MOVERANGETYPE%"):applyAt = EWhenToApply.WhenHitByRangeType;break;
case("At end of move queue"):applyAt = EWhenToApply.AtEndOfMoveQueue;break;
case("When hit by %FIELDMOVETYPE% at end of move queue"):applyAt = EWhenToApply.WhenHitByMoveTypeAtEndOfMoveQueue;break;
case("When one opponent is %FIELDMOVETYPE%"):applyAt = EWhenToApply.WhenOneOpponentisType;break;
case("When one opponent is same as effect owner"):applyAt = EWhenToApply.WhenOneOpponentisSameAsEffectOwner;break;
}
whenMoveElementType = ElementalLibrary.REF.getElement(aRow._MoveElementType);
switch(aRow._MoveRangeType) {
default: this.whenRangeType = ERangedStatus.MeleeAndRanged;break;
case("Melee"):this.whenRangeType = ERangedStatus.Melee;break;
case("Ranged"):this.whenRangeType = ERangedStatus.Ranged;break;
}
whenStatusEffects = (EStatusEffects) aRow._StatusEffectSuffered;
HPPercentage = aRow._HPPercentage;
}
private void removeResponsibleMove(EStatusEffects aEffects) {
if((aEffects&EStatusEffects.Burn)==EStatusEffects.Burn) {
_reasonForBurn = null;
}
if((aEffects&EStatusEffects.Confusion)==EStatusEffects.Confusion) {
_reasonForConfusion = null;
}
if((aEffects&EStatusEffects.Flinch)==EStatusEffects.Flinch) {
_reasonForFlinch = null;
}
if((aEffects&EStatusEffects.Freeze)==EStatusEffects.Freeze) {
_reasonForFreeze = null;
}
if((aEffects&EStatusEffects.Paralyze)==EStatusEffects.Paralyze) {
_reasonForParalyze = null;
}
if((aEffects&EStatusEffects.Poison)==EStatusEffects.Poison) {
_reasonForPoison = null;
}
if((aEffects&EStatusEffects.Sleep)==EStatusEffects.Sleep) {
_reasonForSleep = null;
}
}
public void removeEffect(EStatusEffects aEffect) {
if(hasEffect(aEffect)) {
_currentStatusEffects = _currentStatusEffects & ~aEffect;
if((EStatusEffects.Confusion & aEffect) == EStatusEffects.Confusion) {
_turnsOfConfusion = 0;
}
if(onStatusEffectRemoved!=null) {
onStatusEffectRemoved(aEffect);
}
}
}
public void addEffect(EStatusEffects aEffect,MoveLibItem aMove) {
if(!hasEffect(aEffect)) {
_currentStatusEffects = _currentStatusEffects | aEffect;
setResponsibleMove(aEffect,aMove);
if((EStatusEffects.Confusion & aEffect) == EStatusEffects.Confusion) {
_turnsOfConfusion = 1+(int) (BattleRandomizer.random*MAX_TURNS_OF_CONFUSION);//(1,MAX_TURNS_OF_CONFUSION);
}
if((EStatusEffects.Sleep & aEffect) == EStatusEffects.Sleep) {
_turnsOfSleep = 1+(int) (BattleRandomizer.random*MAX_TURNS_OF_SLEEP);;
}
if(onStatusEffectAdded!=null) {
onStatusEffectAdded(aEffect);
}
}
}
private void setResponsibleMove(EStatusEffects aEffects,MoveLibItem aMove) {
if((aEffects&EStatusEffects.Burn)==EStatusEffects.Burn) {
_reasonForBurn = aMove;
}
if((aEffects&EStatusEffects.Confusion)==EStatusEffects.Confusion) {
_reasonForConfusion = aMove;
}
if((aEffects&EStatusEffects.Flinch)==EStatusEffects.Flinch) {
_reasonForFlinch = aMove;
}
if((aEffects&EStatusEffects.Freeze)==EStatusEffects.Freeze) {
_reasonForFreeze = aMove;
}
if((aEffects&EStatusEffects.Paralyze)==EStatusEffects.Paralyze) {
_reasonForParalyze = aMove;
}
if((aEffects&EStatusEffects.Poison)==EStatusEffects.Poison) {
_reasonForPoison = aMove;
}
if((aEffects&EStatusEffects.Sleep)==EStatusEffects.Sleep) {
_reasonForSleep = aMove;
}
}
public void FromString(string aString) {
int effects = Convert.ToInt32(aString);
_currentStatusEffects = (EStatusEffects) effects;
}
public bool hasStatusEffect(EStatusEffects aEffect) {
if(lingeringEffects.hasEffect(aEffect)) {
return true;
} else return false;
}
public void showStatusEffect(EStatusEffects aEffect) {
switch(aEffect) {
case(EStatusEffects.Flinch):
GameObject flinch = getEffect("FlinchEffect");
if(flinch!=null)
flinch.transform.position = this.SpawnPosition;
break;
case(EStatusEffects.Confusion):
GameObject confusion = getEffect("ConfuseEffect");
if(confusion!=null)
confusion.transform.position = this.ConfuseSpawnPosition;
break;
case(EStatusEffects.Poison):
GameObject poisoned = getEffect("PoisonedEffect");
if(poisoned!=null)
poisoned.transform.position = this.ConfuseSpawnPosition;
break;
case(EStatusEffects.Freeze):
GameObject frozen = getEffect("FrozenEffect");
if(frozen!=null)
frozen.transform.position = this.ConfuseSpawnPosition;
break;
case(EStatusEffects.Paralyze):
GameObject paralyze = getEffect("ParalyzeEffect");
if(paralyze!=null)
paralyze.transform.position = this.ConfuseSpawnPosition;
break;
case(EStatusEffects.Burn):
GameObject burn = getEffect("BurnEffect");
if(burn!=null)
burn.transform.position = this.ConfuseSpawnPosition;
break;
case(EStatusEffects.Sleep):
GameObject sleep = getEffect("SleepEffect");
if(sleep!=null) {
sleep.transform.position = this.ConfuseSpawnPosition;
}
break;
}
BattleControllerWithParticleEngines.putParticlesInfront();
}
public void removeLingeringEffect(EStatusEffects aEffect) {
lingeringEffects.removeEffect(aEffect);
}
public void addLingeringEffect(EStatusEffects aEffect,MoveLibItem aCause) {
lingeringEffects.addEffect(aEffect,aCause);
}
public BetterList<BattleMonster> listContainsStatusEffect(EStatusEffects aStatusEffect,BetterList<BattleMonster> aMonster) {
BetterList<BattleMonster> r = new BetterList<BattleMonster>();
for(int i = 0;i<aMonster.size;i++) {
if((aMonster[i].statusEffects&aStatusEffect)!=0) {
r.Add(aMonster[i]);
}
}
return r;
}
private void onRemoveStatusEffect(EStatusEffects aStatusEffect) {
switch(aStatusEffect) {
case(EStatusEffects.Burn):
base.doCommentaryMessage(this.name+" Burn has been healed!",ECommentaryMessageType.StandardMessage);
break;
case(EStatusEffects.Confusion):
base.doCommentaryMessage(this.name+" is no longer Confused!",ECommentaryMessageType.StandardMessage);
break;
case(EStatusEffects.Freeze):
base.doCommentaryMessage(this.name+" has Thawed!",ECommentaryMessageType.StandardMessage);
break;
case(EStatusEffects.Paralyze):
base.doCommentaryMessage(this.name+" Paralysis has worn off!",ECommentaryMessageType.StandardMessage);
break;
case(EStatusEffects.Poison):
base.doCommentaryMessage(this.name+" is cured of it's Poison!",ECommentaryMessageType.StandardMessage);
break;
case(EStatusEffects.Sleep):
this.doIdleAnimation();
base.doCommentaryMessage(this.name+" Awoke!",ECommentaryMessageType.StandardMessage);
break;
}
}
private void onNewStatusEffect(EStatusEffects aStatusEffect) {
switch(aStatusEffect) {
case(EStatusEffects.Burn):
base.doCommentaryMessage(this.name+" has been Burned!",ECommentaryMessageType.StandardMessage);
this.showStatusEffect(EStatusEffects.Burn);
break;
case(EStatusEffects.Confusion):
this.doCommentaryMessage(this.name+" became Confused!",ECommentaryMessageType.StandardMessage);
this.showStatusEffect(EStatusEffects.Confusion);
break;
case(EStatusEffects.Freeze):
this.doCommentaryMessage(this.name+" was Frozen!",ECommentaryMessageType.StandardMessage);
this.showStatusEffect(EStatusEffects.Freeze);
break;
case(EStatusEffects.Paralyze):
this.doCommentaryMessage(this.name+" is Paralyzed!",ECommentaryMessageType.StandardMessage);
this.showStatusEffect(EStatusEffects.Paralyze);
break;
case(EStatusEffects.Poison):
this.doCommentaryMessage(this.name+" was Poisoned!",ECommentaryMessageType.StandardMessage);
this.showStatusEffect(EStatusEffects.Poison);
break;
case(EStatusEffects.Sleep):
this.doCommentaryMessage(this.name+" fell Asleep!",ECommentaryMessageType.StandardMessage);
this.showStatusEffect(EStatusEffects.Sleep);
break;
}
}
public bool hasEffect(EStatusEffects aEffect) {
if((aEffect & _currentStatusEffects) == aEffect) {
return true;
}
return false;
}
private void onEffectRemoved(EStatusEffects aEffect) {
if(this.onStatusEffectRemoved!=null) {
this.onStatusEffectRemoved(aEffect);
}
}
public void removeAllEffects() {
this._currentStatusEffects = EStatusEffects.None;
_turnsOfSleep = 0;
_turnsOfConfusion = 0;
}
public MoveLibItem(MoveDataRow aInitData) {
this._id = aInitData._ID;
this._name = aInitData._MoveName;
this._moveSpeedMultiplier = aInitData._MoveSpeedMultiplier;
switch (aInitData._PowerApplicationType) {
case("Normal"):this._powerApplicationType = EPowerApplicationTypes.Normal;break;
case("Power is HP"): this._powerApplicationType = EPowerApplicationTypes.PowerIsHP;break;
case("Power is Percentage of HP"): this._powerApplicationType = EPowerApplicationTypes.PowerIsPercentOfHP;break;
}
this._description = aInitData._Description;
oneHitKillInvulnerable = aInitData._AddsOneHitKOInvulnerability;
decisiveBlowsImmunity = aInitData._DecisiveBlowsImmunity;
this._elementalType = ElementalLibrary.REF.getElement (aInitData._ElementalType);
switch (aInitData._MeleeRangedStatus) {
case("Melee"):this._meleeRangedStatus = ERangedStatus.Melee;break;
case("Ranged"):this._meleeRangedStatus = ERangedStatus.Ranged;break;
}
this._effort = aInitData._Effort;
this._power = aInitData._Power;
this._splashpercent = aInitData._SplashPercent;
cameraShake = aInitData._CameraShake;
switch (aInitData._SplashRange) {
case("Hit 1 Only"):this._splashRange = ESplashRange.Hit1Only;break;
case("Hit All"):this._splashRange = ESplashRange.HitAll;break;
case("Splash Range 1"):this._splashRange = ESplashRange.SplashRange1;break;
case("Boost Me"):this._splashRange = ESplashRange.BoostMe;break;
case("Boost 1"):this._splashRange = ESplashRange.Boost1;break;
case("Boost 1 And Me"):this._splashRange = ESplashRange.Boost1AndMe;break;
case("Boost All"):this._splashRange = ESplashRange.BoostAll;break;
case("Boost 2"):this._splashRange = ESplashRange.Boost2;break;
case("Boost whole Field"):this._splashRange = ESplashRange.BoostWholeField;break;
case("Random Opponent"):this._splashRange = ESplashRange.RandomOpponent;break;
}
this._accuracy = aInitData._Accuracy;
this._particlesAnimation = MovesAnimationLib.REF.getAnimation(aInitData._AttackParticlesAnimation);
this._hitParticlesAnimation = MovesAnimationLib.REF.getAnimation(aInitData._AttackParticlesAnimationHit);
this._attackMecanim = aInitData._AttackMecanim;
this._hitMecanim = aInitData._HitMecanim;
this._paralyzePercent = aInitData._ParalyzePercent;
this._sleepPercent = aInitData._SleepPercent;
this._poisonPercent = aInitData._PoisonPercent;
this._freezePercent = aInitData._FreezePercent;
this._flinchPercent = aInitData._FlinchPercent;
this._confusionPercent = aInitData._ConfusionPercent;
this._burnPercent = aInitData._BurnPercent;
this._rangeAttackMultiplier = aInitData._RangeAttackMultiplier;
this._meleeAttackMultiplier = aInitData._MeleeAttackMultiplier;
this._rangeDefenseMultiplier = aInitData._RangeDefenseMultiplier;
this._meleeDefenseMultiplier = aInitData._MeleeDefenseMultiplier;
this._speedStatMultiplier = aInitData._SpeedStatMultiplier;
this.agilityMultiplier = aInitData._AgilityMultiplier;
this._accuracyMultiplier = aInitData._AccuracyMultiplier;
this._minHitsPerTurn = aInitData._MinHitsPerTurn;
this._maxHitsPerTurn = aInitData._MaxHitsPerTurn;
this._minTurns = aInitData._MinTurns;
this._maxTurns = aInitData._MaxTurns;
this._effectsDuration = aInitData._EffectsDuration;
this._criticalHitChance = aInitData._CriticalHitChance;
this.powerOnlyIfTheseStatusEffects = (EStatusEffects) aInitData._OnlyApplyPowerIfTheirStatusEffect;
switch (aInitData._DamageDistribution) {
case("Standard"):default:this._damageDistribution = EDamageDistributionTypes.Standard;break;
}
this._addsVulnerability = ElementalLibrary.REF.getElement (aInitData._AddVulnerabilityType);
this._changeIfIHaveStatusEffects = aInitData._IfMyStatusEffect;
this._changeToThisIfIHaveStatusEffects = aInitData._DoAlternativeMove;
this._changeIfTheyHaveStatusEffects = aInitData._IfTheirStatusEffect;
this._changeToThisIfIHaveStatusEffects = aInitData._DoAlternativeMove;
this._maxUnlockLevel = (byte) aInitData._MaxUnlockLevel;
this._chanceOfAddVulnerability = aInitData._PercentChangeOfVulnerability;
this._addsInvulnerabilityStatTo = (EMonsterStat) aInitData._AddInvulnerabilityToStatChange;
this._addsInvulnerabilityToStatus = (EStatusEffects) aInitData._AddInvulnerabilityToStatus;
this.isPassiveEffect = aInitData._IsPassiveEffect;
this.decisiveBlowsChangeMultiplier = aInitData._DecisiveBlowsChanceMultiplier;
_selfHitPercent = aInitData._HitMyselfWithThisPercentageOfMove;
removesWeaknessesTo = aInitData._RemovesWeaknessTo;
mirrorStatusEffects = aInitData._MirrorStatusEffects;
this.alsoApplyThisString = aInitData._AlsoApplyThisMove;
this.percentChanceOfFollowOn = aInitData._PercentChanceOfFollowOn;
if(aInitData._Struggle==1) {
isStruggleMove = true;
}
// this.removesWeaknessesTo = aInitData._
// this.agilityMultiplier = aInitData.A
}
