public void Handle(ImpactEvent arg)
{
if (arg.Hit <= 0 || (!_allowPlayerConfusion && arg.Target.IsPlayer()))
{
return;
}
var component = arg.Source.Find <ConfuseImpact>();
if (component == null)
{
return;
}
var success = RulesSystem.DiceRollSuccess(component.Chance);
var logSystem = World.Get <GameLogSystem>();
logSystem.StartNewMessage(out var logMsg, out var hoverMsg);
logMsg.Append(arg.Origin.GetName());
logMsg.Append(!success ? " failed to confuse " : " confused ");
logMsg.Append(arg.Target.GetName());
hoverMsg.AppendNewLine(RulesSystem.LastQueryString.ToString());
if (success)
{
hoverMsg.Append(arg.Target.GetName());
hoverMsg.Append(" confused for ");
hoverMsg.Append(component.Length);
hoverMsg.Append(" ");
hoverMsg.Append(StringConst.TimeUnits);
}
logSystem.PostCurrentStrings(!success ? GameLogSystem.NormalColor : GameLogSystem.DamageColor);
if (success)
{
arg.Target.Post(new ConfusionEvent(arg.Target.Entity, component.Length, true));
}
}
private void SetupUnitTurn(ref TurnBasedCharacterTemplate template)
{
if (template.TurnBased.InitiativeRoll < 0)
{
template.TurnBased.InitiativeRoll = RulesSystem.CalculateD20Roll(1);
template.TurnBased.InitiativeStatBonus = RulesSystem.CalculateStatsWithLog(template.Stats.Get(Stats.Dexterity), (int)template.Stats.GetValue(Stats.Level));
var resultEvent = World.Get <RulesSystem>().Post(new RollInitiativeEvent(template, template.TurnBased.InitiativeRoll, template.TurnBased.InitiativeStatBonus));
template.TurnBased.InitiativeStatBonus = resultEvent.Bonus;
var logSystem = World.Get <GameLogSystem>();
logSystem.StartNewMessage(out var logMsg, out var hoverMsg);
logMsg.Append(template.GetName());
logMsg.Append(" initiative: ");
logMsg.Append(resultEvent.Total);
logMsg.Append(" ");
hoverMsg.AppendNewLine(RulesSystem.LastQueryString.ToString());
logSystem.PostCurrentStrings(GameLogSystem.NormalColor);
}
else
{
template.TurnBased.InitiativeStatBonus = RulesSystem.CalculateStatsWithLog(template.Stats.Get(Stats.Dexterity), (int)template.Stats.GetValue(Stats.Level));
var resultEvent = World.Get <RulesSystem>().Post(new RollInitiativeEvent(template, template.TurnBased.InitiativeRoll, template.TurnBased.InitiativeStatBonus));
template.TurnBased.InitiativeStatBonus = resultEvent.Bonus;
}
template.TurnBased.StandardActions = 1;
template.TurnBased.MinorActions = 1;
template.TurnBased.MoveActions = 1;
template.TurnBased.TurnNumber = TurnNumber;
}
public void Handle(ImpactEvent arg)
{
if (arg.Hit <= 0)
{
return;
}
var component = arg.Source.Find <InstantKillImpact>();
if (component == null)
{
if (arg.Source.Find <RaiseDeadImpact>() != null)
{
arg.Target.Post(new RaiseDeadEvent(arg.Origin, arg.Target));
}
return;
}
var success = RulesSystem.DiceRollSuccess(component.Chance);
var logSystem = World.Get <GameLogSystem>();
logSystem.StartNewMessage(out var logMsg, out var hoverMsg);
logMsg.Append(arg.Origin.GetName());
logMsg.Append(" used instant kill on ");
logMsg.Append(arg.Target.GetName());
logMsg.Append(success ? " and succeeded" : " and failed");
hoverMsg.AppendNewLine(RulesSystem.LastQueryString.ToString());
logSystem.PostCurrentStrings(!success ? GameLogSystem.NormalColor : GameLogSystem.DeathColor);
if (success)
{
arg.Target.Post(new DeathEvent(arg.Origin, arg.Target, 100));
arg.Target.Post(new CombatStatusUpdate(arg.Target, "Lethal Hit!", GameLogSystem.DeathColor));
}
}
public void RuleEventRun(ref PrepareDamageEvent context)
{
var power = RulesSystem.CalculateImpactTotal(EntityStats, Stats.Power, _damageImpact.Value.NormalizedPercent);
context.Entries.Add(new DamageEntry(power, _damageImpact.Value.DamageType, _damageImpact.Value.TargetVital,
RulesSystem.LastQueryString.ToString()));
}
public bool CanRuleEventStart(ref TryApplyEntityTag context)
{
var success = RulesSystem.DiceRollSuccess(context.Chance);
PrintLog(success, context);
return(success);
}
public void Handle(ImpactEvent arg)
{
if (arg.Hit <= 0)
{
return;
}
var component = arg.Source.Find <HealImpact>();
var sourceEntity = component.GetEntity();
var stats = sourceEntity.Get <StatsContainer>();
if (component == null || stats == null)
{
return;
}
var target = component.HealSelf ? arg.Origin : arg.Target;
var power = RulesSystem.CalculateTotal(stats, Stats.Power, component.NormalizedPercent);
var logSystem = World.Get <GameLogSystem>();
logSystem.StartNewMessage(out var logMsg, out var hoverMsg);
logMsg.Append(arg.Origin.GetName());
logMsg.Append(" healed ");
logMsg.Append(target.GetName());
logMsg.Append(" for ");
logMsg.Append(power.ToString("F0"));
hoverMsg.Append(RulesSystem.LastQueryString);
logSystem.PostCurrentStrings(GameLogSystem.DamageColor);
target.Post(new HealingEvent(power, arg.Origin, target, component.TargetVital));
}
public void Handle(ImpactEvent arg)
{
if (arg.Hit <= 0)
{
return;
}
var addMod = arg.Source.Find <AddModImpact>();
var sourceEntity = addMod.GetEntity();
var stats = sourceEntity.Get <StatsContainer>();
if (addMod == null || stats == null)
{
return;
}
var stat = stats.Get(addMod.TargetStat);
if (stat == null)
{
return;
}
if (stat.HasMod(addMod.ID))
{
RemoveStatMod(addMod.ID);
}
var power = RulesSystem.CalculateTotal(stats, Stats.Power, addMod.NormalizedPercent);
stat.AddValueMod(new BaseStat.StatValueMod(power, addMod.ID));
_fastString.Clear();
_fastString.Append("+");
_fastString.Append(power);
_fastString.Append(" ");
_fastString.Append(stat.Label);
var label = _fastString.ToString();
AddStatRemovalTimer(
new RemoveStatModifier(
stat, new ModEntry(
label, label, addMod.ID, addMod.Length,
arg.Origin.Entity, arg.Target.Entity, addMod.Icon)));
arg.Target.Post(new ModifiersChanged(arg.Target.Entity));
var logSystem = World.Get <GameLogSystem>();
logSystem.StartNewMessage(out var logMsg, out var hoverMsg);
logMsg.Append(arg.Origin.GetName());
logMsg.Append(" added ");
logMsg.Append(stat.Label);
logMsg.Append(" modifier to ");
logMsg.Append(arg.Target.GetName());
hoverMsg.AppendNewLine(RulesSystem.LastQueryString.ToString());
hoverMsg.Append(label);
hoverMsg.Append(" for ");
hoverMsg.Append(addMod.Length);
hoverMsg.Append(" ");
hoverMsg.Append(StringConst.TimeUnits);
logSystem.PostCurrentStrings(power > 0 ? GameLogSystem.HealColor : GameLogSystem.DamageColor);
}
public void RuleEventRun(ref CheckHitEvent context)
{
RulesSystem.LastQueryString.Append(context.Origin.GetName());
RulesSystem.LastQueryString.Append(": ");
var bonus = RulesSystem.CalculateStatsWithLog(context.Origin.Stats.Get(_component.Value.Stat), _component.Value.AddLevel ?
context.Origin.Level : -1);
context.AttackTotal += bonus;
RulesSystem.LastQueryString.AppendNewLine();
}
private void CheckBuy(int index)
{
if (index > 0 || Data == null)
{
return;
}
var sellPrice = RulesSystem.TotalPrice(InventoryItem);
if (World.Get <ContainerSystem>().TryAdd(Player.MainInventory, Data))
{
StatusMessages(string.Format("Bought for {0} {1}", sellPrice, GameText.DefaultCurrencyLabel));
Clear();
}
}
public bool CanRuleEventStart(ref InstantKillEvent context)
{
var success = RulesSystem.DiceRollSuccess(context.InstantKill.Chance);
var logSystem = World.Get <GameLogSystem>();
logSystem.StartNewMessage(out var logMsg, out var hoverMsg);
logMsg.Append(context.Origin.GetName());
logMsg.Append(" used instant kill on ");
logMsg.Append(context.Target.GetName());
logMsg.Append(success ? " and succeeded" : " and failed");
hoverMsg.AppendNewLine(RulesSystem.LastQueryString.ToString());
logSystem.PostCurrentStrings(!success ? GameLogSystem.NormalColor : GameLogSystem.DeathColor);
return(success);
}
public void RuleEventRun(ref CheckHitEvent context)
{
for (int i = 0; i < _component.Value.Entries.Count; i++)
{
var entry = _component.Value.Entries[i];
if (entry.TargetDefense == context.TargetDefense)
{
RulesSystem.LastQueryString.Append(context.Target.GetName());
RulesSystem.LastQueryString.Append(": ");
var bonus = RulesSystem.CalculateStatsWithLog(context.Target.Stats.Get(entry.TargetStat));
context.AttackTotal += bonus;
RulesSystem.LastQueryString.AppendNewLine();
}
}
}
public void RuleEventEnded(ref ImpactEvent context)
{
var target = _heal.Value.HealSelf ? context.Origin : context.Target;
var power = RulesSystem.CalculateImpactTotal(EntityStats, PixelComrades.Stats.Power, _heal.Value.NormalizedPercent);
var logSystem = World.Get <GameLogSystem>();
logSystem.StartNewMessage(out var logMsg, out var hoverMsg);
logMsg.Append(context.Origin.GetName());
logMsg.Append(" healed ");
logMsg.Append(target.GetName());
logMsg.Append(" for ");
logMsg.Append(power.ToString("F0"));
hoverMsg.Append(RulesSystem.LastQueryString);
logSystem.PostCurrentStrings(GameLogSystem.DamageColor);
World.Get <RulesSystem>().Post(new HealingEvent(power, context.Origin, target, _heal.Value.TargetVital));
}
public void RuleEventRun(ref TryApplyMod context)
{
var stats = context.Origin.Stats;
var stat = stats.Get(context.TargetStat);
if (stat == null)
{
return;
}
if (stat.HasMod(context.ID))
{
RemoveStatMod(context.ID);
}
var power = RulesSystem.CalculateImpactTotal(stats, Stats.Power, context.NormalizedPercent);
stat.AddValueMod(new BaseStat.StatValueMod(power, context.ID));
_fastString.Clear();
_fastString.Append("+");
_fastString.Append(power);
_fastString.Append(" ");
_fastString.Append(stat.Label);
var label = _fastString.ToString();
AddStatRemovalTimer(
new RemoveStatModifier(
stat, new ModEntry(
label, label, context.ID, context.Length,
context.Origin.Entity, context.Target.Entity, context.Icon)));
context.Target.Post(new ModifiersChanged(context.Target.Entity));
var logSystem = World.Get <GameLogSystem>();
logSystem.StartNewMessage(out var logMsg, out var hoverMsg);
logMsg.Append(context.Origin.GetName());
logMsg.Append(" added ");
logMsg.Append(stat.Label);
logMsg.Append(" modifier to ");
logMsg.Append(context.Target.GetName());
hoverMsg.AppendNewLine(RulesSystem.LastQueryString.ToString());
hoverMsg.Append(label);
hoverMsg.Append(" for ");
hoverMsg.Append(context.Length);
hoverMsg.Append(" ");
hoverMsg.Append(StringConst.TimeUnits);
logSystem.PostCurrentStrings(power > 0 ? GameLogSystem.HealColor : GameLogSystem.DamageColor);
}
private void TryBuy()
{
if (Data == null)
{
return;
}
if (Player.MainInventory.IsFull)
{
StatusMessages("Inventory full");
return;
}
var sellPrice = RulesSystem.TotalPrice(InventoryItem);
if (Player.DefaultCurrencyHolder.Value < sellPrice)
{
StatusMessages(string.Format("Costs {0}, Not enough {1}", sellPrice, GameText.DefaultCurrencyLabel));
return;
}
UIModalQuestion.Set(CheckBuy, string.Format("Buy for {0} {1}?", sellPrice, GameText.DefaultCurrencyLabel));
}
public void Handle(DataDescriptionUpdating arg)
{
var inventoryItem = arg.Data.GetEntity().Get <InventoryItem>();
if (inventoryItem == null)
{
return;
}
FastString.Instance.Clear();
FastString.Instance.AppendBoldLabelNewLine("Price", RulesSystem.TotalPrice(inventoryItem));
if (inventoryItem.Count > 1)
{
FastString.Instance.AppendBoldLabelNewLine("Count", inventoryItem.Count);
}
if (!inventoryItem.Identified)
{
FastString.Instance.AppendNewLine("Unidentified");
}
FastString.Instance.AppendBoldLabelNewLine("Rarity", inventoryItem.Rarity.ToString());
arg.Data.Text += FastString.Instance.ToString();
}
private void CheckBuy(int index)
{
if (index > 0)
{
_currentButton = null;
return;
}
var item = _currentButton.Data.Get <InventoryItem>();
if (item == null)
{
_currentButton = null;
return;
}
var sellPrice = RulesSystem.TotalPrice(item);
if (Player.MainInventory.TryAdd(item.GetEntity()))
{
Player.DefaultCurrencyHolder.ReduceValue(sellPrice);
FloatingText(_currentButton.RectTransform, string.Format("Bought for {0} {1}", sellPrice, GameText.DefaultCurrencyLabel));
}
_currentButton = null;
}
public void Handle(ImpactEvent arg) {
if (arg.Hit <= 0) {
return;
}
var component = arg.Source.Find<ApplyTagImpact>();
if (component == null) {
return;
}
var success = RulesSystem.DiceRollSuccess(component.Chance);
var logSystem = World.Get<GameLogSystem>();
logSystem.StartNewMessage(out var logMsg, out var hoverMsg);
logMsg.Append(arg.Origin.GetName());
logMsg.Append(!success ? " failed to apply " : " applied ");
logMsg.Append(component.Description);
logMsg.Append(" on ");
logMsg.Append(arg.Target.GetName());
hoverMsg.AppendNewLine(RulesSystem.LastQueryString.ToString());
if (success) {
hoverMsg.Append(arg.Target.GetName());
hoverMsg.Append(" has ");
hoverMsg.Append(component.Description);
hoverMsg.Append(" for ");
hoverMsg.Append(component.Length);
hoverMsg.Append(" ");
hoverMsg.Append(StringConst.TimeUnits);
}
logSystem.PostCurrentStrings(!success ? GameLogSystem.NormalColor : GameLogSystem.DamageColor);
if (success) {
arg.Target.Tags.Add(component.Tag);
if (component.Length > 0) {
_timerArray.Add(new TagTimerEvent(arg.Target, TimeManager.Time + component.Length,
component.Tag));
}
arg.Target.Post(new TagChangeEvent(arg.Target.Entity, component.Tag, true));
}
}
/*
* var amt = arg.Amount;
* bool isCritical = false;
* string source = arg.Origin.Get<LabelComponent>()?.Text;
* if (string.IsNullOrEmpty(source)) {
* var msg = isCritical ? CombatMessages.DamagedCritNoActor : CombatMessages.DamagedNoActor;
* msg.Show(UIStyle.Damage.ToHex(), Name, amt.ToString("F0"));
* }
* else {
* var msg = isCritical ? CombatMessages.DamagedCritActor : CombatMessages.DamageFromActor;
* msg.Show(UIStyle.Damage.ToHex(), source, Name, amt.ToString("F0"));
* }
*/
public void Handle(ImpactEvent arg)
{
if (arg.Hit <= 0)
{
return;
}
var component = arg.Source.Find <DamageImpact>();
var sourceEntity = component.GetEntity();
var stats = sourceEntity.Get <StatsContainer>();
if (component == null || stats == null)
{
return;
}
var targetStat = arg.Target.Stats.GetVital(component.TargetVital);
if (targetStat == null)
{
return;
}
var power = RulesSystem.CalculateTotal(stats, Stats.Power, component.NormalizedPercent);
var logSystem = World.Get <GameLogSystem>();
logSystem.StartNewMessage(out var logMsg, out var hoverMsg);
logMsg.Append(arg.Origin.GetName());
logMsg.Append(" hit ");
logMsg.Append(power.ToString("F0"));
logMsg.Append(" ");
logMsg.Append(targetStat.Label);
logMsg.Append(" for ");
logMsg.Append(arg.Target.GetName());
hoverMsg.Append(RulesSystem.LastQueryString);
logSystem.PostCurrentStrings(GameLogSystem.DamageColor);
//CollisionExtensions.GetHitMultiplier(impact.Hit, impact.Target)
arg.Target.Post(new TakeDamageEvent(power, arg, component.DamageType, component.TargetVital));
}
private void BuyClickDel(UISimpleGameDataButton button, PointerEventData.InputButton buttonEvent)
{
var item = button.Data.Get <InventoryItem>();
if (item == null)
{
return;
}
if (Player.MainInventory.IsFull)
{
FloatingText(button.RectTransform, "Inventory full");
return;
}
var sellPrice = RulesSystem.TotalPrice(item);
if (Player.DefaultCurrencyHolder.Value < sellPrice)
{
FloatingText(button.RectTransform, string.Format("Costs {0}, Not enough {1}", sellPrice, GameText.DefaultCurrencyLabel));
return;
}
_currentButton = button;
UIModalQuestion.Set(CheckBuy, string.Format("Buy for {0} {1}?", sellPrice, GameText.DefaultCurrencyLabel));
}
public void HandleGlobal(TakeDamageEvent msg)
{
_eventLog.Add(msg);
if (msg.Amount <= 0)
{
return;
}
var node = msg.Target;
if (node == null)
{
return;
}
var logSystem = World.Get <GameLogSystem>();
logSystem.StartNewMessage(out var dmgMsg, out var dmgHoverMsg);
var blockDamage = node.Entity.Get <BlockDamage>();
if (blockDamage != null)
{
for (int i = 0; i < blockDamage.DamageBlockers.Count; i++)
{
if (blockDamage.DamageBlockers[i](msg))
{
dmgMsg.Append(msg.Target.GetName());
dmgMsg.Append(" completely blocked damage from ");
dmgMsg.Append(msg.Origin.GetName());
logSystem.PostCurrentStrings(GameLogSystem.DamageColor);
return;
}
}
}
var damageAmount = msg.Amount;
if (node.StatDefend != null)
{
for (int i = 0; i < node.StatDefend.Count; i++)
{
if (node.StatDefend[i].DamageType != msg.DamageType)
{
continue;
}
var defAmt = RulesSystem.GetDefenseAmount(damageAmount, node.StatDefend[i].Stat.Value);
if (defAmt <= 0)
{
continue;
}
damageAmount = Mathf.Max(0, damageAmount - defAmt);
dmgHoverMsg.Append(node.StatDefend[i].Stat.Stat.Label);
dmgHoverMsg.Append(" Reduced Damage by ");
dmgHoverMsg.AppendNewLine(defAmt.ToString("F1"));
}
}
if (node.DamageAbsorb != null)
{
for (int i = 0; i < node.DamageAbsorb.Count; i++)
{
if (node.DamageAbsorb[i].DamageType != msg.DamageType)
{
continue;
}
var defAmt = RulesSystem.GetDefenseAmount(damageAmount, node.DamageAbsorb[i].Amount);
if (defAmt <= 0)
{
continue;
}
if (defAmt > node.DamageAbsorb[i].Remaining)
{
defAmt = node.DamageAbsorb[i].Remaining;
}
damageAmount = Mathf.Max(0, damageAmount - defAmt);
dmgHoverMsg.Append(node.DamageAbsorb[i].Source);
dmgHoverMsg.Append(" Absorbed ");
dmgHoverMsg.Append(defAmt.ToString("F1"));
dmgHoverMsg.AppendNewLine(" Damage");
node.DamageAbsorb[i].Remaining -= defAmt;
}
node.DamageAbsorb.CheckLimits();
}
float previousValue = 0;
var stats = node.Stats;
var vital = stats.GetVital(msg.TargetVital);
if (vital == null)
{
vital = stats.GetVital(GameData.Vitals.GetID(msg.TargetVital));
}
if (vital != null)
{
dmgHoverMsg.Append(vital.ToLabelString());
dmgHoverMsg.Append(" - ");
dmgHoverMsg.Append(damageAmount);
dmgHoverMsg.Append(" = ");
previousValue = vital.Current;
vital.Current -= damageAmount;
dmgHoverMsg.Append(vital.ToLabelString());
}
dmgMsg.Append(msg.Target.GetName());
dmgMsg.Append(" took ");
dmgMsg.Append(damageAmount.ToString("F1"));
dmgMsg.Append(" damage ");
if (damageAmount > 0)
{
node.Entity.Post(new CombatStatusUpdate(node.Entity, damageAmount.ToString("F1"), Color.red));
msg.Impact.Source.PostAll(new CausedDamageEvent(damageAmount, msg));
}
if (vital != null && vital.Current <= 0 && msg.TargetVital == Stats.Health)
{
node.Entity.Post(new DeathEvent(msg.Origin, msg.Target, damageAmount - previousValue));
}
}
public void RuleEventRun(ref TakeDamageEvent msg)
{
_eventLog.Add(msg);
if (msg.Target.IsDead)
{
msg.Clear();
return;
}
var target = msg.Target;
var logSystem = World.Get <GameLogSystem>();
logSystem.StartNewMessage(out var dmgMsg, out var dmgHoverMsg);
if (msg.Hit.Result == CollisionResult.CriticalHit)
{
dmgMsg.Append("<b>");
dmgHoverMsg.Append("<b>");
}
if (target.StatDefend != null)
{
for (int i = 0; i < target.StatDefend.Count; i++)
{
for (int d = msg.Entries.Count - 1; d >= 0; d--)
{
var dmg = msg.Entries[d];
if (target.StatDefend[i].DamageType != dmg.DamageType)
{
continue;
}
var defAmt = RulesSystem.GetDefenseAmount(dmg.Amount, target.StatDefend[i].Stat.Value);
if (defAmt <= 0)
{
continue;
}
var amount = Mathf.Max(0, dmg.Amount - defAmt);
dmgHoverMsg.Append(target.StatDefend[i].Stat.Stat.Label);
dmgHoverMsg.Append(" Reduced Damage by ");
dmgHoverMsg.AppendNewLine(defAmt.ToString("F1"));
msg.Entries.Remove(dmg);
msg.Entries.Add(new DamageEntry(amount, dmg.DamageType, dmg.TargetVital, dmg.Description));
}
}
}
if (target.DamageAbsorb != null)
{
for (int i = 0; i < target.DamageAbsorb.Count; i++)
{
for (int d = msg.Entries.Count - 1; d >= 0; d--)
{
var dmg = msg.Entries[d];
if (target.DamageAbsorb[i].DamageType != dmg.DamageType)
{
continue;
}
var defAmt = RulesSystem.GetDefenseAmount(dmg.Amount, target.DamageAbsorb[i].Amount);
if (defAmt <= 0)
{
continue;
}
if (defAmt > target.DamageAbsorb[i].Remaining)
{
defAmt = target.DamageAbsorb[i].Remaining;
}
var amount = Mathf.Max(0, dmg.Amount - defAmt);
dmgHoverMsg.Append(target.DamageAbsorb[i].Source);
dmgHoverMsg.Append(" Absorbed ");
dmgHoverMsg.Append(defAmt.ToString("F1"));
dmgHoverMsg.AppendNewLine(" Damage");
target.DamageAbsorb[i].Remaining -= defAmt;
target.DamageAbsorb.CheckLimits();
msg.Entries.Remove(dmg);
msg.Entries.Add(new DamageEntry(amount, dmg.DamageType, dmg.TargetVital, dmg.Description));
}
}
}
float totalDmg = 0;
for (int i = 0; i < msg.Entries.Count; i++)
{
if (msg.Target.IsDead)
{
break;
}
var dmg = msg.Entries[i];
var damageAmount = dmg.Amount;
totalDmg += damageAmount;
float previousValue = 0;
var stats = target.Stats;
var vital = stats.GetVital(dmg.TargetVital);
if (vital == null)
{
vital = stats.GetVital(GameData.Vitals.GetID(dmg.TargetVital));
}
if (vital != null)
{
dmgHoverMsg.Append(vital.ToLabelString());
dmgHoverMsg.Append(" - ");
dmgHoverMsg.Append(damageAmount);
dmgHoverMsg.Append(" = ");
previousValue = vital.Current;
vital.Current -= damageAmount;
dmgHoverMsg.Append(vital.ToLabelString());
}
dmgMsg.Append(msg.Target.GetName());
dmgMsg.Append(" took ");
dmgMsg.Append(damageAmount.ToString("F1"));
dmgMsg.Append(" damage ");
if (vital != null && vital.Current <= 0 && dmg.TargetVital == Stats.Health)
{
target.Entity.Post(new DeathEvent(msg.Origin, msg.Target, msg.Hit.Point, damageAmount - previousValue));
}
}
if (totalDmg > 0)
{
target.Entity.Post(new CombatStatusUpdate(target.Entity, totalDmg.ToString("F1"), Color.red));
msg.Origin.Post(new CausedDamageEvent(totalDmg, msg));
msg.Target.Post(new ReceivedDamageEvent(totalDmg, msg));
}
logSystem.PostCurrentStrings(GameLogSystem.DamageColor);
msg.Clear();
}
public float GetMax()
{
return(MultiplyResult * (RulesSystem.GetMaxDice(DiceSides, DiceRolls) + BaseValue + ModTotal));
}
