//public event EventHandler<StatModifyEventArgs> StatModify;
//protected virtual int OnStatModify(Character character, StatIdentifier statToModify, int newValue, int oldValue)
//{
// int returnValue = newValue;
// foreach (CharacterModifier modifier in this.Modifiers)
// {
// returnValue = modifier.Modify(character, statToModify, returnValue, oldValue);
// }
// return returnValue;
//}
private void Add(StatIdentifier statId, int modifyAmount)
{
int baseValue = baseStats[statId].Value;
int modValue = baseValue + modifyAmount;
this.Set(statId, modValue);
}
public void UpdateFromModifierChanges()
{
StatIdentifier genericStat = "generic_stat";
var template = new StatTemplate()
{
Name = "Generic Stat",
MaxValue = 1000
};
var instance = template.CreateInstance(genericStat);
var static5 = new EventField <float>(5);
var changeFrom5to10 = new EventField <float>(5);
Assert.AreEqual(0.0f, instance.Value);
var modifier = new StatModifier(StatModificationPhase.Typical, StatModificationType.Additive, static5);
instance.AddModifier(modifier);
Assert.AreEqual(5.0f, instance.Value);
var anotherModifier = new StatModifier(StatModificationPhase.Typical, StatModificationType.Additive, changeFrom5to10);
instance.AddModifier(anotherModifier);
Assert.AreEqual(10.0f, instance.Value);
changeFrom5to10.Value = 10.0f;
Assert.AreEqual(15.0f, instance.Value);
}
public void UnsubscribeModifierWhenRemoved()
{
StatIdentifier genericStat = "generic_stat";
var template = new StatTemplate()
{
Name = "Generic Stat",
MaxValue = 1000
};
var instance = template.CreateInstance(genericStat);
var changingModifierValue = new EventField <float>(5);
Assert.AreEqual(0.0f, instance.Value);
var modifier = new StatModifier(StatModificationPhase.Typical, StatModificationType.Additive, changingModifierValue);
instance.AddModifier(modifier);
Assert.AreEqual(5.0f, instance.Value);
changingModifierValue.Value = 10.0f;
Assert.AreEqual(10.0f, instance.Value);
instance.RemoveModifier(modifier);
Assert.AreEqual(0.0f, instance.Value);
changingModifierValue.Value = 15.0f;
Assert.AreEqual(0.0f, instance.Value);
}
//private void SetFactor(StatIdentifier statId, float factor, int restPoint)
//{
// if (factor <= 0f)
// {
// this.Set(statId, 0);
// return;
// }
// int factorValue = MathHelper.Clamp((int)Math.Round(restPoint * factor), Stats.MinValue, Stats.MaxValue);
// this.Set(statId, factorValue);
//}
internal int GetStat(StatIdentifier statId)
{
var currentValue = baseStats[statId];
var eventArgs = currentValue.OnStatRead(statId, new StatReadEventArgs(currentValue.Value), character);
return(eventArgs.Value);
//return modStats[statId];
}
private void Set(StatIdentifier statID, int newValue)
{
int prevValue = this.GetStat(statID);
var eventArgs = this.baseStats[statID].OnStatChanged(statID, new StatChangedEventArgs(newValue, prevValue), character);
baseStats[statID].Value = Stats.Clamp(eventArgs.Value);
//modStats[statId] = this.OnStatModify(character, statId, modifyAmountTo, modStats[statId]);
}
public StatInstance CreateInstance(StatIdentifier identifier)
{
return(new StatInstance()
{
Identifier = identifier,
Template = this
});
}
internal StatReadEventArgs OnStatRead(StatIdentifier statID, StatReadEventArgs e, Character character)
{
//if (onStatRead[(int)statID] != null)
//{
// onStatRead[(int)statID](character, e);
//}
if (this.Read != null)
{
this.Read(character, e);
}
return(e);
}
private float GetStatFactor(StatIdentifier statId, int restPoint)
{
int statValue = this.GetStat(statId);
if (statValue <= 0)
{
return(0f);
}
if (restPoint <= 0)
{
return(0f);
}
return((float)statValue / (float)restPoint);
}
// this function allows access to a stat given an enum
// mainly this is useful for Designer editing/inspector
public void AdjustStat(StatIdentifier stat, int amount)
{
Stat statToAdjust;
int statIndex = (int)stat;
switch (statIndex)
{
case 0:
statToAdjust = null;
break;
case 1:
statToAdjust = MaxHealth;
break;
case 2:
statToAdjust = MaxSanity;
break;
case 3:
statToAdjust = Calm;
break;
case 4:
statToAdjust = Survival;
break;
case 5:
statToAdjust = Tenacity;
break;
default:
Debug.LogWarning("Invald choice of stat identifier");
statToAdjust = null;
break;
}
// if we have a valid stat to adjust, adjust it
if (statToAdjust != null)
{
statToAdjust.Adjust(amount);
}
}
public CharacterStat(StatIdentifier id)
{
this.StatID = id;
}
public int?GetStatValue(D2Unit unit, StatIdentifier statId)
{
return(GetStatValue(unit, (ushort)statId));
}
public bool IsOfType(StatIdentifier id)
{
return(LoStatID == (ushort)id);
}
private float GetStatFactor(StatIdentifier statId)
{
return(GetStatFactor(statId, 100));
}
public ITraitContextBuilder UseTrait(StatIdentifier statIdentifier, StatTemplate statTemplate)
{
statIdentifiers.Add(statIdentifier);
statMapping.Add(statIdentifier, statTemplate);
return(this);
}
public bool TryHandleStat(D2Stat stat, out string description)
{
description = null;
StatIdentifier statId = 0;
if (Enum.IsDefined(typeof(StatIdentifier), stat.LoStatID))
{
statId = (StatIdentifier)stat.LoStatID;
}
else
{
return(false);
}
switch (statId)
{
//Handle one and two handed damage.
case StatIdentifier.DamageMin:
case StatIdentifier.DamageMax:
case StatIdentifier.SecondaryDamageMin:
case StatIdentifier.SecondaryDamageMax:
// Only print once if it's a range.
if (HasHandledDamageRange)
{
return(true);
}
// Skip two-handed damage if there is a one-handed damage source or if no damage is defined.
if (stat.IsOfType(StatIdentifier.SecondaryDamageMin) && !IsDamageMinSecondary)
{
return(true);
}
if (stat.IsOfType(StatIdentifier.SecondaryDamageMax) && !IsDamageMaxSecondary)
{
return(true);
}
// If not a range, print normally.
if (!HasDamageRange)
{
return(false);
}
// We also print twice if they are the same.
if (DamageMin == DamageMax)
{
return(false);
}
HasHandledDamageRange = true;
description = FormatSimpleDamage(DamageMin, DamageMax,
StringConstants.DamageRange,
StringConstants.DamageRange);
return(true);
// Handle enhanced damage.
case StatIdentifier.ItemDamageMinPercent:
{
if (!HasDamagePercentRange)
{
return(false);
}
string enhanced = stringReader.GetString(StringConstants.EnhancedDamage);
description = string.Format("+{0}% {1}", stat.Value, enhanced.TrimEnd());
return(true);
}
case StatIdentifier.ItemDamageMaxPercent:
return(HasDamagePercentRange);
// Handle fire damage ranges.
case StatIdentifier.FireDamageMin:
if (!HasFireRange)
{
return(false);
}
description = FormatSimpleDamage(
FireMinDamage,
FireMaxDamage,
StringConstants.FireDamageRange,
StringConstants.FireDamage);
return(true);
case StatIdentifier.FireDamageMax:
return(HasFireRange);
// Handle lightning damage ranges.
case StatIdentifier.LightningDamageMin:
if (!HasLightningRange)
{
return(false);
}
description = FormatSimpleDamage(
LightningMinDamage,
LightningMaxDamage,
StringConstants.LightningDamageRange,
StringConstants.LightningDamage);
return(true);
case StatIdentifier.LightningDamageMax:
return(HasLightningRange);
// Handle magic damage ranges.
case StatIdentifier.MagicDamageMin:
if (!HasMagicRange)
{
return(false);
}
description = FormatSimpleDamage(
MagicMinDamage,
MagicMaxDamage,
StringConstants.MagicDamageRange,
StringConstants.MagicDamage);
return(true);
case StatIdentifier.MagicDamageMax:
return(HasMagicRange);
// Handle cold damage ranges.
case StatIdentifier.ColdDamageMin:
if (!HasColdRange)
{
return(false);
}
description = FormatSimpleDamage(
ColdMinDamage,
ColdMaxDamage,
StringConstants.ColdDamageRange,
StringConstants.ColdDamage);
return(true);
case StatIdentifier.ColdDamageMax:
return(HasColdRange);
// Handle poison damage ranges.
case StatIdentifier.PoisonDamageMax:
case StatIdentifier.PoisonDamageDuration:
return(HasPoisonRange);
case StatIdentifier.PoisonDamageMin:
{
if (!HasPoisonRange)
{
return(false);
}
int divisor = PoisonDivisor == 0 ? 1 : PoisonDivisor;
int duration = PoisonDuration / divisor;
int min = (PoisonMinDamage * duration + 128) / 256;
int max = (PoisonMaxDamage * duration + 128) / 256;
duration /= 25;
if (min == max)
{
// Example: "6 Poison damage over 2 seconds"
int arguments;
string format = stringReader.GetString(StringConstants.PoisonOverTimeSame);
format = stringReader.ConvertCFormatString(format, out arguments);
if (arguments != 2)
{
return(true);
}
description = string.Format(format, min, duration).TrimEnd();
}
else
{
// Example: "2-10 Poison damage over 2 seconds"
int arguments;
string format = stringReader.GetString(StringConstants.PoisonOverTime);
format = stringReader.ConvertCFormatString(format, out arguments);
if (arguments != 3)
{
return(true);
}
description = string.Format(format, min, max, duration).TrimEnd();
}
return(true);
}
// By default, the stat is not handled.
default: return(false);
}
}
public void OnStatReadUnRegister(StatIdentifier statID, StatReadEventHandler function)
{
baseStats[statID].Read -= function;
//onStatRead[(int)statID] -= function;
}
public void OnStatChangedUnRegister(StatIdentifier statID, StatChangedEventHandler function)
{
baseStats[statID].Changed -= function;
//onStatModified[(int)statID] -= function;
}
