static public ISkillBuff DoBuff(SkillInfo.Action buff_action, BattleCreature creature, BattleCreature target_creature, BattleSkill skill, int target_index, ISkillBuff parent)
{
switch (buff_action.actionType)
{
case eActionType.stun:
case eActionType.hidden:
case eActionType.sleep:
{
if (target_creature.InvokeImmune(eImmuneType.cc, skill.Creature.Info.AttackType, skill.Level) == true)
{
return(null);
}
int value = skill.GetValueWithTargetIndex(buff_action, target_index, -(target_creature.Level - skill.Level) * GameConfig.Get <int>("stun_level_decrease"));
if (BattleBase.Instance.Rand.NextRange(1, 10000) > value)
{
TextManager.Instance.PushMessage(target_creature, Localization.Get("Miss"), eBuffColorType.Immune, eTextPushType.Normal);
return(null);
}
float duration = skill.GetDuration(buff_action, target_index);
Buff buff = new Buff(target_creature, skill, buff_action, value, duration, parent);
if (duration == 0f)
{
buff.DoAction();
}
else if (duration > 0f || duration == -1f)
{
target_creature.AddBuff(buff, skill.Info.CanStack);
TextManager.Instance.PushMessage(target_creature, Localization.Get(buff_action.actionType.ToString()), eBuffColorType.Stun, eTextPushType.Normal);
}
else
{
Debug.LogErrorFormat("duration is invalid : {0}", buff_action.SkillInfo.Name);
}
return(buff);
}
case eActionType.ignore_defense_damage:
case eActionType.ignore_defense_damaged:
case eActionType.worldboss:
case eActionType.shield:
case eActionType.immune:
case eActionType.provoke:
case eActionType.buff:
case eActionType.buff_percent:
{
int value = skill.GetValueWithTargetIndex(buff_action, target_index, 0);
float duration = skill.GetDuration(buff_action, target_index);
Buff buff = new Buff(target_creature, skill, buff_action, value, duration, parent);
if (duration == 0f)
{
buff.DoAction();
}
else if (duration > 0f || duration == -1f)
{
target_creature.AddBuff(buff, skill.Info.CanStack);
}
else
{
Debug.LogErrorFormat("duration is invalid : {0}", buff_action.SkillInfo.Name);
}
target_creature.SetWait();
if (buff_action.statType == eStatType.AttackSpeed && duration > 0f)
{
buff.Duration *= (1f + value * 0.0001f);
}
return(buff);
}
case eActionType.debuff:
case eActionType.debuff_percent:
{
eImmuneType immune_type = eImmuneType.debuff;
switch (buff_action.actionType)
{
default:
if (target_creature.InvokeImmune(immune_type, skill.Creature.Info.AttackType, skill.Level) == true)
{
return(null);
}
break;
}
int value = -skill.GetValueWithTargetIndex(buff_action, target_index, 0);
float duration = skill.GetDuration(buff_action, target_index);
Buff buff = new Buff(target_creature, skill, buff_action, value, duration, parent);
if (duration == 0f)
{
buff.DoAction();
}
else if (duration > 0f || duration == -1f)
{
target_creature.AddBuff(buff, skill.Info.CanStack);
}
else
{
Debug.LogErrorFormat("duration is invalid : {0}", buff_action.SkillInfo.Name);
}
target_creature.SetWait();
if (buff_action.statType == eStatType.AttackSpeed && duration > 0f)
{
buff.Duration *= (1f - value * 0.0001f);
}
return(buff);
}
case eActionType.dot_damage:
{
int value = -skill.GetValueWithTargetIndex(buff_action, target_index, creature.GetDamageValue());
value = Mathf.RoundToInt(value * (1f + (creature.GetValue(eStatType.IncreaseDamagePercent) - creature.GetValue(eStatType.DecreaseDamagePercent)) * 0.0001f));
float duration = skill.GetDuration(buff_action, target_index);
Buff buff = new Buff(target_creature, skill, buff_action, value, duration, parent);
if (duration == 0f)
{
buff.DoAction();
}
else if (duration > 0f || duration == -1f)
{
target_creature.AddBuff(buff, skill.Info.CanStack);
}
else
{
Debug.LogErrorFormat("duration is invalid : {0}", buff_action.SkillInfo.Name);
}
target_creature.SetWait();
return(buff);
}
case eActionType.dot_damage_mana:
{
int value = -skill.GetValueWithTargetIndex(buff_action, target_index, 0);
float decrease = (10000 - (target_creature.Level - skill.Level) * GameConfig.Get <int>("mana_level_decrease")) * 0.0001f;
value = Mathf.RoundToInt(value * (1f + (creature.GetValue(eStatType.IncreaseDamagePercent) - creature.GetValue(eStatType.DecreaseDamagePercent)) * 0.0001f + decrease));
float duration = skill.GetDuration(buff_action, target_index);
Buff buff = new Buff(target_creature, skill, buff_action, value, duration, parent);
if (duration == 0f)
{
buff.DoAction();
}
else if (duration > 0f || duration == -1f)
{
target_creature.AddBuff(buff, skill.Info.CanStack);
}
else
{
Debug.LogErrorFormat("duration is invalid : {0}", buff_action.SkillInfo.Name);
}
target_creature.SetWait();
return(buff);
}
case eActionType.dot_heal:
{
int value = skill.GetValueWithTargetIndex(buff_action, target_index, creature.GetDamageValue());
value = Mathf.RoundToInt(value * (1f + creature.GetValue(eStatType.IncreaseDamagePercent) * 0.0001f));
float duration = skill.GetDuration(buff_action, target_index);
Buff buff = new Buff(target_creature, skill, buff_action, value, duration, parent);
if (duration == 0f)
{
buff.DoAction();
}
else if (duration > 0f || duration == -1f)
{
target_creature.AddBuff(buff, skill.Info.CanStack);
}
else
{
Debug.LogErrorFormat("duration is invalid : {0}", buff_action.SkillInfo.Name);
}
target_creature.SetWait();
return(buff);
}
case eActionType.dot_heal_mana:
{
int value = skill.GetValueWithTargetIndex(buff_action, target_index, 0);
float decrease = (10000 - (target_creature.Level - skill.Level) * GameConfig.Get <int>("mana_level_decrease")) * 0.0001f;
value = Mathf.RoundToInt(value * (1f + creature.GetValue(eStatType.IncreaseDamagePercent) * 0.0001f) * decrease);
float duration = skill.GetDuration(buff_action, target_index);
Buff buff = new Buff(target_creature, skill, buff_action, value, duration, parent);
if (duration == 0f)
{
buff.DoAction();
}
else if (duration > 0f || duration == -1f)
{
target_creature.AddBuff(buff, skill.Info.CanStack);
}
else
{
Debug.LogErrorFormat("duration is invalid : {0}", buff_action.SkillInfo.Name);
}
target_creature.SetWait();
return(buff);
}
}
return(null);
}
// public List<ISkillTarget> GetTargets(bool is_team, bool ignore_distance)
// {
// return GetTargets(null, is_team, ignore_distance);
// }
SkillTargetContainer GetTargets(BattleCreature self, bool is_team, bool ignore_distance, eMoveTarget move_target)
{
SkillTargetContainer skill_target = new SkillTargetContainer();
skill_target.targets = new List <ISkillTarget>();
try
{
switch (Info.TargetType)
{
case eTargetType.self:
if (self == null)
{
Debug.LogError("self is null");
}
skill_target.targets.Add(new SkillTarget(skill_target, this, self, 0));
break;
case eTargetType.position:
case eTargetType.position_reverse:
case eTargetType.all:
case eTargetType.all_reverse:
case eTargetType.all_center:
case eTargetType.position_next:
{
List <ICreature> target_list = GetTargetList(is_team, Info.EnemyType);
switch (Info.TargetType)
{
case eTargetType.position_reverse:
case eTargetType.all_reverse:
target_list = target_list.Reverse <ICreature>().ToList();
break;
case eTargetType.position_next:
skill_target.target_creatures = target_list;
break;
}
var main_action = Info.Actions[0];
int selected_target_index = -1, first_target_index = -1;
// provoke
if (main_action.IsMultiTarget == false)
{
for (int target_index = 0; target_index < target_list.Count; ++target_index)
{
var creature = target_list[target_index] as BattleCreature;
Buff provoke = creature.GetProvoke();
if (provoke != null)
{
int value = provoke.Value - (Level - provoke.Skill.Level) * GameConfig.Get <int>("stun_level_decrease");
if (BattleBase.Instance.Rand.NextRange(1, 10000) > value)
{
continue;
}
TextManager.Instance.PushMessage(creature, Localization.Get("Aggro"), eBuffColorType.Aggro, eTextPushType.Normal);
selected_target_index = target_index;
break;
}
}
}
if (selected_target_index == -1)
{
for (int target_index = 0; target_index < target_list.Count; ++target_index)
{
BattleCreature target = target_list[target_index] as BattleCreature;
if (target == null || target.CanTarget() == false)
{
continue;
}
if (first_target_index == -1)
{
first_target_index = target_index;
}
if (Info.TargetType != eTargetType.all_center && Info.TargetType != eTargetType.all && Info.TargetType != eTargetType.all_reverse && main_action.CanDistance(self.Character.GetAction(Info.ActionName).Effect.GetFirstActionTime(), target) == false)
{
continue;
}
selected_target_index = target_index;
break;
}
if (selected_target_index == -1)
{
if (ignore_distance == true)
{
selected_target_index = first_target_index;
}
if (selected_target_index == -1)
{
return(null);
}
}
}
skill_target.targets.Add(new SkillTarget(skill_target, this, target_list[selected_target_index], 0));
var value_percent = Info.Actions[0].action_value;
for (int value_index = 1, target_index = 1; value_index < value_percent.value_percent.Length; value_index++, target_index++)
{
if (value_percent.value_percent[value_index] > 0)
{
if (main_action.loop_target == true || selected_target_index + target_index < target_list.Count)
{
var target = target_list[(selected_target_index + target_index) % target_list.Count] as BattleCreature;
if (target == null || target.CanTarget() == false)
{
if (main_action.skip_dead)
{
--value_index;
continue;
}
skill_target.targets.Add(null);
}
else
{
skill_target.targets.Add(new SkillTarget(skill_target, this, target, value_index));
}
}
else
{
skill_target.targets.Add(null);
}
skill_target.targets.Add(null);
}
}
// if (Info.TargetType != eTargetType.all && main_action.check_distance == true && !targets.Any(t => t != null && t.Character.Creature.IsDead == false && (t.Character.transform.localPosition == Vector3.zero || ignore_distance == true)))
// return null;
}
break;
case eTargetType.hp_min:
{
List <ICreature> target_list = GetTargetList(is_team, Info.EnemyType);
BattleCreature selected_target = null;
foreach (BattleCreature creature in target_list)
{
if (creature != null && creature.CanTarget() == true && (selected_target == null || creature.Stat.HP < selected_target.Stat.HP))
{
selected_target = creature;
}
}
skill_target.targets.Add(new SkillTarget(skill_target, this, selected_target, 0));
}
break;
case eTargetType.hp_min_percent:
{
List <ICreature> target_list = GetTargetList(is_team, Info.EnemyType);
BattleCreature selected_target = null;
foreach (BattleCreature creature in target_list)
{
if (creature != null && creature.CanTarget() == true && (selected_target == null || creature.Stat.HPPercent < selected_target.Stat.HPPercent))
{
selected_target = creature;
}
}
skill_target.targets.Add(new SkillTarget(skill_target, this, selected_target, 0));
}
break;
case eTargetType.attack_max:
{
List <ICreature> target_list = GetTargetList(is_team, Info.EnemyType);
BattleCreature selected_target = null;
foreach (BattleCreature creature in target_list)
{
if (creature != null && creature.CanTarget() == true && (selected_target == null || creature.GetDamageValue() > selected_target.GetDamageValue()))
{
selected_target = creature;
}
}
skill_target.targets.Add(new SkillTarget(skill_target, this, selected_target, 0));
}
break;
}
}
catch (System.Exception ex)
{
throw new System.Exception(string.Format("[{0}] {1}", Info.ID, ex.Message), ex);
}
if (skill_target.main_target == null && Info.TargetType != eTargetType.position_next)
{
if (Info.TargetType == eTargetType.all_center)
{
skill_target.main_target = GetCenter(!is_team);
}
else
{
if (move_target == eMoveTarget.Character)
{
skill_target.main_target = skill_target.targets[0].Character.transform;
}
else
{
skill_target.main_target = skill_target.targets[0].Character.transform.parent;
}
}
}
return(skill_target);
}
