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; }
/// <summary> /// /// </summary> /// <param name="from"></param> /// <param name="to"></param> /// <returns> /// 1: Win /// 0: Draw /// -1: Lose /// </returns> public static ElementalResult GetBattleResult(this ElementalType from, ElementalType to) { if (from == ElementalType.Normal) { return(ElementalResult.Draw); } if (from == to) { return(ElementalResult.Draw); } if (from.TryGetWinCase(out var lose) && lose == to) { return(ElementalResult.Win); } if (from.TryGetLoseCase(out var win) && win == to) { return(ElementalResult.Lose); } return(ElementalResult.Draw); }
public override void OnSpellDamage(Mobile attacker, Mobile defender, ElementalType damageType, ref int damage) { if (damageType == ElementalType.Physical) { damage -= (int)(damage * ((double)Value / 100)); } }
public void StartTarget(float duration, Vector2Int pos, float damage, ElementalType ele) { Pos = pos; Damage = damage; Elemental = ele; StartCoroutine(TargetAnim(duration)); }
private void CreateNewData() { AssetDatabase.CreateAsset(_elementalType, "Assets/Scriptable Objects/ElementalTypes/" + _name + ".asset"); AssetDatabase.SaveAssets(); _elementalType = CreateInstance <ElementalType>(); }
public DamagePackage(ElementalType newType, float newDamage, string newName, bool newCrit) { type = newType; damage = newDamage; name = newName; isCrit = newCrit; }
public override bool SetDamage(float damage, ElementalType elemental, bool isCritical, bool isAttackBlocking) { if (CanGetDamage && CharInfo.Health > 0) { return(base.SetDamage(damage, elemental, isCritical)); } return(false); }
protected ItemBase(ItemSheet.Row data) { Id = data.Id; Grade = data.Grade; ItemType = data.ItemType; ItemSubType = data.ItemSubType; ElementalType = data.ElementalType; }
/* public override IEnumerator AttackAction() * { * while (true) * { * while (!CanAttack && !VFXTestMode) * { * yield return null; * } * * while (!VFXTestMode && (BattleManagerScript.Instance.CurrentBattleState != BattleState.Battle || !CanGetDamage)) * { * yield return null; * } * * isAttackStarted = false; * isAttackCompletetd = false; * isAttackGoing = false; * while (!isAttackCompletetd) * { * if (!isAttackStarted) * { * isAttackStarted = true; * isAttackGoing = true; * SetAnimation(CharacterAnimationStateType.Atk); * } * * if (isAttackStarted && !isAttackGoing && !isMoving) * { * isAttackGoing = true; * SetAnimation(CharacterAnimationStateType.Atk); * } * yield return null; * } * * * float timer = 0; * while (timer <= CharInfo.AttackSpeedRatio) * { * yield return new WaitForFixedUpdate(); * while (!VFXTestMode && (BattleManagerScript.Instance.CurrentBattleState == BattleState.Pause)) * { * yield return new WaitForEndOfFrame(); * } * * while (isSpecialLoading) * { * yield return new WaitForEndOfFrame(); * timer = 0; * } * * timer += Time.fixedDeltaTime; * } * } * }*/ public override bool SetDamage(float damage, ElementalType elemental, bool isCritical) { if (CanGetDamage) { return(base.SetDamage(damage, elemental, isCritical)); } return(false); }
public SkillCastingVFX Get(Vector3 position, ElementalType elementalType) { var skillName = $"casting_{elementalType}".ToLower(); var go = _pool.Get(skillName, false, position) ?? _pool.Get(skillName, true, position); return(GetEffect <SkillCastingVFX>(go)); }
public SimpleSkill(string newName, bool newSelfTar, ElementalType newType, float newAPMult, bool newSelfDam = false) { name = newName; selfTar = newSelfTar; selfDam = newSelfDam; type = newType; APMult = newAPMult; CDduration = 0; }
public static IElementalResistance Create(ElementalType elementalType, float amount) { ElementalResistance newElementalResistance = new ElementalResistance(elementalType, amount) { ResistanceInfo = { type = elementalType, value = amount } }; return(newElementalResistance); }
protected override void OnModelCreating(ModelBuilder builder) { base.OnModelCreating(builder); Event.ConfigureForDatabase(builder); Region.ConfigureForDatabase(builder); LocationGroup.ConfigureForDatabase(builder); Location.ConfigureForDatabase(builder); BagCategory.ConfigureForDatabase(builder); Item.ConfigureForDatabase(builder); PlacedItem.ConfigureForDatabase(builder); Currency.ConfigureForDatabase(builder); CurrencyAmount.ConfigureForDatabase(builder); ElementalType.ConfigureForDatabase(builder); ElementalTypeRelation.ConfigureForDatabase(builder); Ability.ConfigureForDatabase(builder); PvpTier.ConfigureForDatabase(builder); PokemonAvailability.ConfigureForDatabase(builder); PokemonVarietyUrl.ConfigureForDatabase(builder); Entities.PokemonSpecies.ConfigureForDatabase(builder); PokemonVariety.ConfigureForDatabase(builder); PokemonForm.ConfigureForDatabase(builder); Evolution.ConfigureForDatabase(builder); MoveDamageClass.ConfigureForDatabase(builder); Move.ConfigureForDatabase(builder); MoveTutor.ConfigureForDatabase(builder); MoveTutorMove.ConfigureForDatabase(builder); MoveTutorMovePrice.ConfigureForDatabase(builder); MoveLearnMethod.ConfigureForDatabase(builder); MoveLearnMethodLocation.ConfigureForDatabase(builder); MoveLearnMethodLocationPrice.ConfigureForDatabase(builder); LearnableMove.ConfigureForDatabase(builder); LearnableMoveLearnMethod.ConfigureForDatabase(builder); TimeOfDay.ConfigureForDatabase(builder); Season.ConfigureForDatabase(builder); SeasonTimeOfDay.ConfigureForDatabase(builder); SpawnType.ConfigureForDatabase(builder); Spawn.ConfigureForDatabase(builder); SpawnOpportunity.ConfigureForDatabase(builder); Nature.ConfigureForDatabase(builder); HuntingConfiguration.ConfigureForDatabase(builder); Build.ConfigureForDatabase(builder); ItemOption.ConfigureForDatabase(builder); MoveOption.ConfigureForDatabase(builder); NatureOption.ConfigureForDatabase(builder); ItemStatBoost.ConfigureForDatabase(builder); Entities.ItemStatBoostPokemon.ConfigureForDatabase(builder); ImportSheet.ConfigureForDatabase(builder); }
public IValue Serialize() => Bencodex.Types.Dictionary.Empty .Add("id", Id) .Add("elemental_type", ElementalType.ToString()) .Add("skill_type", SkillType.ToString()) .Add("skill_category", SkillCategory.ToString()) .Add("skill_target_type", SkillTargetType.ToString()) .Add("hit_count", HitCount) .Add("cooldown", Cooldown);
public IElementalResistance GetResistanceByType(ElementalType typeToCheck) { if (ResistanceTypes.ContainsKey(typeToCheck)) { return(ResistanceTypes[typeToCheck]); } AddResistance(typeToCheck, DefaultValue); return(ResistanceTypes[typeToCheck]); }
public bool addRemovedWeakness(ElementalType aElementalType) { for(int i = 0;i<removedWeaknesses.size;i++) { if(removedWeaknesses[i]==aElementalType) { return false; } } removedWeaknesses.Add(aElementalType); return true; }
public override bool SetDamage(float damage, ElementalType elemental, bool isCritical, bool isAttackBlocking) { if (baseForme.BossPhase == Stage09_Boss_Geisha.bossPhasesType.Monster_ && !isImmune) { bool boolToReturn = base.SetDamage(damage, elemental, isCritical, isAttackBlocking); return(boolToReturn); } return(false); }
public ElementalRayTests() { sorcerer = CharacterTestTemplates.Sorcerer(); type = new ElementalType(); type.EnergyType = "acid"; sorcerer.Add(type); ray = new ElementalRay(); sorcerer.Add(ray); }
/// <summary> /// Creates the skill. /// </summary> /// <param name="number">The number.</param> /// <param name="name">The name of the skill.</param> /// <param name="characterClasses">The character classes.</param> /// <param name="damageType">Type of the damage.</param> /// <param name="damage">The damage.</param> /// <param name="distance">The distance.</param> /// <param name="abilityConsumption">The ability consumption.</param> /// <param name="manaConsumption">The mana consumption.</param> /// <param name="levelRequirement">The level requirement.</param> /// <param name="energyRequirement">The energy requirement.</param> /// <param name="leadershipRequirement">The leadership requirement.</param> /// <param name="elementalModifier">The elemental modifier.</param> /// <param name="skillType">Type of the skill.</param> /// <param name="skillTarget">The skill target.</param> /// <param name="implicitTargetRange">The implicit target range.</param> /// <param name="targetRestriction">The target restriction.</param> /// <param name="movesToTarget">If set to <c>true</c>, the skill moves the player to the target.</param> /// <param name="movesTarget">If set to <c>true</c>, it moves target randomly.</param> /// <param name="cooldownMinutes">The cooldown minutes.</param> protected void CreateSkill( SkillNumber number, string name, CharacterClasses characterClasses = CharacterClasses.None, DamageType damageType = DamageType.None, int damage = 0, short distance = 0, int abilityConsumption = 0, int manaConsumption = 0, int levelRequirement = 0, int energyRequirement = 0, int leadershipRequirement = 0, ElementalType elementalModifier = ElementalType.Undefined, SkillType skillType = SkillType.DirectHit, SkillTarget skillTarget = SkillTarget.Explicit, short implicitTargetRange = 0, SkillTargetRestriction targetRestriction = SkillTargetRestriction.Undefined, bool movesToTarget = false, bool movesTarget = false, int cooldownMinutes = 0) { var skill = this.Context.CreateNew <Skill>(); this.GameConfiguration.Skills.Add(skill); skill.Number = (short)number; skill.Name = name; skill.MovesToTarget = movesToTarget; skill.MovesTarget = movesTarget; skill.AttackDamage = damage; this.CreateSkillRequirementIfNeeded(skill, Stats.Level, levelRequirement); this.CreateSkillRequirementIfNeeded(skill, Stats.TotalLeadership, leadershipRequirement); this.CreateSkillRequirementIfNeeded(skill, Stats.TotalEnergy, energyRequirement); this.CreateSkillConsumeRequirementIfNeeded(skill, Stats.CurrentMana, manaConsumption); this.CreateSkillConsumeRequirementIfNeeded(skill, Stats.CurrentAbility, abilityConsumption); skill.Range = distance; skill.DamageType = damageType; skill.SkillType = skillType; skill.ImplicitTargetRange = implicitTargetRange; skill.Target = skillTarget; skill.TargetRestriction = targetRestriction; var classes = this.GameConfiguration.DetermineCharacterClasses(characterClasses); foreach (var characterClass in classes) { skill.QualifiedCharacters.Add(characterClass); } if (elementalModifier != ElementalType.Undefined) { this.ApplyElementalModifier(elementalModifier, skill); } }
//Constructors. Can pass in all values manually, another weapon to copy, //a WeaponType enmum for randomized values with specified type, or nothing for all randomized vales. /// <summary> /// A weapon with specified stats. /// </summary> /// <param name="name">The name of the weapon. "Iron Sword"</param> /// <param name="description">A quick description. "This sword is somewhat beat up."</param> /// <param name="damageRange">A 2-element array representing the damage range. [min, max]</param> /// <param name="elementalType">The elemental type of the weapon.</param> /// <param name="weaponType">The type of weapon. Range is automatically set based off of this value.</param> /// <param name="health">How much damage the weapon can take.</param> /// <param name="missChance">Chance to miss with this weapon.</param> public Weapon(string name, string description, int[] damageRange, ElementalType elementalType, WeaponType weaponType, int health, int missChance) { this.Name = name; this.Description = description; this.DamageRange = damageRange; this.Element = elementalType; this.Type = weaponType; this.Health = health; this.MissChance = missChance; }
public BetterList<MonsterLibraryRecord> getMonstersOfElement(ElementalType aElementalType) { BetterList<MonsterLibraryRecord> rec = new BetterList<MonsterLibraryRecord>(); for(int i = 0; i < list.size ; i++) { if((list[i].PrimaryElement==aElementalType)||(list[i].SecondaryElement==aElementalType)) { if(list[i].Name!="No Creature") rec.Add(list[i]); } } return rec; }
public float this[ElementalType i] { get { Weakness w = Weaknesses.FirstOrDefault(weakness => weakness.ElementalType == i); if (default(Weakness).Equals(w)) { return(1); } return(w.DamageMultiplier); } }
public float getWeaknessStrengthToElement(ElementalType aOther) { switch(aOther.Name) { case("Earth"):return strengthVsEarth; case("Water"):return strengthVsWater; case("Ice"):return strengthVsIce; case("Air"):return strengthVsAir; case("Fire"):return strengthVsFire; case("Arcane"):return strengthVsArcane; case("Electric"):return strengthVsElectric; } return 1.0f; }
/// <summary> /// Initializes a new instance of the <see cref="Enemy"/> class. /// </summary> /// <param name="newType">New type.</param> /// <param name="newLevel">New level.</param> /// <param name="number">Number</param> public Enemy(ElementalType newType, int newLevel, int number) { type = newType; level = newLevel; health = level * 100000; damageReduction = 11.0F; critChance = level; //Instansiate healthbar with max hp. VisualController._instance.CreateEnemyHealthbar(health); AP = level + number; addAbilities(); }
protected virtual IEnumerator CoAnimationCast(ElementalType elementalType) { var sfxCode = AudioController.GetElementalCastingSFX(elementalType); AudioController.instance.PlaySfx(sfxCode); Animator.Cast(); var pos = transform.position; var effect = Game.instance.Stage.SkillController.Get(pos, elementalType); effect.Play(); yield return(new WaitForSeconds(0.6f)); }
public static IEnumerable <string> GetOptions(this ElementalType from, StatType statType) { if (statType != StatType.ATK && statType != StatType.DEF) { return(new List <string>()); } if (GetOptionsCache.ContainsKey(from) && GetOptionsCache[from].ContainsKey(statType)) { return(GetOptionsCache[from][statType]); } if (!GetOptionsCache.ContainsKey(from)) { GetOptionsCache[from] = new Dictionary <StatType, List <string> >(StatTypeComparer.Instance); } var dict = GetOptionsCache[from]; if (!dict.ContainsKey(statType)) { dict[statType] = new List <string>(); } var list = dict[statType]; if (from == ElementalType.Normal) { return(list); } if (statType == StatType.ATK) { if (from.TryGetWinCase(out var lose)) { var format = L10nManager.Localize("ELEMENTAL_TYPE_OPTION_ATK_WIN_FORMAT"); list.Add(string.Format(format, lose.GetLocalizedString(), ElementalTypeExtension.WinMultiplier - 1)); } } else if (statType == StatType.DEF) { if (from.TryGetLoseCase(out var win)) { var format = L10nManager.Localize("ELEMENTAL_TYPE_OPTION_DEF_LOSE_FORMAT"); list.Add(string.Format(format, win.GetLocalizedString(), ElementalTypeExtension.WinMultiplier - 1)); } } return(list); }
public static GameObject getBGForMonsterType(ElementalType aType) { List<GameBackgroundsRow> all = GameBackgrounds.Instance.Rows; for(int i = 0;i<all.Count;i++) { if(all[i]._DefaultBackgroundFor == aType.Name) { GameObject prefab = UnityEngine.Object.Instantiate(Resources.Load("Battles/Backgrounds/Prefabs/"+all[i]._BackgroundFile)) as GameObject; prefab.GetComponent<Renderer>().sortingLayerName = "BackgroundLayer"; prefab.transform.localPosition = new Vector3(); return prefab; } } return null; }
public int GetResist(ElementalType protectionType) { return(protectionType switch { ElementalType.Water => Get((WaterProtection e) => e.Value), ElementalType.Air => Get((AirProtection e) => e.Value), ElementalType.Physical => Get((PhysicalProtection e) => e.Value), ElementalType.Fire => Get((FireProtection e) => e.Value), ElementalType.Poison => Get((PoisonProtection e) => e.Value), ElementalType.Earth => Get((EarthProtection e) => e.Value), ElementalType.Necro => Get((NecroProtection e) => e.Value), _ => throw new ArgumentOutOfRangeException(nameof(protectionType), protectionType, null) });
public SkillInfo(CharacterBase character, int effect, bool critical, SkillCategory skillCategory, int waveTurn, ElementalType elementalType = ElementalType.Normal, SkillTargetType targetType = SkillTargetType.Enemy, [CanBeNull] Model.Buff.Buff buff = null) { Target = character; Effect = effect; Critical = critical; SkillCategory = skillCategory; ElementalType = elementalType; SkillTargetType = targetType; Buff = buff; WaveTurn = waveTurn; }
public float getWeaknessStrengthToElement(ElementalType aElementalType) { float defaultValue = this.monster.getWeaknessStrengthToElement(aElementalType); if(defaultValue<=1.0f) { return defaultValue; } else { for(int i= 0;i<this.removedWeaknesses.size;i++) { if(removedWeaknesses[i]==aElementalType) { return 1.0f; } } return defaultValue; } }
public void GrantsImmunitiesBasedOnElementType() { var sorcerer = CharacterTestTemplates.Sorcerer(); var elementType = new ElementalType(); elementType.EnergyType = "acid"; sorcerer.Add(elementType); sorcerer.Add(new ElementalBody()); AssertCharacter.IsImmuneTo("acid", sorcerer); AssertCharacter.IsImmuneTo("sneak attacks", sorcerer); AssertCharacter.IsImmuneTo("critical hits", sorcerer); }
public void SetAttack(float duration, Vector2Int pos, float damage, ElementalType ele, BaseCharacter attacker, List <ScriptableObjectAttackEffect> atkEffects, float effectChances) { GameObject nextT = TargetIndicatorManagerScript.Instance.GetTargetIndicator(AttackType.Tile); nextT.SetActive(true); TargetClass tc = new TargetClass(duration, nextT); nextT.transform.parent = transform; nextT.transform.localPosition = TargetsPosition[0]; Targets.Add(tc); UpdateQueue(); StartCoroutine(FireTarget(tc, pos, damage, ele, attacker, atkEffects, effectChances)); }
public void OnEnemyHitPlayerElemental(int damage, ElementalType damageType) { float mod = 1; if (Player.Armor.Value.ElementalWeakness.Value != null) { mod = Player.Armor.Value.ElementalWeakness.Value[damageType]; } float fdamage = damage * mod; damage = Mathf.RoundToInt(fdamage); Player.DamagePlayer(damage); PlayerDamageNumberSpawner.SpawnNumber(damage, damageType.DamageColor); }
public void CanChangeEnergyDamageToTypeOfElemental() { var sorcerer = CharacterTestTemplates.Sorcerer(); var elementalType = new ElementalType(); elementalType.EnergyType = "cold"; sorcerer.Add(elementalType); var arcana = new ElementalArcana(); sorcerer.Add(arcana); Assert.Equal("change energy damage spells to cold", arcana.BonusAbility); }
} //calvin's tips //Helper function, turns ElementalType into string - calvin's tips public string typeToString(ElementalType type) { string returnstring = ""; switch ((int)type) { case 0: returnstring = "Air"; break; case 1: default: Debug.Log("Something broke"); break; } return(returnstring); }
private void EvaluateState(ElementalType elementalType) { if (currentState == UnitStates.Checkmate) { return; } var tryGetElement = unitBase._elementalWeaknesses.Any (kvp => kvp.Key._type == elementalType); if (tryGetElement) { EvaluateShield(); } }
public float getEffectOnAttackPower(ERangedStatus aRangedStatus,ElementalType aElementType) { bool elementPassed = false; if(this.moveRef.elementType==ElementalLibrary.REF.getElement("Normal")) { elementPassed = true; } else { if(this.moveRef.elementType==aElementType) { elementPassed = true; } } if(elementPassed) { if(aRangedStatus==ERangedStatus.Melee) { return this.moveRef.meleeAttackMultiplier; } if(aRangedStatus==ERangedStatus.Ranged) { return this.moveRef.rangeAttackMultiplier; } } return 1.0f; }
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; }
public MonsterLibraryRecord(TMMonstersRow aInitData) { _id = aInitData._ID; _name = aInitData._Name; _description = aInitData._Description; _evolvesToID = aInitData._EvolvesTo; _primaryElement = ElementalLibrary.REF.getElement (aInitData._PrimaryElement); _secondaryElement = ElementalLibrary.REF.getElement (aInitData._SecondaryElement); _evolvesAt = Convert.ToByte( aInitData._EvolvesAt); _hp = aInitData._HP; _hpPerLevel = aInitData._HPPerLevel; _meleeAttack = aInitData._MeleeAttack; _meleeDefense = aInitData._MeleeDefense; _rangeAttack = aInitData._RangeAttack; _rangeDefense = aInitData._RangeDefense; _speed = aInitData._Speed; // _resistance = aInitData._resistance; _accuracy = aInitData._Accuracy; _agility = aInitData._Agility; _meleeAttackPerLevel = aInitData._MeleeAttackPerLevel; _meleeDefensePerLevel = aInitData._MeleeDefensePerLevel; _rangeAttackPerLevel = aInitData._RangeAttackPerLevel; _rangeDefensePerLevel = aInitData._RangeDefensePerLevel; _energy = aInitData._Energy; _energyPerLevel = aInitData._EnergyPerLevel; this._accuracyPerLevel = aInitData._AccuracyPerLevel; _speedPerLevel = aInitData._SpeedPerLevel; _catchRate = aInitData._CatchRate; _moveTree1 = MoveTreeLibrary.REF.GetMoveTree (aInitData._MoveTree1); _moveTree2 = MoveTreeLibrary.REF.GetMoveTree (aInitData._MoveTree2); _moveTree3 = MoveTreeLibrary.REF.GetMoveTree (aInitData._MoveTree3); _moveTree4 = MoveTreeLibrary.REF.GetMoveTree (aInitData._MoveTree4); passiveClass = aInitData._PassiveEffectClasses; _expVal = aInitData._BaseExperienceYield; _xpDevModel = XPDevModelLib.REF.getXPDevModel (aInitData._XPDevModel); this.companionAString = aInitData._CompanionA; this.companionBString = aInitData._CompanionB; this.companionALevelDiff = aInitData._CompanionALevelDiff; this.companionBLevelDiff = aInitData._CompanionBLevelDiff; }
public Effect(ActionComponent actionComponent, Character _sourceUnit, Character _targetUnit) { hitType = actionComponent.hitType; elementalType = actionComponent.elementalType; effectType = actionComponent.effectType; basePower = actionComponent.basePower; baseToHit = actionComponent.baseToHit; duration = actionComponent.duration; priPowerStat = actionComponent.priPowerStat; priPowerWeight = actionComponent.priPowerWeight; secPowerStat = actionComponent.secPowerStat; secPowerWeight = actionComponent.secPowerWeight; priResistStat = actionComponent.priResistStat; priResistWeight = actionComponent.priResistWeight; secResistStat = actionComponent.secResistStat; secResistWeight = actionComponent.secResistWeight; sourceUnit = _sourceUnit; targetUnit = _targetUnit; sourcePowerStat = GetStatPower(_sourceUnit); }
private void showMonsters(ElementalType aElementType) { StartCoroutine(spreadCreation (0)); }
public AdditionalWeaknesses (ElementalType aElement,byte aTurns) { _weakness = aElement; _turns = aTurns; }
public void addEffect(ElementalType aElementType,byte aTurns) { if(aTurns==0) { aTurns = 255; } for(byte c = 0;c < this._extraWeaknesses.size;c++) { if(_extraWeaknesses[c].type.ID==aElementType.ID) { if(_extraWeaknesses[c].turnsRemaining<aTurns) { _extraWeaknesses[c].turnsRemaining = aTurns; } return; } } _extraWeaknesses.Add(new AdditionalWeaknesses(aElementType,aTurns)); }
public float hasElementWeakness(ElementalType aElement) { for(byte c = 0;c<_extraWeaknesses.size;c++) { _extraWeaknesses[c].turnsRemaining--; if(_extraWeaknesses[c].turnsRemaining<0) { _extraWeaknesses.RemoveAt(c); c--; } } for(byte c = 0;c<_extraWeaknesses.size;c++) { if(_extraWeaknesses[c].type.ID==aElement.ID) { return 2f; } } return 0.0f; }
public void LoadMiniGames(ElementalType miniGame1, ElementalType miniGame2 = ElementalType.None) { MiniGameManager.Instance.LoadMiniGames(miniGame1, miniGame2); }
public void StartScene(int sceneId, ElementalType elementalType) { if(sceneId == 2) { mInitialElement = elementalType; } Application.LoadLevel(sceneId); }
public BetterList<BattleMonster> listContainsElement(ElementalType aElement,BetterList<BattleMonster> aMonster) { BetterList<BattleMonster> r = new BetterList<BattleMonster>(); for(int i = 0;i<aMonster.size;i++) { if(aElement == aMonster[i].monster.elementType) { r.Add(aMonster[i]); } } return r; }
public ActionComponent(Dictionary<string,string> data) { /* foreach(KeyValuePair<string, string> e in data) { Debug.Log(e.Key.ToString() + " : " + e.Value.ToString()); } */ executionOrder = int.Parse(data["Component"]); targetType = (TargetType)System.Enum.Parse(typeof(TargetType), data["TargetType"].ToString()); hitType = (HitType)System.Enum.Parse(typeof(HitType), data["HitType"].ToString()); elementalType = (ElementalType)System.Enum.Parse(typeof(ElementalType), data["ElementalType"].ToString()); effectType = (EffectType)System.Enum.Parse(typeof(EffectType), data["EffectType"].ToString()); basePower = float.Parse(data["BasePower"]); baseToHit = float.Parse(data["BaseToHit"]); duration = int.Parse(data["Duration"]); string[] powerStats = data["PowerStats"].Split(char.Parse(",")); priPowerStat = (StatType)System.Enum.Parse(typeof(StatType), powerStats[0].ToString()); if(powerStats.Length > 1) { secPowerStat = (StatType)System.Enum.Parse(typeof(StatType), powerStats[1].ToString()); } priPowerWeight = float.Parse(data["PrimaryPowerStatWeight"]); secPowerWeight = 1f - priPowerWeight; string[] resistStats = data["DefenseStats"].Split(char.Parse(",")); priResistStat = (StatType)System.Enum.Parse(typeof(StatType), resistStats[0].ToString()); if(resistStats.Length > 1) { secResistStat = (StatType)System.Enum.Parse(typeof(StatType), resistStats[1].ToString()); } priResistWeight = float.Parse(data["PrimaryDefenseStatWeight"]); secResistWeight = 1f - priResistWeight; }
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 }