public BuffExample () {
name = "Example buff";
buffType = BuffType.Timed;
timeOfBuff = 5.0f;
timeOfBuffRemaining = 5.0f;
statModifiers = new StatModifier[2];
statModifiers[0] = new StatModifier(Stat.AttackSpeed, 5.0f);
statModifiers[1] = new StatModifier(Stat.MovementSpeed, 5.0f);
}
public override void Start()
{
_statModifier = new StatModifier<LilithStats>();
_statModifier.Target = AppliesToMax ? StatModifierTarget.Max : StatModifierTarget.Current;
_statModifier.Value = Adjustment;
_statModifier.Type = IsMultiplicative ? StatModifierType.Multiplicative : StatModifierType.Additive;
Stat.AddModifier(_statModifier);
TimedTaskManager.Instance.Add(Duration * 1000, () =>
{
Finish();
});
base.Start();
}
public void AddModifierToStat()
{
string name = "sdsd";
float value = 10.0f;
Stat stat = new Stat(name, value);
float modValue = 5.0f;
string modName = "fsdhnuh";
StatModifier mod = new StatModifier(modName, modValue);
stat.AddModifier(mod);
Assert.IsTrue(stat.Name == name);
Assert.IsTrue(stat.BaseValue == value);
Assert.IsTrue(stat.TotalValue == modValue + value);
}
public void AddStatModifier(BaseStatModifierType _statModifierType, float _timeExpired, float _param)
{
StatModifier statModifier;
if (Contains(_statModifierType))
{
statModifier = statModifierStocks.Find(x => x.stateModifierType == _statModifierType);
}
else
{
statModifier = new StatModifier();
}
statModifier.timeExpired = _timeExpired + Time.time;
statModifier.stateModifierType = _statModifierType;
statModifier.param = _param;
//
statModifierStocks.Add(statModifier);
}
public void AddModifier(StatModifier mod)
{
modList.Add(mod);
mod.OnValueChange += OnModValueChange;
}
protected override void Update()
{
if (m_poisonImmunity == null)
{
m_poisonImmunity = new DamageTypeModifier();
m_poisonImmunity.damageMultiplier = 0f;
m_poisonImmunity.damageType = CoreDamageTypes.Poison;
}
if (m_fireImmunity == null)
{
m_fireImmunity = new DamageTypeModifier();
m_fireImmunity.damageMultiplier = 0f;
m_fireImmunity.damageType = CoreDamageTypes.Fire;
}
if (m_electricityImmunity == null)
{
m_electricityImmunity = new DamageTypeModifier();
m_electricityImmunity.damageMultiplier = 0f;
m_electricityImmunity.damageType = CoreDamageTypes.Electric;
}
if (machoDamageMod == null)
{
machoDamageMod = new StatModifier();
machoDamageMod.statToBoost = PlayerStats.StatType.Damage;
machoDamageMod.modifyType = StatModifier.ModifyMethod.MULTIPLICATIVE;
machoDamageMod.amount = 1.3f;
}
if (this.m_extantOrbital != null && this.Owner != null)
{
if (this.m_extantOrbital.GetComponent <PlayerOrbital>().orbitRadius != overrideOrbitalDistance)
{
this.m_extantOrbital.GetComponent <PlayerOrbital>().orbitRadius = overrideOrbitalDistance;
}
if (this.m_extantOrbital.GetComponent <PlayerOrbital>().orbitDegreesPerSecond != overrideOrbitalSpeed)
{
this.m_extantOrbital.GetComponent <PlayerOrbital>().orbitDegreesPerSecond = overrideOrbitalSpeed;
}
if (this.m_extantOrbital.GetComponent <PlayerOrbital>().perfectOrbitalFactor != overridePerfectOrbitalFactor)
{
this.m_extantOrbital.GetComponent <PlayerOrbital>().perfectOrbitalFactor = overridePerfectOrbitalFactor;
}
if (this.m_extantOrbital.GetComponent <tk2dSprite>().renderer.material.shader != ShaderCache.Acquire("Brave/Internal/RainbowChestShader"))
{
this.m_extantOrbital.GetComponent <tk2dSprite>().sprite.renderer.material.shader = ShaderCache.Acquire("Brave/Internal/RainbowChestShader");
this.m_extantOrbital.GetComponent <tk2dSprite>().sprite.renderer.material.SetFloat("_AllColorsToggle", 1f);
}
if (canReselectGuonState && Owner)
{
canReselectGuonState = false;
ReSelectGuonState();
Invoke("resetGuonStateCooldown", 5f);
}
if (Owner && Owner.IsInCombat && Owner.specRigidbody.Velocity == Vector2.zero && canFireCyanProjectile)
{
if (RandomlySelectedGuonState == GuonState.CYAN)
{
FireProjectileFromGuon(CyanGuonStone.cyanGuonProj.gameObject, true, true, 1, 0, 5, true);
canFireCyanProjectile = false;
if (Owner.PlayerHasActiveSynergy("Rainbower Guon Stone"))
{
Invoke("resetCyanFireCooldown", 0.16f);
}
else
{
Invoke("resetCyanFireCooldown", 0.35f);
}
}
}
if (Owner && Owner.IsInCombat && canFireOrangeProjectile)
{
if (RandomlySelectedGuonState == GuonState.ORANGE)
{
canFireOrangeProjectile = false;
if (Owner.PlayerHasActiveSynergy("Rainbower Guon Stone"))
{
FireProjectileFromGuon(mockOrangeGuonProj.gameObject, true, true, 1.6f);
Invoke("resetOrangeFireCooldown", 0.5f);
}
else
{
FireProjectileFromGuon(mockOrangeGuonProj.gameObject, true, true, 1);
Invoke("resetOrangeFireCooldown", 1f);
}
}
}
}
base.Update();
}
public override void CompPostTick(ref float severityAdjustment)
{
if (this.Pawn.Spawned && !this.Pawn.Dead && !this.Pawn.Downed)
{
base.CompPostTick(ref severityAdjustment);
if (base.Pawn != null & base.parent != null)
{
if (!initialized)
{
initialized = true;
this.Initialize();
}
}
CompAbilityUserMight comp = this.Pawn.GetComp <CompAbilityUserMight>();
if (this.doPsionicAttack)
{
this.ticksTillPsionicStrike--;
if (this.ticksTillPsionicStrike <= 0)
{
this.doPsionicAttack = false;
MightPowerSkill ver = comp.MightData.MightPowerSkill_PsionicAugmentation.FirstOrDefault((MightPowerSkill x) => x.label == "TM_PsionicAugmentation_ver");
if (!threat.Destroyed && !threat.Dead)
{
TM_MoteMaker.MakePowerBeamMotePsionic(threat.DrawPos.ToIntVec3(), threat.Map, 2f, 2f, .7f, .1f, .6f);
DamageInfo dinfo2 = new DamageInfo(TMDamageDefOf.DamageDefOf.TM_PsionicInjury, Rand.Range(6, 12) + (2 * ver.level), 0, -1, this.Pawn, null, null, DamageInfo.SourceCategory.ThingOrUnknown, this.threat);
this.threat.TakeDamage(dinfo2);
}
}
}
if (Find.TickManager.TicksGame % 60 == 0)
{
severityAdjustment += (this.Pawn.GetStatValue(StatDefOf.PsychicSensitivity, false) * Rand.Range(.04f, .12f));
if (Find.Selector.FirstSelectedObject == this.Pawn)
{
HediffStage hediffStage = this.Pawn.health.hediffSet.GetFirstHediffOfDef(HediffDef.Named("TM_PsionicHD"), false).CurStage;
hediffStage.label = this.parent.Severity.ToString("0.00") + "%";
}
Hediff hediff = this.Pawn.health.hediffSet.GetFirstHediffOfDef(TorannMagicDefOf.TM_Artifact_PsionicBoostHD);
float maxSev = 100;
if (hediff != null)
{
maxSev += hediff.Severity;
}
this.parent.Severity = Mathf.Clamp(this.parent.Severity, 0, maxSev);
}
if (comp.usePsionicAugmentationToggle)
{
if (Find.TickManager.TicksGame % 600 == 0 && !this.Pawn.Drafted)
{
if (this.parent.Severity >= 95 && this.Pawn.CurJob.targetA.Thing != null)
{
DeterminePsionicHD();
if ((this.Pawn.Position - this.Pawn.CurJob.targetA.Thing.Position).LengthHorizontal > 20 && (this.Pawn.Position - this.Pawn.CurJob.targetA.Thing.Position).LengthHorizontal < 300 && this.Pawn.CurJob.locomotionUrgency >= LocomotionUrgency.Jog && this.Pawn.CurJob.bill == null)
{
this.parent.Severity -= 10f;
if (this.EffVal == 0)
{
HealthUtility.AdjustSeverity(this.Pawn, HediffDef.Named("TM_PsionicSpeedHD"), 1f + .02f * this.EffVal);
}
else if (this.EffVal == 1)
{
HealthUtility.AdjustSeverity(this.Pawn, HediffDef.Named("TM_PsionicSpeedHD_I"), 1f + .02f * this.EffVal);
}
else if (this.EffVal == 2)
{
HealthUtility.AdjustSeverity(this.Pawn, HediffDef.Named("TM_PsionicSpeedHD_II"), 1f + .02f * this.EffVal);
}
else
{
HealthUtility.AdjustSeverity(this.Pawn, HediffDef.Named("TM_PsionicSpeedHD_III"), 1f + .02f * this.EffVal);
}
for (int i = 0; i < 12; i++)
{
float direction = Rand.Range(0, 360);
TM_MoteMaker.ThrowGenericMote(ThingDef.Named("Mote_Psi"), this.Pawn.DrawPos, this.Pawn.Map, Rand.Range(.1f, .4f), 0.2f, .02f, .1f, 0, Rand.Range(8, 10), direction, direction);
}
comp.MightUserXP += Rand.Range(10, 15);
}
if (this.Pawn.CurJob.targetA.Thing != null)
{
if ((this.Pawn.Position - this.Pawn.CurJob.targetA.Thing.Position).LengthHorizontal < 2 && (this.Pawn.CurJob.bill != null || this.Pawn.CurJob.def.defName == "Sow" || this.Pawn.CurJob.def.defName == "FinishFrame" || this.Pawn.CurJob.def.defName == "Deconstruct" || this.Pawn.CurJob.def.defName == "Repair" || this.Pawn.CurJob.def.defName == "Clean" || this.Pawn.CurJob.def.defName == "Mine" || this.Pawn.CurJob.def.defName == "SmoothFloor" || this.Pawn.CurJob.def.defName == "SmoothWall" || this.Pawn.CurJob.def.defName == "Harvest" || this.Pawn.CurJob.def.defName == "HarvestDesignated" || this.Pawn.CurJob.def.defName == "CutPlant" || this.Pawn.CurJob.def.defName == "CutPlantDesignated"))
{
this.parent.Severity -= 12f;
if (this.PwrVal == 0)
{
HealthUtility.AdjustSeverity(this.Pawn, HediffDef.Named("TM_PsionicManipulationHD"), 1f + .02f * this.PwrVal);
}
else if (this.PwrVal == 1)
{
HealthUtility.AdjustSeverity(this.Pawn, HediffDef.Named("TM_PsionicManipulationHD_I"), 1f + .02f * this.PwrVal);
}
else if (this.PwrVal == 2)
{
HealthUtility.AdjustSeverity(this.Pawn, HediffDef.Named("TM_PsionicManipulationHD_II"), 1f + .02f * this.PwrVal);
}
else
{
HealthUtility.AdjustSeverity(this.Pawn, HediffDef.Named("TM_PsionicManipulationHD_III"), 1f + .02f * this.PwrVal);
}
for (int i = 0; i < 12; i++)
{
float direction = Rand.Range(0, 360);
TM_MoteMaker.ThrowGenericMote(ThingDef.Named("Mote_Psi"), this.Pawn.DrawPos, this.Pawn.Map, Rand.Range(.1f, .4f), 0.2f, .02f, .1f, 0, Rand.Range(8, 10), direction, direction);
}
comp.MightUserXP += Rand.Range(10, 15);
}
}
}
}
if (this.parent.Severity >= 20)
{
DeterminePsionicHD();
if (Find.TickManager.TicksGame % 180 == 0 && (this.Pawn.Drafted || !this.Pawn.IsColonist) && ((this.Pawn.equipment.Primary != null && !this.Pawn.equipment.Primary.def.IsRangedWeapon) || this.Pawn.equipment.Primary == null))
{
if (this.Pawn.CurJob.targetA.Thing != null && this.Pawn.CurJob.targetA.Thing is Pawn)
{
//Log.Message("performing psionic dash - curjob " + this.Pawn.CurJob);
//Log.Message("curjob def " + this.Pawn.CurJob.def.defName);
//Log.Message("target " + this.Pawn.CurJob.targetA.Thing);
//Log.Message("target range " + (this.Pawn.CurJob.targetA.Thing.Position - this.Pawn.Position).LengthHorizontal);
Pawn targetPawn = this.Pawn.CurJob.targetA.Thing as Pawn;
float targetDistance = (this.Pawn.Position - targetPawn.Position).LengthHorizontal;
if (targetDistance > 3 && targetDistance < (12 + EffVal) && targetPawn.Map != null && !targetPawn.Downed)
{
for (int i = 0; i < 12; i++)
{
float direction = Rand.Range(0, 360);
TM_MoteMaker.ThrowGenericMote(ThingDef.Named("Mote_Psi"), this.Pawn.DrawPos, this.Pawn.Map, Rand.Range(.1f, .4f), 0.2f, .02f, .1f, 0, Rand.Range(8, 10), direction, direction);
}
FlyingObject_PsionicLeap flyingObject = (FlyingObject_PsionicLeap)GenSpawn.Spawn(ThingDef.Named("FlyingObject_PsionicLeap"), this.Pawn.Position, this.Pawn.Map);
flyingObject.Launch(this.Pawn, this.Pawn.CurJob.targetA.Thing, this.Pawn);
HealthUtility.AdjustSeverity(this.Pawn, HediffDef.Named("TM_PsionicHD"), -3f);
comp.Stamina.CurLevel -= .03f;
comp.MightUserXP += Rand.Range(20, 30);
}
}
}
if (this.nextPsionicAttack < Find.TickManager.TicksGame && this.Pawn.Drafted)
{
if (this.Pawn.CurJob.def != TorannMagicDefOf.JobDriver_PsionicBarrier && VerVal > 0)
{
this.threat = TM_Calc.FindNearbyEnemy(this.Pawn, 20 + (2 * verVal)); // GetNearbyTarget(20 + (2 * VerVal));
if (threat != null)
{
//start psionic attack; ends after delay
SoundInfo info = SoundInfo.InMap(new TargetInfo(this.Pawn.Position, this.Pawn.Map, false), MaintenanceType.None);
TorannMagicDefOf.TM_Implosion.PlayOneShot(info);
Effecter psionicAttack = TorannMagicDefOf.TM_GiantExplosion.Spawn();
psionicAttack.Trigger(new TargetInfo(threat.Position, threat.Map, false), new TargetInfo(threat.Position, threat.Map, false));
psionicAttack.Cleanup();
for (int i = 0; i < 12; i++)
{
float direction = Rand.Range(0, 360);
TM_MoteMaker.ThrowGenericMote(ThingDef.Named("Mote_Psi"), this.Pawn.DrawPos, this.Pawn.Map, Rand.Range(.1f, .4f), 0.2f, .02f, .1f, 0, Rand.Range(8, 10), direction, direction);
}
float weaponModifier = 1;
if (this.Pawn.equipment.Primary != null)
{
if (this.Pawn.equipment.Primary.def.IsRangedWeapon)
{
StatModifier wpnMass = this.Pawn.equipment.Primary.def.statBases.FirstOrDefault((StatModifier x) => x.stat.defName == "Mass");
weaponModifier = Mathf.Clamp(wpnMass.value, .8f, 6);
}
else //assume melee weapon
{
StatModifier wpnMass = this.Pawn.equipment.Primary.def.statBases.FirstOrDefault((StatModifier x) => x.stat.defName == "Mass");
weaponModifier = Mathf.Clamp(wpnMass.value, .6f, 5);
}
}
else //unarmed
{
weaponModifier = .4f;
}
this.nextPsionicAttack = Find.TickManager.TicksGame + (int)(Mathf.Clamp((600 - (60 * verVal)) * weaponModifier, 120, 900));
float energyCost = Mathf.Clamp((10f - VerVal) * weaponModifier, 2f, 12f);
HealthUtility.AdjustSeverity(this.Pawn, HediffDef.Named("TM_PsionicHD"), -energyCost);
comp.MightUserXP += Rand.Range(8, 12);
this.doPsionicAttack = true;
this.ticksTillPsionicStrike = 24;
}
}
}
}
}
}
}
// Token: 0x06000005 RID: 5 RVA: 0x00002160 File Offset: 0x00000360
private StatModifier GetStatModifier(StatRequest req)
{
EquipmentRequirementModifiers eqMods = new EquipmentRequirementModifiers();
Thing thing;
bool flag = (thing = req.Thing) != null && (eqMods = thing.def.GetModExtension <EquipmentRequirementModifiers>()) != null;
StatModifier result;
if (flag)
{
StatModifier statModifier = eqMods.modifyTheseStats.FirstOrDefault((StatModifier modifier) => modifier.stat == this.parentStat);
bool flag2 = statModifier == null;
if (flag2)
{
result = null;
}
else
{
Pawn pawn = null;
ThingOwner holdingOwner = thing.holdingOwner;
Pawn_EquipmentTracker pawn_EquipmentTracker;
bool flag3 = (pawn_EquipmentTracker = (((holdingOwner != null) ? holdingOwner.Owner : null) as Pawn_EquipmentTracker)) != null;
if (flag3)
{
pawn = pawn_EquipmentTracker.pawn;
}
else
{
ThingOwner holdingOwner2 = thing.holdingOwner;
Pawn_ApparelTracker pawn_ApparelTracker;
bool flag4 = (pawn_ApparelTracker = (((holdingOwner2 != null) ? holdingOwner2.Owner : null) as Pawn_ApparelTracker)) != null;
if (flag4)
{
pawn = pawn_ApparelTracker.pawn;
}
}
bool flag5 = pawn == null;
if (flag5)
{
result = null;
}
else
{
bool flag6 = !eqMods.requireAnyOfTheseRaces.NullOrEmpty <string>();
if (flag6)
{
bool flag7 = eqMods.requireAnyOfTheseRaces.Contains(pawn.def.defName);
if (flag7)
{
return(null);
}
}
bool flag8 = !eqMods.requireAnyOfTheseHediffs.NullOrEmpty <string>();
if (flag8)
{
bool flag9 = pawn.health.hediffSet.hediffs.Any((Hediff hediff) => eqMods.requireAnyOfTheseHediffs.Contains(hediff.def.defName));
if (flag9)
{
return(null);
}
}
bool flag10 = !eqMods.requireAnyOfTheseApparels.NullOrEmpty <string>() && pawn.apparel != null;
if (flag10)
{
bool flag11 = pawn.apparel.WornApparel.Any((Apparel apparel) => eqMods.requireAnyOfTheseApparels.Contains(apparel.def.defName));
if (flag11)
{
return(null);
}
}
result = statModifier;
}
}
}
else
{
result = null;
}
return(result);
}
/// <summary>
/// Add a modifier to the end of the stack. This will recompute the Stats so it now include the new modifier.
/// </summary>
/// <param name="modifier"></param>
public void AddModifier(StatModifier modifier)
{
m_ModifiersStack.Add(modifier);
UpdateFinalStats();
}
public abstract void RemoveStatModifier(StatType statusType, StatModifier statModifier);
generateEffect(EffectType type, float modifier, bool affectsCaster,
StatModifier statMod, IEnumerable<Effect> causedEffects)
{
switch(type)
{
case EffectType.Increase:
return (c1, c2, dt, v) => v + modifier;
case EffectType.Multiply:
return (c1, c2, dt, v) => v * modifier;
case EffectType.DamageOrHeal:
if(affectsCaster)
return (c1, c2, dt, v) =>
{
c1.DamageOrHeal(c1, modifier, dt, false);
return v;
};
else
return (c1, c2, dt, v) =>
{
c1.DamageOrHeal(c2, modifier, dt, false);
return v;
};
case EffectType.DamageOrHealUnmodified:
if(affectsCaster)
return (c1, c2, dt, v) =>
{
c1.AttackTarget(c1, modifier, dt);
return v;
};
else
return (c1, c2, dt, v) =>
{
c1.AttackTarget(c2, modifier, dt);
return v;
};
case EffectType.ModifySecondary:
if(affectsCaster)
return (c1, c2, dt, v) =>
{
c1.ModifySecondary(c1, modifier, dt, false);
return v;
};
else
return (c1, c2, dt, v) =>
{
c2.ModifySecondary(c2, modifier, dt, false);
return v;
};
case EffectType.ApplyStatModifier:
if(affectsCaster)
return (c1, c2, dt, v) =>
{
c1.AddModifier(statMod);
return v;
};
else
return (c1, c2, dt, v) =>
{
c2.AddModifier(statMod);
return v;
};
case EffectType.RemoveStatModifier:
if(affectsCaster)
return (c1, c2, dt, v) =>
{
c1.RemoveModifier(statMod);
return v;
};
else
return (c1, c2, dt, v) =>
{
c2.RemoveModifier(statMod);
return v;
};
case EffectType.CallEffect:
return (c1, c2, dt, v) =>
{
foreach(Effect causedEffect in causedEffects)
causedEffect.Call(c1, c2, dt, v);
return v;
};
default:
return (c1, c2, dt, v) => v;
}
}
public void CreateStatModifier()
{
float Value = 10.0f;
string Name = "fsdhnuh";
StatModifier mod = new StatModifier(Name, Value);
Assert.IsTrue(mod.Value == Value);
Assert.IsTrue(mod.Name == Name);
}
public void AddModifier(StatModifier mod)
{
Modifiers.Add(mod);
}
IEnumerator ExpireCumulativeMod(ModifiableStat ms, StatModifier mod, float expireyTime)
{
yield return(new WaitForSeconds(expireyTime));
ms.RemoveModifier(mod);
}
public virtual void AddModifier(StatModifier mod)
{
IsDirty = true;
StatModifiers.Add(mod);
}
private void HandleRandomEffect(PlayerController player)
{
if (m_PickedUp | AllowedEffects == null | AllowedEffects.Count <= 0)
{
return;
}
ExpandShaders.Instance.GlitchScreenForDuration();
AllowedEffects = AllowedEffects.Shuffle();
m_SelectedEffect = BraveUtility.RandomElement(AllowedEffects);
if (m_SelectedEffect == ItemEffectType.ArmorUp)
{
player.healthHaver.Armor += 10f;
}
else if (m_SelectedEffect == ItemEffectType.BigCash)
{
player.carriedConsumables.Currency = 999;
}
else if (m_SelectedEffect == ItemEffectType.ManyKeys)
{
player.carriedConsumables.KeyBullets = 999;
}
else if (m_SelectedEffect == ItemEffectType.BlanksRUS)
{
PickupObject blankPickup = PickupObjectDatabase.GetById(224);
for (int i = 0; i < UnityEngine.Random.Range(5, 10); i++)
{
if (blankPickup)
{
LootEngine.GivePrefabToPlayer(blankPickup.gameObject, player);
}
}
}
else if (m_SelectedEffect == ItemEffectType.HealthPak)
{
if (player.characterIdentity != PlayableCharacters.Robot)
{
StatModifier healthUp = new StatModifier()
{
statToBoost = PlayerStats.StatType.Health,
amount = UnityEngine.Random.Range(4, 6),
modifyType = StatModifier.ModifyMethod.ADDITIVE,
isMeatBunBuff = false,
};
player.ownerlessStatModifiers.Add(healthUp);
player.stats.RecalculateStats(player, false, false);
}
else
{
player.healthHaver.Armor += UnityEngine.Random.Range(4, 6);
}
}
else if (m_SelectedEffect == ItemEffectType.DrStone)
{
PickupObject glassStone = PickupObjectDatabase.GetById(565);
for (int i = 0; i < UnityEngine.Random.Range(8, 12); i++)
{
if (glassStone)
{
LootEngine.GivePrefabToPlayer(glassStone.gameObject, player);
}
}
}
else if (m_SelectedEffect == ItemEffectType.MuchAmmo)
{
StatModifier ManyBullets = new StatModifier()
{
statToBoost = PlayerStats.StatType.AmmoCapacityMultiplier,
amount = UnityEngine.Random.Range(1.5f, 3),
modifyType = StatModifier.ModifyMethod.MULTIPLICATIVE,
isMeatBunBuff = false,
};
player.ownerlessStatModifiers.Add(ManyBullets);
player.stats.RecalculateStats(player, false, false);
}
return;
}
public void AddModifier(StatModifier mod)
{
isModded = true;
statModifiers.Add(mod);
statModifiers.Sort(CompareModifierOrder);
}
public void Equip(IHasStat stat)
{
foreach (var mod in m_ModifierContainers)
{
StatModifier modifier = new StatModifier(mod.Value, mod.ModType, mod.Order, this);
switch (mod.StatType)
{
case StatType.MaxHealth:
stat.MaxHealth.AddModifier(modifier);
break;
case StatType.HealthRecovery:
stat.HealthRecovery.AddModifier(modifier);
break;
case StatType.MaxMainStamina:
stat.MaxMainStamina.AddModifier(modifier);
break;
case StatType.MaxSubStamina:
stat.MaxSubStamina.AddModifier(modifier);
break;
case StatType.PhysicalDamage:
stat.PhysicalDamage.AddModifier(modifier);
break;
case StatType.MagicalDamage:
stat.MagicalDamage.AddModifier(modifier);
break;
case StatType.PhysicalResistence:
stat.PhysicalResistence.AddModifier(modifier);
break;
case StatType.MagicalResistence:
stat.MagicalResistence.AddModifier(modifier);
break;
case StatType.PhysicalDurability:
stat.PhysicalDurability.AddModifier(modifier);
break;
case StatType.MagicalDurability:
stat.MagicalDurability.AddModifier(modifier);
break;
case StatType.Stability:
stat.Stability.AddModifier(modifier);
break;
case StatType.JumpCount:
stat.JumpCount.AddModifier(modifier);
break;
case StatType.CanWallJump:
stat.CanWallJump.AddModifier(modifier);
break;
}
}
}
protected FloatInputWidget <StatModifier> CreateFloatInput(StatModifier sm)
{
return(new FloatInputWidget <StatModifier>(sm, sm.stat.label, (StatModifier m) => m.value, (StatModifier m, float f) => m.value = f));
}
public void AddModifier(StatModifier mod)
{
_stats.AddModifier(mod);
}
private bool GetSatsFromSource(StatModifier statModifier, object source)
{
return(statModifier.Source == source);
}
public static void RemoveModifier(Unit unit, StatModifier mod)
{
// UNDONE: checks?
//unit.stats[mod.statType].mods.Remove(mod);
}
public abstract void AddStatModifier(StatType statusType, StatModifier statModifier);
public ABuildableDefWidget(D def, DefType type) : base(def, type)
{
if (base.Def.statBases == null)
{
base.Def.statBases = new List <StatModifier>();
}
this.inputWidgets = new List <IInputWidget>()
{
new EnumInputWidget <D, Traversability>(base.Def, "Passability", 200, d => d.passability, (d, v) => d.passability = v),
new IntInputWidget <D>(base.Def, "Path Cost", d => d.pathCost, (d, v) => d.pathCost = v),
new BoolInputWidget <D>(base.Def, "Path Cost Ignore Repeat", d => d.pathCostIgnoreRepeat, (d, v) => d.pathCostIgnoreRepeat = v),
new FloatInputWidget <D>(base.Def, "Fertility", d => d.fertility, (d, v) => d.fertility = v),
new IntInputWidget <D>(base.Def, "Cost Stuff Count", d => d.costStuffCount, (d, v) => d.costStuffCount = v),
new IntInputWidget <D>(base.Def, "Placing Draggable Dimensions", d => d.placingDraggableDimensions, (d, v) => d.placingDraggableDimensions = v),
new BoolInputWidget <D>(base.Def, "Clear Building Area", d => d.clearBuildingArea, (d, v) => d.clearBuildingArea = v),
new FloatInputWidget <D>(base.Def, "Resources Fraction When Deconstructed", d => d.resourcesFractionWhenDeconstructed, (d, v) => d.resourcesFractionWhenDeconstructed = v),
new IntInputWidget <D>(base.Def, "Construction Skill Prerequisite", d => d.constructionSkillPrerequisite, (d, v) => d.constructionSkillPrerequisite = v),
new EnumInputWidget <D, TechLevel>(base.Def, "Min Tech Level To Build", 200, d => d.minTechLevelToBuild, (d, v) => d.minTechLevelToBuild = v),
new EnumInputWidget <D, TechLevel>(base.Def, "Max Tech Level To Build", 200, d => d.maxTechLevelToBuild, (d, v) => d.maxTechLevelToBuild = v),
new EnumInputWidget <D, AltitudeLayer>(base.Def, "Altitude Layer", 200, d => d.altitudeLayer, (d, v) => d.altitudeLayer = v),
new FloatInputWidget <D>(base.Def, "Special Display Radius", d => d.specialDisplayRadius, (d, v) => d.specialDisplayRadius = v),
new DefInputWidget <D, TerrainAffordanceDef>(base.Def, "Terrain Affordance Needed", 200, d => d.terrainAffordanceNeeded, (d, v) => d.terrainAffordanceNeeded = v, true),
new DefInputWidget <D, EffecterDef>(base.Def, "Repair Effect", 200, d => d.repairEffect, (d, v) => d.repairEffect = v, true),
new DefInputWidget <D, EffecterDef>(base.Def, "Construct Effect", 200, d => d.constructEffect, (d, v) => d.constructEffect = v, true),
new DefInputWidget <D, DesignationCategoryDef>(base.Def, "Designation Category", 200, d => d.designationCategory, (d, v) => d.designationCategory = v, true),
new DefInputWidget <D, DesignatorDropdownGroupDef>(base.Def, "Designator Dropdown", 200, d => d.designatorDropdown, (d, v) => d.designatorDropdown = v, true),
new DefInputWidget <D, KeyBindingDef>(base.Def, "Key Binding", 200, d => d.designationHotKey, (d, v) => d.designationHotKey = v, true),
new DefInputWidget <D, ThingDef>(base.Def, "Blueprint", 200, d => d.blueprintDef, (d, v) => d.blueprintDef = v, true),
new DefInputWidget <D, ThingDef>(base.Def, "Install Blueprint", 200, d => d.installBlueprintDef, (d, v) => d.installBlueprintDef = v, true),
new DefInputWidget <D, ThingDef>(base.Def, "Frame", 200, d => d.frameDef, (d, v) => d.frameDef = v, true),
new EnumInputWidget <D, Direction>(base.Def, "Default Placing Rotation", 200,
d =>
{
switch (d.defaultPlacingRot.AsAngle)
{
case 0f:
return(Direction.North);
case 90f:
return(Direction.East);
case 180f:
return(Direction.South);
default:
return(Direction.West);
}
},
(d, v) =>
{
switch (v)
{
case Direction.North:
d.defaultPlacingRot = Rot4.North;
break;
case Direction.East:
d.defaultPlacingRot = Rot4.East;
break;
case Direction.South:
d.defaultPlacingRot = Rot4.South;
break;
default:
d.defaultPlacingRot = Rot4.West;
break;
}
}),
};
this.statBasesPlusMinus = new WindowUtil.PlusMinusArgs <StatDef>()
{
allItems = DefDatabase <StatDef> .AllDefs,
getDisplayName = d => Util.GetLabel(d),
beingUsed = () =>
{
List <StatDef> l = new List <StatDef>(base.Def.statBases.Count);
base.Def.statBases.ForEach(v => l.Add(v.stat));
return(l);
},
onAdd = v =>
{
StatModifier sm = new StatModifier()
{
stat = v, value = 0
};
base.Def.statBases.Add(sm);
this.statBases.Add(this.CreateFloatInput(sm));
},
onRemove = v =>
{
base.Def.statBases.RemoveAll(sm => sm.stat == v);
this.statBases.RemoveAll(w => w.Parent.stat == v);
},
};
}
public static void AddModifier(Unit unit, StatModifier mod)
{
//unit.stats[mod.statType].mods.Add(mod);
}
public virtual void AddModifier(StatModifier mod)
{
isDirty = true;
statModifiers.Add(mod);
statModifiers.Sort(CompareModifierOrder);
}
public static void RemoveTrackedStatMod(StatCollection source, StatCollection target, StatType stat, StatModifier mod, params StatModifierOption[] statOptions)
{
GameObject s = source != null ? source.Owner : null;
GameObject t = target != null ? target.Owner : null;
if (t != null)
{
target.RemoveTrackedMod(stat, mod, s, statOptions);
SendStatChangeEvent(source.Owner, t, stat, -mod.Value);
}
else
{
Debug.LogWarning("a stat mod: " + mod + " could not be removed from a target because it was null");
}
}
protected override void FillTab()
{
//Log.Message("ITab_Avali_Pack");
Rect rect1 = new Rect(0, 0, WinSize.x, WinSize.y).ContractedBy(10f);
Text.Font = GameFont.Small;
oldColor = GUI.color;
Hediff avaliBiology = SelPawn.health.hediffSet.GetFirstHediffOfDef(HediffDefOf.AvaliBiology);
if (avaliBiology == null)
{
NotInPack(rect1);
return;
}
HediffDef packHediffDef = (HediffDef)Traverse.Create(avaliBiology).Field("packHediffDef").GetValue();
List <Pawn> relatedPawns = (List <Pawn>)Traverse.Create(avaliBiology).Field("relatedPawns").GetValue();
Pawn packLeader = null;
int maxPawnsInPack = (int)Traverse.Create(avaliBiology).Field("maxPawnsInPack").GetValue();
if (packHediffDef == null ||
maxPawnsInPack < 2 ||
relatedPawns == null)
{
NotInPack(rect1);
return;
}
for (int i = 0; i < relatedPawns.Count; i++)
{
Pawn relatedPawn = relatedPawns[i];
if (SelPawn.relations.DirectRelationExists(PawnRelationDefOf.PackLeader, relatedPawn))
{
packLeader = relatedPawn;
break;
}
}
if (packLeader == null)
{
packLeader = SelPawn;
}
packHediff = SelPawn.health.hediffSet.GetFirstHediffOfDef(packHediffDef);
if (packHediff == null)
{
NotInPack(rect1);
return;
}
/* --------------------------------------------------------------------------------------------- //
*
* Specialization: packHediff.LabelCap
* Pack Leader: packLeader
* Pack members: 6/6
*
* Pack activity effects:
* ...
*
* // --------------------------------------------------------------------------------------------- */
Rect rect2 = new Rect(0, startPosY, WinSize.x, 42).ContractedBy(10f);
NewRect(rect2, "PackSpecialization".Translate(), packHediff.LabelCap, rect2, "PackSpecializationDesc".Translate());
DrawLineHorizontalWithColor(10, startPosY + labelSizeY * 1 + 8, WinSize.x - 20, Color.gray);
//GUI.color = oldColor;
Rect rect3 = new Rect(0, startPosY + labelSizeY * 1, WinSize.x, 42).ContractedBy(10f);
NewRect(rect3, "PackLeader".Translate(), packLeader.Name.ToString(), rect3, "PackLeaderDesc".Translate());
Rect rect4 = new Rect(0, startPosY + labelSizeY * 2, WinSize.x, 42).ContractedBy(10f);
string packMembers = SelPawn.Name.ToString();
int packMembersCount = 1;
for (int i = 0; i < relatedPawns.Count; i++)
{
Pawn relatedPawn = relatedPawns[i];
if (relatedPawn == SelPawn)
{
continue;
}
packMembers += "\n" + relatedPawn.Name;
packMembersCount++;
}
NewRect(rect4, "PackMembers".Translate(), packMembersCount + "/" + maxPawnsInPack, rect4, packMembers);
if (packHediff.CurStage == null || packHediff.CurStage.statOffsets == null || packHediff.CurStage.statOffsets.Count == 0)
{
NotInPack(rect1);
return;
}
DrawLineHorizontalWithColor(10, startPosY + labelSizeY * 5 + 8, WinSize.x - 20, Color.gray);
//GUI.color = oldColor;
Rect rect5 = new Rect(0, startPosY + labelSizeY * 4, WinSize.x, 42).ContractedBy(10f);
float hearingRange = 30 * SelPawn.health.capacities.GetLevel(PawnCapacityDefOf.Hearing);
NewRect(rect5, "PackEffects".Translate(), "", rect5, string.Format("PackEffectsDesc".Translate(), (int)hearingRange));
float yPosition = startPosY + labelSizeY * 5;
List <StatModifier> statOffsets = packHediff.CurStage.statOffsets;
if (statOffsets.Count > 1)
{
int secondColumnStart = statOffsets.Count / 2;
for (int i = secondColumnStart; i < statOffsets.Count; i++)
{
StatModifier packStatMod = statOffsets[i];
if (packStatMod == null)
{
continue;
}
Rect rect = new Rect(WinSize.x / 2 - 10, yPosition, WinSize.x / 2 + 10, 42).ContractedBy(10f);
Rect labelRect = new Rect(WinSize.x - 75, yPosition + 10, 1000, 42);
NewRect(rect, packStatMod.stat.LabelCap, packStatMod.ValueToStringAsOffset, labelRect, packStatMod.stat.description);
yPosition += labelSizeY;
}
}
yPosition = startPosY + labelSizeY * 5;
for (int i = 0; i < statOffsets.Count / 2; i++)
{
StatModifier packStatMod = statOffsets[i];
if (packStatMod == null)
{
continue;
}
Rect rect = new Rect(0, yPosition, WinSize.x / 2 + 10, 42).ContractedBy(10f);
Rect labelRect = new Rect(WinSize.x / 2 - 75, yPosition + 10, 1000, 42);
NewRect(rect, packStatMod.stat.LabelCap, packStatMod.ValueToStringAsOffset, labelRect, packStatMod.stat.description);
yPosition += labelSizeY;
}
}
override protected void Update()
{
if (battleGroup == null)
{
return;
}
base.Update();
//추락
if ((airborneCoroutine == null && falldownCoroutine == null && coroutineShake == null) && (isDie || isBlockMove))
{
skeletonAnimation.transform.localPosition = Vector2.Lerp(skeletonAnimation.transform.localPosition, Vector2.zero, 2f * Time.deltaTime);
}
//공중 높이 복귀
if (skeletonAnimState != SkeletonAnimState.Skill && airborneCoroutine == null && falldownCoroutine == null && coroutineShake == null)
{
if (skeletonAnimation.transform.localPosition.y < originalPosY || skeletonAnimation.transform.localPosition.y > originalPosY)
{
//공중 복귀
if (originalPosY > 0f)
{
if (skeletonAnimation.transform.localPosition.y < originalPosY + 0.02f && skeletonAnimation.transform.localPosition.y > originalPosY - 0.02f)
{
skeletonAnimation.transform.localPosition = new Vector2(0f, originalPosY);
}
else
{
skeletonAnimation.transform.localPosition = Vector2.Lerp(skeletonAnimation.transform.localPosition, new Vector2(0f, originalPosY), 2f * Time.deltaTime);
}
}
//추락
else
{
Vector2 destPos = Vector2.MoveTowards(skeletonAnimation.transform.localPosition, new Vector2(0f, originalPosY), fallingSpeed * Time.deltaTime);
if (skeletonAnimation.transform.localPosition.y < originalPosY && destPos.y >= originalPosY ||
skeletonAnimation.transform.localPosition.y > originalPosY && destPos.y <= originalPosY
)
{
skeletonAnimation.transform.localPosition = new Vector2(0f, originalPosY);
fallingSpeed = 2f;
}
else
{
float acc = originalPosY > 0f ? 2f : 9.8f;
skeletonAnimation.transform.localPosition = destPos;
fallingSpeed += acc * Time.deltaTime;
}
}
}
}
Renderer r = skeletonAnimation.GetComponent <Renderer>();
//최종 이동 속도 적용. 이동속도 증가량, 식량 상태에 의한 보정
if (isDie)
{
skeletonAnimation.timeScale = 1f;
mpb.SetColor("_OverlayColor", new Color(0f, 0f, 0f, 0.5f));
r.SetPropertyBlock(mpb);
}
else if (shakeAmount > 0.01f)
{
skeletonAnimation.timeScale = 0f;
if (coroutineLevelUp == null)
{
mpb.SetColor("_OverlayColor", new Color(1f, 0f, 0f, 0.5f));
r.SetPropertyBlock(mpb);
}
}
else if (airborneCoroutine != null || falldownCoroutine != null)
{
skeletonAnimation.timeScale = 0f;
}
else
{
Stat statMoveSpeed = stats.GetParam(StatType.MoveSpeed);
Stat statAttackSpeed = stats.GetParam(StatType.AttackSpeed);
if (skeletonAnimation.AnimationName == runAnimation || skeletonAnimation.AnimationName == idleAnimation)
{
skeletonAnimation.timeScale = Mathf.Max(0.1f, (float)(statMoveSpeed.value * 0.0001f));
}
else
{
skeletonAnimation.timeScale = Mathf.Max(0.1f, (float)(statAttackSpeed.value * 0.0001f));
}
if (coroutineLevelUp == null)
{
r.SetPropertyBlock(null);
}
}
//if(shakeAmount > 0f)
{
float a = 0f;
if (shakeAmount > 0f)
{
a = Mathf.Sin(Time.time * 20f);
if (a > 0)
{
a = 1;
}
else if (a < 0)
{
a = -1;
}
}
float s = shakeAmount * a;// UnityEngine.Random.Range(-shakeAmount, shakeAmount);
Vector3 shakePos = new Vector3(s, 0f, 0f);
Vector3 localPos = new Vector3(0f, skeletonAnimation.transform.localPosition.y, skeletonAnimation.transform.localPosition.z);
skeletonAnimation.transform.localPosition = Vector3.Lerp(skeletonAnimation.transform.localPosition, localPos + shakePos, 10f * Time.deltaTime);
}
////스탯 테스트
//if (!UnityEditor.Selection.Contains(gameObject))
// return;
if (Input.GetKeyDown(KeyCode.KeypadPlus))
{
StatModifier mod = new StatModifier();
mod.type = StatModifier.Type.BaseValuePercent;
mod.value = 1000f;
stats.AddStatModifier(StatType.MoveSpeed, mod);
}
else if (Input.GetKeyDown(KeyCode.KeypadMinus))
{
var mod = stats.GetParam <ModifiableStat>(StatType.MoveSpeed).modifiers.Find(x => x.type == StatModifier.Type.BaseValuePercent);
stats.RemoveModifier(StatType.MoveSpeed, mod);
}
}
/// <summary>
/// Remove a modifier from the stack. This modifier need to already be on the stack. e.g. used by the equipment
/// effect that store the modifier they add on equip and remove it when unequipped.
/// </summary>
/// <param name="modifier"></param>
public void RemoveModifier(StatModifier modifier)
{
m_ModifiersStack.Remove(modifier);
UpdateFinalStats();
}
public override void ExecuteEffect(UsableItem parentItem, Player player)
{
if (StrengthBuff != 0)
{
StatModifier strengthStatModifier = new StatModifier(StrengthBuff, StatModType.Flat, parentItem);
player.Strength.AddModifier(strengthStatModifier);
player.StartCoroutine(RemoveBuff(player, strengthStatModifier, Duration));
player.character.UpdateStatValues();
}
if (AgilityBuff != 0)
{
StatModifier agilityStatModifier = new StatModifier(AgilityBuff, StatModType.Flat, parentItem);
player.Agility.AddModifier(agilityStatModifier);
player.StartCoroutine(RemoveBuff(player, agilityStatModifier, Duration));
player.character.UpdateStatValues();
}
if (IntelligenceBuff != 0)
{
StatModifier intelligenceStatModifier = new StatModifier(IntelligenceBuff, StatModType.Flat, parentItem);
player.Intelligence.AddModifier(intelligenceStatModifier);
player.StartCoroutine(RemoveBuff(player, intelligenceStatModifier, Duration));
player.character.UpdateStatValues();
}
if (VitalityBuff != 0)
{
StatModifier vitalityStatModifier = new StatModifier(VitalityBuff, StatModType.Flat, parentItem);
player.Vitality.AddModifier(vitalityStatModifier);
player.StartCoroutine(RemoveBuff(player, vitalityStatModifier, Duration));
player.character.UpdateStatValues();
}
if (LuckBuff != 0)
{
StatModifier luckStatModifier = new StatModifier(LuckBuff, StatModType.Flat, parentItem);
player.Dexterity.AddModifier(luckStatModifier);
player.StartCoroutine(RemoveBuff(player, luckStatModifier, Duration));
player.character.UpdateStatValues();
}
if (AttackBuff != 0)
{
StatModifier attackStatModifier = new StatModifier(AttackBuff, StatModType.Flat, parentItem);
player.Attack.AddModifier(attackStatModifier);
player.StartCoroutine(RemoveBuff(player, attackStatModifier, Duration));
player.character.UpdateStatValues();
}
if (DefenseBuff != 0)
{
StatModifier defenseStatModifier = new StatModifier(DefenseBuff, StatModType.Flat, parentItem);
player.Defense.AddModifier(defenseStatModifier);
player.StartCoroutine(RemoveBuff(player, defenseStatModifier, Duration));
player.character.UpdateStatValues();
}
if (CritBuff != 0)
{
StatModifier critStatModifier = new StatModifier(CritBuff, StatModType.Flat, parentItem);
player.Crit.AddModifier(critStatModifier);
player.StartCoroutine(RemoveBuff(player, critStatModifier, Duration));
player.character.UpdateStatValues();
}
if (MagicAttackBuff != 0)
{
StatModifier magicAttackStatModifier = new StatModifier(MagicAttackBuff, StatModType.Flat, parentItem);
player.MagicAttack.AddModifier(magicAttackStatModifier);
player.StartCoroutine(RemoveBuff(player, magicAttackStatModifier, Duration));
player.character.UpdateStatValues();
}
if (MagicDefenseBuff != 0)
{
StatModifier magicDefenseStatModifier = new StatModifier(MagicDefenseBuff, StatModType.Flat, parentItem);
player.Toughness.AddModifier(magicDefenseStatModifier);
player.StartCoroutine(RemoveBuff(player, magicDefenseStatModifier, Duration));
player.character.UpdateStatValues();
}
if (AttackSpeedBuff != 0)
{
StatModifier attackSpeedStatModifier = new StatModifier(AttackSpeedBuff, StatModType.Flat, parentItem);
player.AttackSpeed.AddModifier(attackSpeedStatModifier);
player.StartCoroutine(RemoveBuff(player, attackSpeedStatModifier, Duration));
player.character.UpdateStatValues();
}
}
public override void ModifyWeaponDamage(Player player, ref StatModifier damage)
{
SetUseStats(player); // Always displays left-click stats
Tools.HandleAltUseAnimation(player);
}
public virtual void AddModifier(StatModifier modifier)
{
isChanged = true;
statModifiers.Add(modifier);
}
public void AddModifier(StatModifier modifier)
{
mModifiers.Add(modifier);
}
public virtual void ModifyStat(StatModifier mod)
{
mods.Add(mod);
}
public static void PanaceaUseHook(Action <Panacea, PlayerController> orig, Panacea self, PlayerController user)
{
orig(self, user);
List <int> OptionalItemIDs = new List <int>
{
64,
174,
267,
168,
205,
427,
426,
424
};
bool hasMysteriousBrewSynergy = false;
foreach (PlayerItem active in user.activeItems)
{
if (OptionalItemIDs.Contains(active.PickupObjectId))
{
hasMysteriousBrewSynergy = true;
}
}
foreach (PassiveItem passive in user.passiveItems)
{
if (OptionalItemIDs.Contains(passive.PickupObjectId))
{
hasMysteriousBrewSynergy = true;
}
}
if (hasMysteriousBrewSynergy)
{
int value = UnityEngine.Random.Range(1, 9);
string header = "";
string text = "";
if (value == 1)
{
header = "?";
text = "Nothing happened.";
}
else if (value == 2)
{
header = "Invigorated";
text = "You feel healthier.";
StatModifier mod = new StatModifier
{
statToBoost = PlayerStats.StatType.Health,
amount = 1,
modifyType = StatModifier.ModifyMethod.ADDITIVE,
};
user.ownerlessStatModifiers.Add(mod);
user.stats.RecalculateStats(user, true, false);
}
else if (value == 3)
{
header = "Overloaded";
text = "The brew explodes.";
Exploder.DoDefaultExplosion(user.sprite.WorldCenter, new Vector2());
}
else if (value == 4)
{
header = "Pathetic";
text = "You feel weaker.";
StatModifier mod = new StatModifier
{
statToBoost = PlayerStats.StatType.Damage,
amount = -0.20f,
modifyType = StatModifier.ModifyMethod.ADDITIVE,
};
StatModifier mod2 = new StatModifier
{
statToBoost = PlayerStats.StatType.ThrownGunDamage,
amount = 0,
modifyType = StatModifier.ModifyMethod.MULTIPLICATIVE,
};
user.ownerlessStatModifiers.Add(mod);
user.ownerlessStatModifiers.Add(mod2);
user.stats.RecalculateStats(user, true, false);
}
else if (value == 5)
{
header = "Fast Reaction";
text = "Bullets are slow to you.";
StatModifier mod2 = new StatModifier
{
statToBoost = PlayerStats.StatType.EnemyProjectileSpeedMultiplier,
amount = 0.90f,
modifyType = StatModifier.ModifyMethod.MULTIPLICATIVE,
};
user.ownerlessStatModifiers.Add(mod2);
user.stats.RecalculateStats(user, true, false);
}
else if (value == 6)
{
header = "Slow Hands";
text = "Slower charge and reload.";
StatModifier mod2 = new StatModifier
{
statToBoost = PlayerStats.StatType.ReloadSpeed,
amount = 0.10f,
modifyType = StatModifier.ModifyMethod.ADDITIVE,
};
StatModifier mod1 = new StatModifier
{
statToBoost = PlayerStats.StatType.ChargeAmountMultiplier,
amount = -0.10f,
modifyType = StatModifier.ModifyMethod.ADDITIVE,
};
user.ownerlessStatModifiers.Add(mod2);
user.ownerlessStatModifiers.Add(mod1);
user.stats.RecalculateStats(user, true, false);
}
else if (value == 7)
{
header = "Flammable";
text = "You feel vulnerable to fire.";
DamageTypeModifier mod = new DamageTypeModifier
{
damageType = CoreDamageTypes.Fire,
damageMultiplier = 2
};
user.healthHaver.damageTypeModifiers.Add(mod);
}
else if (value == 8)
{
header = "Obsidian Skin";
text = "You feel immune to fire.";
DamageTypeModifier mod = new DamageTypeModifier
{
damageType = CoreDamageTypes.Fire,
damageMultiplier = 0
};
user.healthHaver.damageTypeModifiers.Add(mod);
}
else if (value == 9)
{
header = "Bulletproof";
text = "You feel almost invulnerable!";
void ModifyDamageEvent(HealthHaver healthHaver, HealthHaver.ModifyDamageEventArgs args)
{
if (args == EventArgs.Empty)
{
return;
}
if (UnityEngine.Random.value < 0.2f)
{
args.ModifiedDamage = 0f;
}
}
user.healthHaver.ModifyDamage += ModifyDamageEvent;
}
NoPseudosynergiesModule.Notify(header, text, self.sprite);
}
}
public virtual void ModifyStat(StatModifier mod, ref float update)
{
ModifyStat(mod);
update = ModifiedValue;
}
public void RemoveModifier(StatModifier mod)
{
modList.Remove(mod);
mod.OnValueChange -= OnModValueChange;
}
/// <summary>
/// Compares orders of two StatModifier objects.
/// </summary>
/// <param name="a"></param>
/// <param name="b"></param>
private int CompareModifierOrder(StatModifier a, StatModifier b)
{
return(a.Order - b.Order);
}
public string GetDisplayValue(float value, StatModifier mod)
{
var displayValue = new StringBuilder(mod == StatModifier.Add ? "+" : "x");
switch (type)
{
case StatType.Flat:
displayValue.Append(value);
break;
case StatType.Multiplier:
case StatType.Proc:
case StatType.Resistance:
displayValue.Append(mod == StatModifier.Add ? (value * 100).ToString() + "%"
: (1 + value).ToString());
break;
case StatType.Turn:
displayValue.Append(mod == StatModifier.Add ? value + "/turn"
: value.ToString());
break;
}
return displayValue.ToString();
}
/// <summary>
/// Adds a modifier to StatModifier list.
/// </summary>
/// <param name="modifier"></param>
public void AddModifier(StatModifier modifier)
{
Recaliberate = true;
statModifiers.Add(modifier);
statModifiers.Sort(CompareModifierOrder);
}
public void RemoveModifier(StatModifier mod)
{
_stats.RemoveModifier(mod);
}
public Effect(EffectType type, bool affectsCaster, StatModifier statMod)
{
effect = generateEffect(type, 0, affectsCaster, statMod, null);
}