public IEnumerable <string> Add(StatId id, string?expression = null)
{
IEnumerable <string> errors = new List <string>();
if (Exists(id))
{
errors = errors.Append($"Stat already exists: {id}");
}
var context = new ParsingContext(this, _functionService)
{
StatId = id,
};
errors = errors.Concat(_parser.Parse(out var stat, context, id.ToString(), expression));
if (stat == null)
{
return(errors);
}
errors = errors.Concat(IsRecursive(stat));
if (errors.Any())
{
return(errors);
}
Stats.Add(stat.Id, stat);
return(errors);
}
//TODO move to an extension method in tests
public IEnumerable <string> Update(StatId id, string?expression = null)
{
IEnumerable <string> errors = new List <string>();
if (!Exists(id))
{
errors = errors.Append($"{id} does not exists");
}
var context = new ParsingContext(this, _functionService)
{
StatId = id,
};
errors = errors.Concat(_parser.Parse(out var stat, context, id.ToString(), expression));
if (stat == null)
{
return(errors);
}
errors = errors.Concat(IsRecursive(stat));
if (!errors.Any())
{
Stats[id] = stat;
_cache.Clear();
}
return(errors);
}
public bool Equals(DestinyHistoricalStatsValue input)
{
if (input == null)
{
return(false);
}
return
((
StatId == input.StatId ||
(StatId != null && StatId.Equals(input.StatId))
) &&
(
Basic == input.Basic ||
(Basic != null && Basic.Equals(input.Basic))
) &&
(
Pga == input.Pga ||
(Pga != null && Pga.Equals(input.Pga))
) &&
(
Weighted == input.Weighted ||
(Weighted != null && Weighted.Equals(input.Weighted))
) &&
(
ActivityId == input.ActivityId ||
(ActivityId.Equals(input.ActivityId))
));
}
private Task StartRegen(StatId statId, StatId regenStatId, StatId timeStatId)
{
// TODO: merge regen updates with larger packets
return(Task.Run(async() =>
{
while (true)
{
await Task.Delay(Stats[timeStatId].Total);
lock (Stats)
{
if (Stats[statId].Total >= Stats[statId].Bonus)
{
return;
}
// TODO: Check if regen-enabled
AddStatRegen(statId, regenStatId);
Value.Session?.FieldManager.BroadcastPacket(StatPacket.UpdateStats(this, statId));
if (Value.Party != null)
{
Value.Party.BroadcastPacketParty(PartyPacket.UpdateHitpoints(Value));
}
}
}
}));
}
private static void HandleStatIncrement(GameSession session, PacketReader packet)
{
StatId statTypeIndex = (StatId)packet.ReadByte();
session.Player.StatPointDistribution.AddPoint(statTypeIndex);
session.Player.Stats.Allocate(statTypeIndex);
session.Send(StatPointPacket.WriteStatPointDistribution(session.Player));
session.Send(StatPacket.SetStats(session.Player.FieldPlayer));
}
public void AddPoint(StatId statType)
{
if (AllocatedStats.ContainsKey(statType))
{
AllocatedStats[statType] += 1;
return;
}
AllocatedStats[statType] = 1;
}
private static List <ParserStat> ParseFloatValues(StatId attribute, XmlNode node)
{
List <ParserStat> values = new();
for (int i = 2; i <= 17; i++)
{
values.Add(new(attribute, float.Parse(node.Attributes[$"idx{i}"].Value)));
}
return(values);
}
public double GetValue(StatId id)
{
if (_cache.ContainsKey(id))
{
return(_cache[id]);
}
var value = Stats[id].Resolve();
//_cache.Add(id, value);
return(value);
}
public static void WriteStat(this PacketWriter pWriter, Stats stats, StatId statId)
{
if (statId == StatId.Hp)
{
pWriter.WriteLong(stats[statId].BonusLong);
pWriter.WriteLong(stats[statId].BaseLong);
pWriter.WriteLong(stats[statId].TotalLong);
return;
}
for (int i = 0; i < 3; i++)
{
pWriter.WriteInt(stats[statId][i]);
}
}
private static void AddHiddenNormalStat(List <NormalStat> normalStats, StatId attribute, int value, float calibrationFactor)
{
NormalStat normalStat = normalStats.FirstOrDefault(x => x.ItemAttribute == attribute);
if (normalStat == null)
{
return;
}
int calibratedValue = (int)(value * calibrationFactor);
int index = normalStats.FindIndex(x => x.ItemAttribute == attribute);
int biggerValue = Math.Max(value, calibratedValue);
int smallerValue = Math.Min(value, calibratedValue);
int summedFlat = normalStat.Flat + RandomProvider.Get().Next(smallerValue, biggerValue);
normalStats[index] = new(normalStat.ItemAttribute, summedFlat, normalStat.Percent);
}
public bool Equals(DestinyLeaderboard input)
{
if (input == null)
{
return(false);
}
return
((
StatId == input.StatId ||
(StatId != null && StatId.Equals(input.StatId))
) &&
(
Entries == input.Entries ||
(Entries != null && Entries.SequenceEqual(input.Entries))
));
}
public static PacketWriter UpdateStats(IFieldActor player, StatId statId, params StatId[] otherIds)
{
PacketWriter pWriter = PacketWriter.Of(SendOp.STAT);
pWriter.WriteInt(player.ObjectId);
pWriter.Write(StatsMode.UpdateStats);
pWriter.WriteByte((byte)(1 + otherIds.Length));
pWriter.Write(statId);
pWriter.WriteStat(player.Stats, statId);
foreach (StatId otherId in otherIds)
{
pWriter.Write(otherId);
pWriter.WriteStat(player.Stats, statId);
}
return(pWriter);
}
public IEnumerable <string> Remove(StatId id, bool cascade = false)
{
IEnumerable <string> errors = new List <string>();
if (!Exists(id))
{
errors = errors.Append($"{id} does not exists"); //throw??
}
var deps = Stats.Where(s => s.Value.Id != id)
.Where(s => s.Value.Expressions.SelectMany(e => e.Nodes)
.Any(node =>
{
if (node is StatNode sn && sn.Id == id)
{
return(true);
}
if (node is VariableNode vn && vn.Id.StatId == id)
{
return(true);
}
return(false);
}))
.Select(s => s.Value.Id)
.ToArray();
if (!deps.Any())
{
Stats.Remove(id);
return(errors);
}
if (!cascade)
{
return(errors.Concat(deps.Select(depId => $"Cannot remove {depId} because {depId} depends on it")));
}
errors = errors.Concat(deps.SelectMany(stat => Remove(stat, true)));
Stats.Remove(id);
_cache.Remove(id);
return(errors);
}
private void AddStatRegen(StatId statIndex, StatId regenStatIndex)
{
int regenAmount = Stats[regenStatIndex].Total;
if (regenAmount <= 0)
{
return;
}
Stat stat = Stats[statIndex];
lock (stat)
{
if (stat.Total < stat.Bonus)
{
int missingAmount = stat.Bonus - stat.Total;
stat.Increase(Math.Clamp(regenAmount, 0, missingAmount));
}
}
}
public bool Equals(DestinyClanAggregateStat input)
{
if (input == null)
{
return(false);
}
return
((
Mode == input.Mode ||
(Mode != null && Mode.Equals(input.Mode))
) &&
(
StatId == input.StatId ||
(StatId != null && StatId.Equals(input.StatId))
) &&
(
Value == input.Value ||
(Value != null && Value.Equals(input.Value))
));
}
private static ItemStat ReadStat(int statId, int value)
{
// Normal Stat with percent value
if (statId >= 1000 && statId < 11000)
{
float percent = (float)(value + 5) / 10000;
StatId attribute = (StatId)(statId - 1000);
return(new NormalStat(attribute, 0, percent));
}
// Special Stat with percent value
if (statId >= 11000)
{
float percent = (float)(value + 5) / 10000;
SpecialStatId attribute = (SpecialStatId)(statId - 11000);
return(new SpecialStat(attribute, 0, percent));
}
// Normal Stat with flat value
return(new NormalStat((StatId)statId, value, 0));
}
public float?GetStatValue(StatId statId)
{
var stat = Stats.SingleOrDefault(st => st.StatId == statId);
return(stat != null ? stat.Value : (float?)null);
}
public Stat(StatId id, Expression expression)
: this(id, new List <NamedExpression> {
public bool Equals(DestinyHistoricalStatsDefinition input)
{
if (input == null)
{
return(false);
}
return
((
StatId == input.StatId ||
(StatId != null && StatId.Equals(input.StatId))
) &&
(
Group == input.Group ||
(Group != null && Group.Equals(input.Group))
) &&
(
PeriodTypes == input.PeriodTypes ||
(PeriodTypes != null && PeriodTypes.SequenceEqual(input.PeriodTypes))
) &&
(
Modes == input.Modes ||
(Modes != null && Modes.SequenceEqual(input.Modes))
) &&
(
Category == input.Category ||
(Category != null && Category.Equals(input.Category))
) &&
(
StatName == input.StatName ||
(StatName != null && StatName.Equals(input.StatName))
) &&
(
StatNameAbbr == input.StatNameAbbr ||
(StatNameAbbr != null && StatNameAbbr.Equals(input.StatNameAbbr))
) &&
(
StatDescription == input.StatDescription ||
(StatDescription != null && StatDescription.Equals(input.StatDescription))
) &&
(
UnitType == input.UnitType ||
(UnitType != null && UnitType.Equals(input.UnitType))
) &&
(
IconImage == input.IconImage ||
(IconImage != null && IconImage.Equals(input.IconImage))
) &&
(
MergeMethod == input.MergeMethod ||
(MergeMethod.Equals(input.MergeMethod))
) &&
(
UnitLabel == input.UnitLabel ||
(UnitLabel != null && UnitLabel.Equals(input.UnitLabel))
) &&
(
Weight == input.Weight ||
(Weight.Equals(input.Weight))
) &&
(
MedalTierHash == input.MedalTierHash ||
(MedalTierHash.Equals(input.MedalTierHash))
));
}
public StatVariable GetStat(StatId id)
{
return(variables_stats[(int)id]);
}
public Stat Get(StatId id) => Stats[id];
public NormalStat(ParserStat stat)
{
ItemAttribute = stat.Id;
Flat = stat.Flat;
Percent = stat.Percent;
}
public NormalStat(StatId attribute, int flat, float percent)
{
ItemAttribute = attribute;
Flat = flat;
Percent = percent;
}
public bool Exists(StatId id) => Stats.ContainsKey(id);
public ParserStat(StatId type, float percent)
{
Id = type;
Flat = 0;
Percent = percent;
}
string StatToString(StatId id)
{
string ret;
switch (id)
{
case StatId.WeaponDmg:
ret = "Weapon Damage";
break;
case StatId.MaxHealth:
ret = "Max Health";
break;
case StatId.HealthRegen:
ret = "Health Regen";
break;
case StatId.MaxResource:
ret = "Max Resource";
break;
case StatId.ResourceRegen:
ret = "Resource Regen";
break;
case StatId.MoveSpeed:
ret = "Move Speed";
break;
case StatId.AttackSpeed:
ret = "Attack Speed";
break;
case StatId.Armor:
ret = "Armor";
break;
case StatId.PhysicRes:
ret = "Physical Resist";
break;
case StatId.FireRes:
ret = "Fire Resist";
break;
case StatId.WaterRes:
ret = "Water Resist";
break;
case StatId.ShockRes:
ret = "Shock Resist";
break;
case StatId.EarthRes:
ret = "Earth Resistance";
break;
default:
ret = "Unknown";
break;
}
return(ret);
}
public ParserStat(StatId type, int flat)
{
Id = type;
Flat = flat;
Percent = 0;
}
public StatNode(StatService statService, string id)
: base(id, NodeType.Variable, 1)
{
_statService = statService;
Id = new StatId(id);
}
