public override void Enter(SkillController obj)
{
base.Enter(obj);
if (obj.Type == ESkillType.TARGET)
{
if (enemy != null)
{
if ((ESkillOffense)obj.Ability == ESkillOffense.SINGLE)
{
obj.transform.position = enemy.transform.position;
SkillState skill = obj.getCurrentState();
if (skill.hasDamage || skill.effectType != EBulletEffect.NONE)
{
if (obj.skillAnimation.GetComponent <SkillDamage>() == null)
{
SkillDamage dmg = obj.skillAnimation.gameObject.AddComponent <SkillDamage>();
dmg.damage(enemy);
}
}
}
else
{
obj.transform.position = destPosition;
}
}
else
{
obj.transform.position = destPosition;
}
}
}
private void DamagePopup(Transform target, SkillDamage damage, int uniqId)
{
if (damage.isResist == false)
{
switch (damage.valueTarget)
{
case SkillValueTarget.SLEEP:
SleepPopup(uniqId);
break;
default:
string color = SkillsDicionary.SkillColor(damage.valueTarget);
string damageText = $"<color={color}>{damage.damage}";
GameObject text =
Instantiate(Resources.Load("Prefabs/Text/DamageText", typeof(GameObject)) as GameObject);
var pos = target.GetComponent<Transform>().localPosition;
pos = PopupPos(pos);
text.GetComponent<Transform>().localPosition = pos;
var tMesh = text.GetComponent<TextMeshPro>();
tMesh.rectTransform.localScale = new Vector3(1.4f, 1.4f);
tMesh.rectTransform.pivot = new Vector2(0, 0);
tMesh.color = new Color(tMesh.color.r, tMesh.color.g, tMesh.color.b, 0);
tMesh.text = damageText;
TextPopUpFadeInOut(tMesh, text);
break;
}
}
else
{
ResistPopup(target);
}
}
private static void test1()
{
var sc1 = new SkillDamage(new Skill("Attack (Acc+1)", 2, 4, 1f, 0.5f));
var sc2 = new SkillDamage("Attack", 3, 4, 1f, 0.5f);
var combo = new SkillDamage(null, sc1, sc2);
combo.GenerateGraph();
}
public override AttackLog TakeDamage(SkillDamage damage)
{
if (damage.AttackType == DamageType.Physical)
{
double armorNegationPercentage = this.ArmorNegation / 100.0;
damage.Damage -= (int)(damage.Damage * armorNegationPercentage);
}
return(base.TakeDamage(damage));
}
public virtual AttackLog TakeDamage(SkillDamage damage)
{
this.CurrentHitPoints -= damage.Damage;
if (this.CurrentHitPoints <= 0)
{
this.IsAlive = false;
}
return(new AttackLog(true, String.Format("{0} for {1} damage.", this.Name, damage.Damage)));
}
/// <summary>
/// Deals the current character's damage to the selected target.
/// In this case, the AI controls the attack - whether normal attack or spellcast.
/// </summary>
/// <param name="target">The targeted character.</param>
/// <returns>AttackLog which holds information if the attack passed, as well as the damage dealt and type of attack.</returns>
public virtual AttackLog DealDamage(IAttackable target)
{
if (target.IsAlive)
{
SkillDamage attackPower = this.AvailableSkills["basic attack"].DealDamage(this.AttackDamage);
var result = target.TakeDamage(attackPower);
result.AttackDetails = String.Format("{0} attacks {1}", this.Name, result.AttackDetails);
return(result);
}
else
{
return(AttackLog.AttackFailed);
}
}
/// <summary>
/// ダメージと敵ステータスを比較してダメージ計算し反映する
/// </summary>
/// <returns></returns>
private static int CalcDamage(SkillDamage damage, BattlerSerializable toBattler)
{
var _damage = damage.damage;
switch (damage.valueTarget)
{
//通常ダメージ計算
// TODO
case SkillValueTarget.HP:
_damage = _damage - toBattler.parameter.def;
//ダメージは25%以下に減らない
if (_damage < damage.damage * 0.25)
{
_damage = (int)(damage.damage * 0.25);
}
//ダメージのブレ
_damage += Random.Range(_damage, (int)(_damage * 0.1));
SkillDamage(_damage, toBattler);
return(_damage);
//毒計算
case SkillValueTarget.TARGET_POISON:
damage.damage = damage.damage - (int)(damage.damage * (toBattler.resistRate.poison / 100));
StatusDamage(damage, toBattler);
return(damage.damage);
//睡眠判定
case SkillValueTarget.SLEEP:
if (IsStateJudgment(damage.damage, toBattler))
{
damage.damage = 1;
SetState(SkillValueTarget.SLEEP, toBattler, 20);
}
else
{
damage.isResist = true;
damage.damage = 0;
}
return(damage.damage);
//再生計算
case SkillValueTarget.TARGET_REGENERATION_HP:
StatusDamage(damage, toBattler);
return(damage.damage);
}
return(damage.damage);
}
private static void AddSkills(IEnumerable <SkillDps> skills, CharacterStatistics characterStats)
{
foreach (var skill in skills.OrderByDescending(i => i.DPSBoss))
{
var skillDamage = new SkillDamage
{
Name = skill.Name,
SkillId = skill.SkillId,
DamageAll = skill.PowerAll + skill.CondiAll,
DamageBoss = skill.PowerBoss + skill.CondiBoss,
DpsAll = Math.Round(skill.DPSAll),
DpsBoss = Math.Round(skill.DPSBoss)
};
characterStats.Skills.Add(skillDamage);
}
}
/// <summary>
/// 単体の対象に向けてスキルを使う
/// </summary>
/// <param name="skillId"></param>
/// <param name="fromBattler"></param>
/// <param name="toBattler"></param>
/// <returns></returns>
public static List <SkillDamage> SkillToBattler(string skillId, BattlerSerializable fromBattler,
BattlerSerializable toBattler)
{
List <SkillDamage> skillDamages = new List <SkillDamage>();
var skill = SkillsDicionary.GetSkillById(skillId);
foreach (var(x, i) in skill.effect.value.Select((x, i) => (x, i)))
{
var skillDamage = new SkillDamage();
var damage = SkillLogic.GetTotalDamageByTarget(x, fromBattler);
skillDamage.damage = damage;
skillDamage.valueTarget = x.valueTarget;
skillDamage.turn = x.turn;
skillDamages.Add(skillDamage);
skillDamage.damage = CalcDamage(skillDamage, toBattler);
}
return(skillDamages);
}
public static string SkillDamagePopUpText(SkillDamage damage)
{
switch (damage.valueTarget)
{
case SkillValueTarget.HP:
case SkillValueTarget.MP:
case SkillValueTarget.POISON:
return(damage.damage.ToString());
case SkillValueTarget.SLEEP:
if (damage.damage == 0)
{
return("ていこう");
}
return("すいみん");
}
return("");
}
private static void StatusDamage(SkillDamage damage, BattlerSerializable battler)
{
var status = battler.status.Find(x => x.type == damage.valueTarget);
if (status == null)
{
BattlerSerializableStatus battlerSerializableStatus = new BattlerSerializableStatus();
battlerSerializableStatus.type = damage.valueTarget;
battlerSerializableStatus.value = damage.damage;
if (StatusDictionary.IsTurnStatus(damage.valueTarget))
{
battlerSerializableStatus.turn = damage.turn;
}
battler.status.Add(battlerSerializableStatus);
BattlePresenter.GetInstance().BattlerSpriteModel.GetData(battler.uniqId).Status.OnNext(Unit.Default);
}
else
{
status.value += damage.damage;
}
}
private static void CreateData(_Worksheet worksheet, SkillDamage data)
{
var floats = new float[data.Hits.Count * 2, 2];
var ints = new int[data.Hits.Count * 2, 1];
var meanValue = data.MeanValue;
float previousProba = 0;
uint i = 0;
foreach (var item in data.Hits)
{
floats[i, 0] = previousProba;
floats[i, 1] = meanValue;
ints[i, 0] = item.Damage;
++i;
previousProba = item.CumulProba * 10;
floats[i, 0] = previousProba;
floats[i, 1] = meanValue;
ints[i, 0] = item.Damage;
++i;
}
worksheet.Range["A2", "B" + i + 1].set_Value(null, floats);
worksheet.Range["C2", "C" + i + 1].set_Value(null, ints);
}
/// <summary>
/// Builds the current data as an Excel graph in an image
/// </summary>
/// <param name="data">Data to be displayed</param>
/// <param name="pngFile">Path to the PNG file</param>
/// <param name="excelFile">Path to the Excel workbook</param>
public static void ToGraph(SkillDamage data, string pngFile, string excelFile = null)
{
var application = new Application();
var workbook = application.Workbooks.Add();
var worksheet = workbook.Worksheets[1] as Worksheet;
application.DisplayAlerts = false;
if (worksheet == null)
{
return;
}
worksheet.Cells[1, 2] = Data2;
worksheet.Cells[1, 3] = ValueTitle;
CreateData(worksheet, data);
BuildChart(worksheet, data.Name, (uint)data.Hits.Count * 2 + 1, pngFile);
if (excelFile != null)
{
workbook.SaveAs(excelFile, XlFileFormat.xlWorkbookDefault, null, null, null, null,
XlSaveAsAccessMode.xlExclusive);
}
workbook.Close(true);
application.Quit();
}
