public void SetPerformerSkillAnimation(SkillArtInfo skillInfo, bool activate)
{
SkeletonAnimation skillAnimation = unitAnimator.Effects.Find(item => item.name == skillInfo.ArtId);
if (skillAnimation != null)
{
skillAnimation.gameObject.layer = CurrentState.gameObject.layer;
skillAnimation.gameObject.SetActive(activate);
skillAnimation.Reset();
}
unitAnimator.Animator.SetBool(skillInfo.AnimationId, activate);
}
public void UnitSkillIntroOverriden(FormationUnit unit, SkillArtInfo skillArtInfo, string mode)
{
if (unit.CurrentHalo != null)
{
unit.CurrentHalo.skeletonAnimation.MeshRenderer.enabled = false;
}
unit.SetLayer(9);
unit.SetSortingOrder(PartyFormationManager.ShowoffOrder + 6);
if (unit.CombatInfo.IsImmobilized)
{
unit.SetDefendAnimation(false);
}
unit.SetPerformerSkillAnimationOverriden(skillArtInfo, mode, true);
}
public void UnitSkillIntro(FormationUnit unit, SkillArtInfo skillArtInfo)
{
if (unit.CurrentHalo != null)
{
unit.CurrentHalo.SkeletonAnimation.MeshRenderer.enabled = false;
}
unit.SetLayer(9);
unit.SetSortingOrder(ShowoffOrder + 6);
if (unit.CombatInfo.IsImmobilized)
{
unit.SetDefendAnimation(false);
}
unit.SetPerformerSkillAnimation(skillArtInfo, true);
}
public SkillTargetInfo UpdateSkillInfo(FormationUnit performer, CombatSkill skill)
{
Mode = performer.Character.Mode;
Skill = skill;
SkillArtInfo = performer.Character.SkillArtInfo.Find(info => info.SkillId == skill.Id);
if (skill.LimitPerBattle.HasValue)
{
performer.CombatInfo.SkillsUsedInBattle.Add(skill.Id);
}
if (skill.LimitPerTurn.HasValue)
{
performer.CombatInfo.SkillsUsedThisTurn.Add(skill.Id);
}
return(this);
}
public void SetPerformerSkillAnimationOverriden(SkillArtInfo skillInfo, string mode, bool activate)
{
SkeletonAnimation skillAnimation = unitAnimator.Effects.Find(item => item.name == skillInfo.ArtId);
if (skillAnimation != null)
{
skillAnimation.gameObject.layer = CurrentState.gameObject.layer;
skillAnimation.gameObject.SetActive(activate);
if (activate)
{
skillAnimation.Reset();
skillAnimation.state.SetAnimation(0, skillInfo.ArtId + "_" + mode, false).Time = 0;
skillAnimation.Update(0);
skillAnimation.AnimationName = skillInfo.ArtId + "_" + mode;
}
}
unitAnimator.Animator.SetBool(skillInfo.AnimationId + "_" + mode, activate);
}
public void UnitSkillOutroOverriden(FormationUnit unit, SkillArtInfo skillArtInfo, string mode)
{
unit.SetLayer(0);
if (unit.Character.RenderRankOverride == 0)
{
unit.SetSortingOrder(PartyFormationManager.ShowoffOrder - unit.Rank);
}
else
{
unit.SetSortingOrder(PartyFormationManager.ShowoffOrder - unit.Character.RenderRankOverride);
}
unit.DeleteTarget(0.1f);
unit.SetPerformerSkillAnimationOverriden(skillArtInfo, mode, false);
if (unit.CombatInfo.IsImmobilized)
{
unit.SetDefendAnimation(true);
}
if (unit.CurrentHalo != null)
{
unit.CurrentHalo.skeletonAnimation.MeshRenderer.enabled = true;
}
}
public static void ExecuteSkill(FormationUnit performerUnit, FormationUnit targetUnit, CombatSkill skill, SkillArtInfo artInfo)
{
SkillResult.Skill = skill;
SkillResult.ArtInfo = artInfo;
var target = targetUnit.Character;
var performer = performerUnit.Character;
ApplyConditions(performerUnit, targetUnit, skill);
if (skill.Move != null && !performerUnit.CombatInfo.IsImmobilized)
{
if (skill.Move.Pullforward > 0)
{
performerUnit.Pull(skill.Move.Pullforward, false);
}
else if (skill.Move.Pushback > 0)
{
performerUnit.Push(skill.Move.Pushback, false);
}
}
if (skill.Category == SkillCategory.Heal || skill.Category == SkillCategory.Support)
{
#region Heal
if (skill.Heal != null)
{
float initialHeal = RandomSolver.Next(skill.Heal.MinAmount, skill.Heal.MaxAmount + 1) *
(1 + performer.GetSingleAttribute(AttributeType.HpHealPercent).ModifiedValue);
if (skill.IsCritValid)
{
float critChance = performer[AttributeType.CritChance].ModifiedValue + skill.CritMod / 100;
if (RandomSolver.CheckSuccess(critChance))
{
int critHeal = target.Heal(initialHeal * 1.5f, true);
targetUnit.OverlaySlot.UpdateOverlay();
SkillResult.AddResultEntry(new SkillResultEntry(targetUnit, critHeal, SkillResultType.CritHeal));
ApplyEffects(performerUnit, targetUnit, skill);
if (targetUnit.Character.IsMonster == false)
{
DarkestDungeonManager.Data.Effects["crit_heal_stress_heal"].ApplyIndependent(targetUnit);
}
return;
}
}
int heal = target.Heal(initialHeal, true);
targetUnit.OverlaySlot.UpdateOverlay();
SkillResult.AddResultEntry(new SkillResultEntry(targetUnit, heal, SkillResultType.Heal));
ApplyEffects(performerUnit, targetUnit, skill);
}
else
{
SkillResult.AddResultEntry(new SkillResultEntry(targetUnit, SkillResultType.Utility));
ApplyEffects(performerUnit, targetUnit, skill);
}
#endregion
}
else
{
#region Damage
float accuracy = skill.Accuracy + performer.Accuracy;
float hitChance = Mathf.Clamp(accuracy - target.Dodge, 0, 0.95f);
float roll = (float)RandomSolver.NextDouble();
if (target.BattleModifiers != null && target.BattleModifiers.CanBeHit == false)
{
roll = float.MaxValue;
}
if (roll > hitChance)
{
if (!(skill.CanMiss == false || (target.BattleModifiers != null && target.BattleModifiers.CanBeMissed == false)))
{
if (roll > Mathf.Min(accuracy, 0.95f))
{
SkillResult.AddResultEntry(new SkillResultEntry(targetUnit, SkillResultType.Miss));
}
else
{
SkillResult.AddResultEntry(new SkillResultEntry(targetUnit, SkillResultType.Dodge));
}
ApplyEffects(performerUnit, targetUnit, skill);
return;
}
}
float initialDamage = performer is Hero?
Mathf.Lerp(performer.MinDamage, performer.MaxDamage, (float)RandomSolver.NextDouble()) * (1 + skill.DamageMod) :
Mathf.Lerp(skill.DamageMin, skill.DamageMax, (float)RandomSolver.NextDouble()) * performer.DamageMod;
int damage = Mathf.CeilToInt(initialDamage * (1 - target.Protection));
if (damage < 0)
{
damage = 0;
}
if (target.BattleModifiers != null && target.BattleModifiers.CanBeDamagedDirectly == false)
{
damage = 0;
}
if (skill.IsCritValid)
{
float critChance = performer.GetSingleAttribute(AttributeType.CritChance).ModifiedValue + skill.CritMod;
if (RandomSolver.CheckSuccess(critChance))
{
int critDamage = target.TakeDamage(damage * 1.5f);
targetUnit.OverlaySlot.UpdateOverlay();
if (target.HasZeroHealth)
{
SkillResult.AddResultEntry(new SkillResultEntry(targetUnit, critDamage, true, SkillResultType.Crit));
}
else
{
SkillResult.AddResultEntry(new SkillResultEntry(targetUnit, critDamage, SkillResultType.Crit));
}
ApplyEffects(performerUnit, targetUnit, skill);
if (targetUnit.Character.IsMonster == false)
{
DarkestDungeonManager.Data.Effects["Stress 2"].ApplyIndependent(targetUnit);
}
return;
}
}
damage = target.TakeDamage(damage);
targetUnit.OverlaySlot.UpdateOverlay();
if (target.HasZeroHealth)
{
SkillResult.AddResultEntry(new SkillResultEntry(targetUnit, damage, true, SkillResultType.Hit));
}
else
{
SkillResult.AddResultEntry(new SkillResultEntry(targetUnit, damage, SkillResultType.Hit));
}
ApplyEffects(performerUnit, targetUnit, skill);
#endregion
}
}
private void LoadData(List <string> heroData)
{
int index = 2;
StringId = heroData[0].Split(' ')[1];
while (heroData[index] != ".end")
{
List <string> data = heroData[index++].Replace("%", "").Replace("\"", "").
Split(new[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries).ToList();
switch (data[0])
{
case "rendering:":
RenderingRankOverride = int.Parse(data[2]);
break;
case "commonfx:":
if (CommonEffects == null)
{
CommonEffects = new CommonEffects(data);
}
else
{
CommonEffects.LoadData(data);
}
break;
case "combat_skill:":
SkillArtInfo skillArt = new SkillArtInfo(data, false);
SkillArtInfo.Add(skillArt);
break;
case "riposte_skill:":
SkillArtInfo riposteArt = new SkillArtInfo(data, false);
SkillArtInfo.Add(riposteArt);
break;
default:
Debug.LogError("Unknown art token in hero: " + StringId);
break;
}
}
index += 2;
while (heroData[index] != ".end")
{
List <string> data = heroData[index++].Replace("%", "").Replace("\"", "").
Split(new [] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries).ToList();
switch (data[0])
{
case "resistances:":
Resistanses.Add(AttributeType.Stun, float.Parse(data[2]) / 100);
Resistanses.Add(AttributeType.Poison, float.Parse(data[4]) / 100);
Resistanses.Add(AttributeType.Bleed, float.Parse(data[6]) / 100);
Resistanses.Add(AttributeType.Disease, float.Parse(data[8]) / 100);
Resistanses.Add(AttributeType.Move, float.Parse(data[10]) / 100);
Resistanses.Add(AttributeType.Debuff, float.Parse(data[12]) / 100);
Resistanses.Add(AttributeType.DeathBlow, float.Parse(data[14]) / 100);
Resistanses.Add(AttributeType.Trap, float.Parse(data[16]) / 100);
break;
case "weapon:":
Equipment weapon = new Equipment(data[2], Weapons.Count + 1, HeroEquipmentSlot.Weapon);
weapon.EquipmentModifiers.Add(new FlatModifier(AttributeType.DamageLow, float.Parse(data[6]), false));
weapon.EquipmentModifiers.Add(new FlatModifier(AttributeType.DamageHigh, float.Parse(data[7]), false));
weapon.EquipmentModifiers.Add(new FlatModifier(AttributeType.CritChance, float.Parse(data[9]) / 100, false));
weapon.EquipmentModifiers.Add(new FlatModifier(AttributeType.SpeedRating, float.Parse(data[11]), false));
Weapons.Add(weapon);
break;
case "armour:":
Equipment armor = new Equipment(data[2], Armors.Count + 1, HeroEquipmentSlot.Armor);
armor.EquipmentModifiers.Add(new FlatModifier(AttributeType.DefenseRating, float.Parse(data[4]) / 100, false));
armor.EquipmentModifiers.Add(new FlatModifier(AttributeType.HitPoints, float.Parse(data[8]), true));
Armors.Add(armor);
break;
case "combat_skill:":
List <string> combatData = new List <string>();
data = heroData[index - 1].Split(new [] { '\"' }, StringSplitOptions.RemoveEmptyEntries).ToList();
bool isEffectData = false;
foreach (var item in data)
{
if (isEffectData)
{
if (item.Trim(' ').StartsWith("."))
{
isEffectData = false;
}
else
{
combatData.Add(item);
continue;
}
}
string[] combatItems = item.Replace("%", "").Split(
new [] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
if (combatItems[combatItems.Length - 1] == ".effect")
{
isEffectData = true;
}
combatData.AddRange(combatItems);
}
CombatSkillVariants.Add(new CombatSkill(combatData, true));
break;
case "combat_move_skill:":
MoveSkill = new MoveSkill(data[2], int.Parse(data[8]), int.Parse(data[9]));
break;
case "riposte_skill:":
List <string> riposteData = new List <string>();
data = heroData[index - 1].Split('\"').ToList();
bool isRiposteEffect = false;
foreach (var item in data)
{
if (isRiposteEffect)
{
if (item.Trim(' ')[0] == '.')
{
isRiposteEffect = false;
}
else
{
riposteData.Add(item);
continue;
}
}
string[] combatItems = item.Replace("%", "").Split(
new [] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
if (combatItems[combatItems.Length - 1] == ".effect")
{
isRiposteEffect = true;
}
riposteData.AddRange(combatItems);
}
RiposteSkill = new CombatSkill(riposteData, true);
break;
case "incompatible_party_member:":
IncompatiablePartyTag = data[4];
break;
case "tag:":
Tags.Add(data[2]);
break;
case "controlled:":
break;
case "id_index:":
IndexId = int.Parse(data[2]);
break;
case "skill_selection:":
CanSelectCombatSkills = bool.Parse(data[2]);
NumberOfSelectedCombatSkills = int.Parse(data[4]);
break;
case "deaths_door:":
if (DeathDoor == null)
{
DeathDoor = new DeathDoor(data);
}
else
{
DeathDoor.LoadData(data);
}
break;
case "generation:":
if (Generation == null)
{
Generation = new HeroGeneration(data);
}
else
{
Generation.LoadData(data);
}
break;
case "extra_battle_loot:":
if (ExtraBattleLoot == null)
{
ExtraBattleLoot = new LootDefinition(data);
}
else
{
ExtraBattleLoot.LoadData(data);
}
break;
case "extra_curio_loot:":
if (ExtraCurioLoot == null)
{
ExtraCurioLoot = new LootDefinition(data);
}
else
{
ExtraCurioLoot.LoadData(data);
}
break;
case "extra_stack_limit:":
ExtraStackLimit = data[2];
break;
case "mode:":
Modes.Add(new CharacterMode(data));
break;
default:
Debug.LogError("Unknown info token " + data[0] + " in hero: " + StringId);
break;
}
}
CombatSkills = new List <CombatSkill>(CombatSkillVariants.FindAll(skill => skill.Level == 0));
}
public void SetTargetSkillEffect(SkillArtInfo artInfo, FormationUnit performer)
{
SetTargetEffect(performer, artInfo.TargetChestFX, "fxchest");
SetTargetEffect(performer, artInfo.TargetFX, "fxskill");
SetTargetEffect(performer, artInfo.TargetHeadFX, "fxhead");
}
