public void RemoveStatBonus(StatBonus toRemove)
{
this.BaseAdditives.Remove(toRemove);
}
public void RemoveStatBonus(StatBonus bonus)
{
bonuses.Remove(bonus);
}
public void AddStatBonus(StatBonus toAdd)
{
this.BaseAdditives.Add(toAdd);
}
public FieldBonus(StatBonus newBonus, int newDuration = 1)
{
this.bonus = newBonus;
this.duration = (newDuration + 1);
this.status = true;
}
public void AddStatBonus(StatBonus bonus)
{
bonuses.Add(bonus);
}
public void AddStatBonus(StatBonus statBonus)
{
this.StatPoints.Add(statBonus);
}
public void Fire()
{
if (FloorData.MaxCooldown > 0 &&
GameManager.Instance.State == GameManager.GameState.Battle &&
!GameManager.Instance.FadeActive)
{
foreach (UpgradeSlot slot in UpgradeSlots)
{
HomeUpgrade item = slot.HomeUpgrade;
if (item != null && item.UpgradeData != null && item.UpgradeData.IsWeapon && item.UpgradeData.BaseDamage != null)
{
if (item.UpgradeData.Sound != Sound.None)
{
SFXPlayer.Instance.Play(item.UpgradeData.Sound, volumeFactor: 0.3f);
}
Home targetHome = FindObjectsOfType <Home>().Where(x => x != MyHome).First();
int baseTargetIndex = Index;
switch (item.UpgradeData.TargetingModule.TargetingType)
{
case TargetTypes.Bottom: baseTargetIndex = 0;
break;
case TargetTypes.Top: baseTargetIndex = targetHome.Floors.Count - 1;
break;
}
List <StatBonus> baseDamage = item.UpgradeData.BaseDamage;
foreach (DamageTypes type in FloorData.DamageBonuses.Keys)
{
for (int i = 0; i < baseDamage.Count; i++)
{
if (baseDamage[i].DamageType == type)
{
baseDamage[i] = new StatBonus(baseDamage[i].DamageType, baseDamage[i].Bonus + FloorData.DamageBonuses[type]);
break;
}
}
baseDamage.Add(new StatBonus(type, FloorData.DamageBonuses[type]));
}
foreach (int targetIndex in item.UpgradeData.TargetingModule.Targets)
{
int projectileTargetIndex = targetIndex + baseTargetIndex;
Projectile proj = Instantiate(ProjectilePrefab).GetComponent <Projectile>();
proj.transform.position = slot.transform.position;
proj.TargetFloorIndex = projectileTargetIndex;
proj.TargetHome = targetHome;
proj.Damage = baseDamage;
}
for (int i = 0; i < item.UpgradeData.TargetingModule.RandomHits; i++)
{
int projectileTargetIndex = Utilities.UtilityFunctions.GetRandomElement(item.UpgradeData.TargetingModule.RandomTargets) + baseTargetIndex;
Projectile proj = Instantiate(ProjectilePrefab).GetComponent <Projectile>();
proj.transform.position = slot.transform.position;
proj.TargetFloorIndex = projectileTargetIndex;
proj.TargetHome = targetHome;
proj.Damage = baseDamage;
}
}
}
}
Cooldown -= FloorData.MaxCooldown;
}
public void AddBonus(StatBonus newBonus)
{
this.cardStatBonus.Add(newBonus);
}
public void RemoveStatBonus(StatBonus statBonus)
{
this.BaseAdditives.Remove(statBonus);
}
public void AddStatBonus(StatBonus statBonus)
{
StatBonuses.Add(statBonus);
}
public void RemoveStatBonus(StatBonus statBonus)
{
StatBonuses.Remove(StatBonuses.Find(x => x.BonusValue == statBonus.BonusValue));
}
public Dictionary <ElementType, float> ScaleSecondaryDamageValue(Actor target, Dictionary <ElementType, MinMaxRange> baseDamage, IEnumerable <GroupType> effectTags)
{
HashSet <GroupType> targetTypes = target.GetActorTagsAsTarget();
Dictionary <BonusType, StatBonus> whenHitBonusDict = new Dictionary <BonusType, StatBonus>();
int[] minDamage = new int[7];
int[] maxDamage = new int[7];
int[] convertedMinDamage = new int[7];
int[] convertedMaxDamage = new int[7];
float[] conversions = new float[7];
HashSet <GroupType> tagsToUse = new HashSet <GroupType>(effectTags);
tagsToUse.UnionWith(GetActorTagsAndDataTags());
foreach (TriggeredEffect triggeredEffect in Data.TriggeredEffects[TriggerType.WHEN_HITTING])
{
if (targetTypes.Contains(triggeredEffect.BaseEffect.restriction) && triggeredEffect.RollTriggerChance())
{
if (whenHitBonusDict.ContainsKey(triggeredEffect.BaseEffect.statBonusType))
{
whenHitBonusDict[triggeredEffect.BaseEffect.statBonusType].AddBonus(triggeredEffect.BaseEffect.statModifyType, triggeredEffect.Value);
}
else
{
StatBonus bonus = new StatBonus();
bonus.AddBonus(triggeredEffect.BaseEffect.statModifyType, triggeredEffect.Value);
whenHitBonusDict.Add(triggeredEffect.BaseEffect.statBonusType, bonus);
}
}
}
foreach (ElementType elementType in Enum.GetValues(typeof(ElementType)))
{
if (!baseDamage.ContainsKey(elementType))
{
baseDamage[elementType] = new MinMaxRange();
}
minDamage[(int)elementType] = baseDamage[elementType].min;
maxDamage[(int)elementType] = baseDamage[elementType].max;
HashSet <BonusType> minTypes = new HashSet <BonusType>();
HashSet <BonusType> maxTypes = new HashSet <BonusType>();
HashSet <BonusType> multiTypes = new HashSet <BonusType>();
Helpers.GetGlobalAndFlatDamageTypes(elementType, tagsToUse, minTypes, maxTypes, multiTypes);
multiTypes.UnionWith(Helpers.GetMultiplierTypes(AbilityType.NON_ABILITY, elementType));
StatBonus minBonus = Data.GetMultiStatBonus(tagsToUse, minTypes.ToArray());
StatBonus maxBonus = Data.GetMultiStatBonus(tagsToUse, maxTypes.ToArray());
StatBonus multiBonus = new StatBonus();
foreach (KeyValuePair <BonusType, StatBonus> keyValue in whenHitBonusDict)
{
if (minTypes.Contains(keyValue.Key))
{
minBonus.AddBonuses(keyValue.Value);
}
else if (maxTypes.Contains(keyValue.Key))
{
maxBonus.AddBonuses(keyValue.Value);
}
else if (multiTypes.Contains(keyValue.Key))
{
multiBonus.AddBonuses(keyValue.Value);
}
}
HashSet <BonusType> availableConversions = Data.BonusesIntersection(null, Helpers.GetConversionTypes(elementType));
if (availableConversions.Count > 0)
{
Array.Clear(conversions, 0, 7);
ActorAbility.GetElementConversionValues(Data, tagsToUse, availableConversions, conversions, null);
MinMaxRange baseRange = ActorAbility.CalculateDamageConversion(Data, convertedMinDamage, convertedMaxDamage, tagsToUse, baseDamage[elementType], conversions, elementType, multiTypes, minBonus, maxBonus, multiBonus);
minDamage[(int)elementType] = baseRange.min;
maxDamage[(int)elementType] = baseRange.max;
}
else
{
Data.GetMultiStatBonus(multiBonus, null, tagsToUse, multiTypes.ToArray());
minDamage[(int)elementType] = (int)Math.Max(multiBonus.CalculateStat(baseDamage[elementType].min + minBonus.CalculateStat(0f)), 0);
maxDamage[(int)elementType] = (int)Math.Max(multiBonus.CalculateStat(baseDamage[elementType].max + maxBonus.CalculateStat(0f)), 0);
}
}
float critChance = Data.GetMultiStatBonus(tagsToUse, BonusType.GLOBAL_CRITICAL_CHANCE).CalculateStat(0f);
bool isCrit = UnityEngine.Random.Range(0f, 100f) < critChance;
Dictionary <ElementType, float> returnDict = new Dictionary <ElementType, float>();
foreach (ElementType elementType in Enum.GetValues(typeof(ElementType)))
{
float damage = UnityEngine.Random.Range(minDamage[(int)elementType] + convertedMinDamage[(int)elementType], maxDamage[(int)elementType] + convertedMaxDamage[(int)elementType] + 1);
if (isCrit)
{
damage *= 1 + (Data.GetMultiStatBonus(tagsToUse, BonusType.GLOBAL_CRITICAL_DAMAGE).CalculateStat(50) / 100f);
}
returnDict.Add(elementType, damage);
}
return(returnDict);
}
public void RemoveBonus(StatBonus bonus)
{
baseAdditives.Remove(baseAdditives.Find(x => x.Value == bonus.Value));
}
public void AddBonus(StatBonus bonus)
{
baseAdditives.Add(bonus);
}
public void AddStatBonus(StatBonus statBonus)
{
this.BaseAdditives.Add(statBonus);
}
public void AddStatBonus(StatBonus statBonus)
{
statAdditives.Add(statBonus);
}
public void RemoveStatBonus(StatBonus statBonus)
{
this.BaseAdditives.Remove(BaseAdditives.Find(x => x.BonusValue == statBonus.BonusValue));
}
public void RemoveStatBonus(StatBonus statBonus)
{
statAdditives.Remove(statAdditives.Find(x => x.BonusValue == statBonus.BonusValue));
}
public void RemoveStatBonus(StatBonus statBonus)
{
this.StatPoints.Remove(StatPoints.Find(x => x.BonusValue == statBonus.BonusValue));
}
public string ToString(int quantity, ItemStringOptions options)
{
StringBuilder builder = new StringBuilder();
// show the quantity
if (options.IsSet(ItemStringOptions.ShowQuantity))
{
if (quantity > 1)
{
builder.Append(quantity.ToString());
builder.Append(" ");
}
else
{
builder.Append("a ");
}
}
// show the prefix power
if ((mPower != null) && mPower.Type.IsPrefix)
{
builder.Append(mPower.Name);
builder.Append(" ");
}
// show the name
if (options.IsSet(ItemStringOptions.ShowQuantity))
{
if (quantity > 1)
{
builder.Append(Type.Noun.Plural);
}
else
{
builder.Append(Type.Noun.Singular);
}
}
else
{
builder.Append(Type.Noun.Singular);
}
// show the suffix power
if ((mPower != null) && !mPower.Type.IsPrefix)
{
builder.Append(" ");
builder.Append(mPower.Name);
}
if (options.IsSet(ItemStringOptions.ShowBonuses))
{
// show the weapon stats
if ((Type.Attack != null) || (StrikeBonus != 0) || (DamageBonus != 1.0f))
{
bool needsSpace = false;
builder.Append(" ^k(^m");
if (Type.Attack != null)
{
builder.Append(Type.Attack.Damage.ToString());
needsSpace = true;
}
if (StrikeBonus != 0)
{
if (needsSpace)
{
builder.Append(" ");
}
builder.Append(StrikeBonus.ToString("+##;-##;0"));
needsSpace = true;
}
if (DamageBonus != 1.0f)
{
if (needsSpace)
{
builder.Append(" ");
}
builder.AppendFormat("x{0}", DamageBonus);
}
builder.Append("^k)^-");
}
// show the armor stats
if ((Type.Armor != 0) || (ArmorBonus != 0))
{
bool needsSpace = false;
builder.Append(" ^k[^m");
if (Type.Armor != 0)
{
builder.Append(Type.Armor.ToString());
needsSpace = true;
}
if (ArmorBonus != 0)
{
if (needsSpace)
{
builder.Append(" ");
}
builder.Append(ArmorBonus.ToString("+##;-##;0"));
}
builder.Append("^k]^-");
}
// show the stat bonus
if (StatBonus != 0)
{
builder.Append(" ^k(^m");
builder.Append(StatBonus.ToString("+##;-##;0"));
builder.Append("^k)^-");
}
// show the speed bonus
if (SpeedBonus != 0)
{
builder.Append(" ^k(^m");
builder.Append(SpeedBonus.ToString("+##;-##;0"));
builder.Append(" speed^k)^-");
}
}
if (options.IsSet(ItemStringOptions.ShowCharges))
{
switch (Type.ChargeType)
{
case ChargeType.Light:
if (mCharges == 0)
{
builder.Append(" ^k(^mempty^k)^-");
}
else if (mCharges > 0)
{
builder.AppendFormat(" ^k(^ylit^m {0} left^k)^-", mCharges);
}
else
{
builder.AppendFormat(" ^k(^m{0} left^k)^-", -mCharges);
}
break;
case ChargeType.Multi:
if (mCharges == 0)
{
builder.Append(" ^k(^mempty^k)^-");
}
else
{
builder.AppendFormat(" ^k(^m{0} charges^k)^-", mCharges);
}
break;
}
}
return(builder.ToString());
}
