public override void ExecutedSkillFast(Skill skill, SkillReport skillreport)
{
if (skill.GetRange() != Skill.RANGE_SELF)
{
Remove();
}
}
public override void ExecutedSkill(Skill skill, SkillReport skillreport)
{
if (skillreport.TargetAfter.MutableStats[AttributeStats.StatType.Health].Value == 0)
{
boardEntity.Stats.AddActionPoints(1);
}
}
private int HealthAfterDamage(SkillReport report, Stats targetStats, DamagePackage damage)
{
Stats beforeStats = targetStats.GetCopy();
Stats afterStats = targetStats.GetCopy();
int tempArmour = 0;
if (damage.Type == DamageType.physical)
{
tempArmour = targetStats.GetNonMuttableStat(StatType.Armour).Value;
tempArmour -= damage.Piercing;
if (tempArmour < 0)
{
tempArmour = 0;
}
}
if (damage.Type == DamageType.physical || damage.Type == DamageType.pure)
{
int tempDamage = damage.Damage;
if (damage.Type == DamageType.physical)
{
tempDamage -= tempArmour;
if (tempDamage < 0)
{
tempDamage = 0;
}
}
int oldHealth = targetStats.GetMutableStat(StatType.Health).Value;
int newHealth = oldHealth - tempDamage;
if (newHealth <= 0)
{
// dat bibba dead
newHealth = 0;
}
DamageDisplay damageDisplay = new DamageDisplay();
damageDisplay.value = tempDamage;
damageDisplay.character = (CharacterBoardEntity)targetStats.BoardEntity;
if (damage.Type == DamageType.physical)
{
damageDisplay.color = Color.red;
}
else
{
damageDisplay.color = Color.magenta;
}
report.DamageDisplays.Add(damageDisplay);
afterStats.SetMutableStat(StatType.Health, newHealth);
report.targetAfter = afterStats;
report.targetBefore = beforeStats;
return(newHealth);
}
else
{
return(targetStats.GetMutableStat(StatType.Health).Value);
}
}
public override void ExecutedSkill(Skill skill, SkillReport skillreport)
{
if (skill is BasicAttack)
{
skillreport.targetAfter.BoardEntity.AddPassive(new BuffStun());
Remove();
}
}
public void AddAttackAction(Skill skill, Tile t, Action callBack)
{
SkillReport report = skill.TheoreticalAction(t);
if (report.TargetAfter.MutableStats[AttributeStats.StatType.Health].Value == 0)
{
scoredKill = true;
}
targetScore = report.targetAfter.GetMutableStat(AttributeStats.StatType.Health).Value;
apCost += skill.GetAPCost();
actions.Add(() => skill.Action(t, callBack));
}
public void QuickDamage(CharacterBoardEntity target, List <DamagePackage> damages)
{
foreach (DamagePackage package in damages)
{
SkillReport report = new SkillReport();
int health = HealthAfterDamage(report, target.Stats, package);
Stats afterStats = target.Stats.GetCopy();
afterStats.SetMutableStat(StatType.Health, health);
report.targets.Add(new Tuple <Stats, Stats>(target.Stats.GetCopy(), afterStats));
ExecuteSkillReport(report);
}
turnManager.CheckEntitiesForDeath();
}
public override void ExecutedSkill(Skill skill, SkillReport skillreport)
{
if (skillreport != null)
{
foreach (Tuple <Stats, Stats> statInstance in skillreport.targets)
{
if (statInstance.second.GetMutableStat(StatType.Health).Value == 0)
{
Trigger();
}
}
}
}
public override void ExecutedSkill(Skill skill, SkillReport skillReport)
{
if (skillReport != null)
{
foreach (Tuple <Stats, Stats> report in skillReport.targets)
{
int difference = report.first.GetMutableStat(StatType.Health).Value - report.second.GetMutableStat(StatType.Health).Value;
int damageThreshold = Mathf.CeilToInt(report.second.GetNonMuttableStat(StatType.Health).Value *damagePercentage);
if (difference >= damageThreshold)
{
Trigger();
//this should only trigger once ?? might change
break;
}
}
}
}
private StatisticsSkillEntity BuildSkillEntity(SkillReport outputskill, string type, string source)
{
var entity = new StatisticsSkillEntity();
entity.Id = outputskill.SkillId;
entity.Round = outputskill.Round;
entity.Name = ModelMgr.GetSkillStr(outputskill.SkillId.ToString());
if (outputskill.SkillTargets != null && outputskill.SkillTargets.Length > 0)
{
foreach (var t in outputskill.SkillTargets)
{
entity.Target += t.ToString() + ',';
}
entity.Target = entity.Target.TrimEnd(',');
}
entity.Type = type;
entity.Source = source;
return(entity);
}
public SkillReport getEmployeesBySkill(string skillName)
{
var employees =
graphClient.Cypher
.Match("(emp:Employee)-[rel:HAS_EXPERIENCE]->(sk:Skill)")
.Where("sk.name = {skillName}")
.WithParam("skillName", skillName)
.ReturnDistinct((emp, rel) => new
{
Emp = emp.As <Employee>().name,
Rel = rel.As <SkillExperience>().level
})
.Results;
SkillReport skrp = new SkillReport(skillName);
foreach (var employee in employees)
{
switch (employee.Rel)
{
case "Junior":
skrp.junior.Add(employee.Emp);
break;
case "Intermediate":
skrp.intermediate.Add(employee.Emp);
break;
case "Senior":
skrp.senior.Add(employee.Emp);
break;
case "Lead":
skrp.lead.Add(employee.Emp);
break;
}
}
return(skrp);
}
public void ExecuteSkillReport(SkillReport skillReport)
{
if (skillReport != null)
{
foreach (Tuple <Stats, Stats> stats in skillReport.targets)
{
stats.second.BoardEntity.Stats = stats.second;
stats.second.UpdateStatHandler();
}
// should put this in an couroutine for later and make more better
foreach (DamageDisplay displayDamage in skillReport.DamageDisplays)
{
displayDamage.character.GetComponent <FloatingTextGenerator>().AddTextDisplay(displayDamage.GetFloatingText());
}
foreach (TextDisplay textDisplay in skillReport.TextDisplays)
{
textDisplay.target.GetComponent <FloatingTextGenerator>().AddTextDisplay(textDisplay);
}
turnManager.CheckEntitiesForDeath();
}
}
public SkillReport ExecuteSkillHealing(Skill skill, CharacterBoardEntity source, CharacterBoardEntity target, int value)
{
SkillReport report = new SkillReport();
report.targetBefore = target.Stats.GetCopy();
report.targetAfter = target.Stats.GetCopy();
report.targetAfter.SetMutableStat(StatType.Health, report.targetAfter.GetMutableStat(StatType.Health).Value + value);
report.targets.Add(new Tuple <Stats, Stats>(report.targetBefore, report.targetAfter));
int healValue = report.targetAfter.GetMutableStat(StatType.Health).Value - report.targetBefore.GetMutableStat(StatType.Health).Value;
report.TextDisplays.Add(new TextDisplay()
{
text = "+ " + healValue,
textColor = Color.green,
callback = (() => target.SetAnimation(Common.Animator.AnimatorUtils.animationType.win)),
target = target
});
return(report);
}
public SkillReport ExecuteSkillDamage(CharacterBoardEntity source, Skill skill, CharacterBoardEntity target, List <DamagePackage> damage)
{
SkillReport skillReport = ExecuteSkillHelper(source, skill, target, damage);
return(skillReport);
}
/// <summary>
/// when a skill is executed
/// </summary>
/// <param name="skillreport"></param>
public virtual void ExecutedSkill(Skill skill, SkillReport skillreport)
{
}
private void processBoardEntity(BoardEntity boardEntity, Stats previewStats = null, SkillReport skillreport = null)
{
if (previewStats != null)
{
apDisplay.DisplayAp(boardEntity, previewStats);
}
else
{
apDisplay.DisplayAp(boardEntity);
}
UpdateProfilePic(boardEntity.ProfileImage);
foreach (GameObject g in texts)
{
Destroy(g);
}
foreach (GameObject g in passives)
{
Destroy(g);
}
AddTitle(boardEntity.Name);
EvaluateStats(boardEntity, previewStats, skillreport);
if (showPassives)
{
if (boardEntity is CharacterBoardEntity)
{
AddPassives(((CharacterBoardEntity)boardEntity).Passives);
}
}
}
private void EvaluateStats(BoardEntity boardEntity, Stats previewStats = null, SkillReport skillReport = null)
{
foreach (StatType type in displayOrder)
{
string text = boardEntity.Stats.StatToString(type);
if (previewStats != null)
{
Color?col = GetStatChangeColor(boardEntity, previewStats, type);
if (col != null)
{
text += ColorText((Color)col, " -> " + previewStats.StatValueString(type));
}
}
if (skillReport != null)
{
List <StatModifier> mods = new List <StatModifier>();
foreach (Buff buff in skillReport.Buffs)
{
mods.AddRange(buff.GetStatModifiers());
}
int value = skillReport.targetAfter.GetDefaultStat(type, mods).Value;
skillReport.targetAfter.modifiers = mods;
Color?col = GetStatChangeColor(boardEntity, skillReport.targetAfter, type);
if (col != null)
{
text += ColorText((Color)col, " -> " + skillReport.targetAfter.StatValueString(type));
}
skillReport.targetAfter.modifiers = new List <StatModifier>();
}
AddText(text, Stats.StatTypeToTooltip(type));
}
AddRangeText(boardEntity);
}
public override void ExecutedSkill(Skill skill, SkillReport skillreport)
{
base.ExecutedSkill(skill, skillreport);
Remove();
}
public void UpdateProfile(BoardEntity boardEntity, Stats previewStats = null, SkillReport skillReport = null)
{
if (currentBoardEntity != null)
{
currentBoardEntity.updateStatHandler -= RefreshProfile;
}
currentBoardEntity = boardEntity;
if (boardEntity == null)
{
gameObject.SetActive(false);
}
else
{
currentBoardEntity.updateStatHandler += RefreshProfile;
gameObject.SetActive(true);
processBoardEntity(boardEntity, previewStats, skillReport);
}
CharacterBoardEntity characterBoardEntity = Core.Instance.convert(boardEntity);
if (characterBoardEntity != null && characterBoardEntity.Ka != null)
{
kaProfile.SetActive(true);
kaProfile.GetComponent <Image>().sprite = characterBoardEntity.Ka.ProfilePic;
}
else
{
kaProfile.SetActive(false);
}
}
public SkillReport ExecuteSkillHelper(CharacterBoardEntity source, Skill skill, CharacterBoardEntity target, List <DamagePackage> damages)
{
SkillReport report = new SkillReport();
report.Buffs = skill.GetBuffs();
Stats sourceBefore = source.Stats.GetCopy();
Stats sourceAfter = source.Stats.GetCopy();
Stats targetBefore = target.Stats.GetCopy();
Stats targetAfter = target.Stats.GetCopy();
report.sourceBefore = sourceBefore;
report.targetBefore = targetBefore;
foreach (DamagePackage package in damages)
{
List <Passive> passives = target.Passives;
TakeDamageReturn usingTakeDamageReturn = new TakeDamageReturn()
{
type = TakeDamageReturnType.Normal
};
foreach (Passive passive in passives)
{
usingTakeDamageReturn = passive.TakeDamage(skill, package, usingTakeDamageReturn);
}
if (usingTakeDamageReturn.type == TakeDamageReturnType.Normal)
{
targetAfter = targetBefore.GetCopy();
int newTargetHealthDamage = HealthAfterDamage(report, targetAfter, package);
targetAfter.SetMutableStat(StatType.Health, newTargetHealthDamage);
}
else if (usingTakeDamageReturn.type == TakeDamageReturnType.NoDamage)
{
report.TextDisplays.Add(new TextDisplay()
{
target = target, text = "MISS"
});
}
else if (usingTakeDamageReturn.type == TakeDamageReturnType.Mitigate)
{
targetAfter = targetBefore.GetCopy();
int newDamage = (int)(package.Damage * (1 - usingTakeDamageReturn.value));
DamagePackage newDamagePackage = new DamagePackage(newDamage, package.Type, package.Piercing);
int newReflectTargetHealthDamage = HealthAfterDamage(report, targetAfter, newDamagePackage);
targetAfter.SetMutableStat(StatType.Health, newReflectTargetHealthDamage);
}
else if (usingTakeDamageReturn.type == TakeDamageReturnType.Reflect)
{
sourceAfter = sourceBefore.GetCopy();
targetAfter = targetBefore.GetCopy();
int newDamage = (int)(package.Damage * (1 - usingTakeDamageReturn.value));
int reflectDamage = (int)(package.Damage * (usingTakeDamageReturn.value));
DamagePackage newDamagePackage = new DamagePackage(newDamage, package.Type, package.Piercing);
DamagePackage reflectDamagePackage = new DamagePackage(reflectDamage, DamageType.physical);
int newReflectTargetHealthDamage = HealthAfterDamage(report, targetAfter, newDamagePackage);
int newReflectSourceHealthDamage = HealthAfterDamage(report, sourceAfter, reflectDamagePackage);
targetAfter.SetMutableStat(StatType.Health, newReflectTargetHealthDamage);
sourceAfter.SetMutableStat(StatType.Health, newReflectSourceHealthDamage);
}
sourceBefore = sourceAfter;
targetBefore = targetAfter;
}
report.targets.Add(new Tuple <Stats, Stats>(target.Stats.GetCopy(), targetAfter));
report.targetAfter = targetAfter;
report.targetBefore = target.Stats.GetCopy();
report.sourceAfter = sourceAfter;
report.sourceBefore = source.Stats.GetCopy();
return(report);
}
