public SkillTarget(SkillTargetContainer target_container, BattleSkill skill, ICreature target, int target_index)
{
this.target_container = target_container;
this.Skill = skill;
m_TargetIndex = target_index;
m_Creature = target as BattleCreature;
}
protected void OnSkill(BattleSkill skill)
{
if (skill.IsDefault == true)
{
return;
}
}
public BattleVariableControl battle_variable_control;//戦闘をプレイするにあたって、重要な変数の管理
/*
* //保存事項------------
* public int enchant1;
* public int enchant2;
*
* //------------
*/
public BattleRun1(Summary1 s1)
{
set1(s1);
// long time1 = m1.get_time();
battle_flow1 = new BattleFlow1(s1);
battle_bg = new BattleBg(s1);
battle_menu = new BattleMenu(s1);
battle_member_group = new BattleMemberGroup(s1);
battle_enemy_group = new BattleEnemyGroup(s1);
battle_member_group_attack_run = new BattleMemberGroupAttackRun(s1);
battle_enemy_group_attack_run = new BattleEnemyGroupAttackRun(s1);
battle_enemy_skill_run = new BattleEnemySkillRun(s1);
battle_member_group_status_control = new BattleMemberGroupStatusControl(s1);
battle_enchantment = new BattleEnchantment(s1);
battle_skill = new BattleSkill(s1);
battle_mana = new BattleMana(s1);
battle_variable_control = new BattleVariableControl(s1);
battle_message_window = new BattleMessageWindow(s1);
// m1.msbox((m1.get_time() - time1));
}
public bool DoAction(int index, bool is_skill, bool ignore_distance)
{
index = Math.Min(index, Skills.Count - 1);
BattleSkill skill = Skills[index];
return(DoAction(skill, is_skill, ignore_distance));
}
// 初始化战斗数据库
private void initializeBattleObjects()
{
BattleSkill.InitializeBattleSkills();
BattleStatus.InitializeBattleStatusList();
BattleJob.InitializeBattleJobList();
BattleActor.InitializeBattleActorList();
}
public static void InitializeBattleSkills()
{
battleSkillsList = new List <BattleSkill>();
// 0 攻击
BattleSkill attack = new BattleSkill(0, "攻击", new Texture2D(32, 32));
attack.Setup(SkillAim.onlyEnemy, 0, 0, null);
battleSkillsList.Add(attack);
}
//获取可用技能 这个函数必须在技能列表初始化之后调用否则会出现空指针
public List <BattleSkill> GetUsableSkills(int level)
{
List <BattleSkill> result = new List <BattleSkill>();
foreach (int skillId in jobSkillsList.Keys)
{
if (jobSkillsList[skillId] <= level)
{
result.Add(BattleSkill.GetBattleSkill(skillId));
}
}
return(result);
}
public Buff(BattleCreature creature, BattleSkill skill, SkillInfo.Action action_info, int value, float duration, ISkillBuff parent)
: base(duration)
{
Parent = parent;
m_Creature = creature;
Skill = skill;
this.ActionInfo = action_info;
switch (action_info.actionType)
{
case eActionType.dot_damage:
case eActionType.dot_damage_mana:
case eActionType.dot_heal:
case eActionType.dot_heal_mana:
this.Value = Mathf.RoundToInt(value / duration);
break;
default:
this.Value = value;
break;
}
this.StartTime = m_Creature.PlaybackTime;
eBuffColorType buff_color = eBuffColorType.None;
if (action_info.actionType == eActionType.shield && action_info.value > 0)
{
AffectValue = value;
AffectValueMax = value;
buff_color = eBuffColorType.Shield;
}
else
{
AffectValue = 1;
AffectValueMax = 1;
}
if (skill != null && skill.Creature != null && IsMainBuff == true && skill.Info.ShowIcon == true)
{
if (buff_color != eBuffColorType.Shield)
{
buff_color = creature.IsTeam == skill.Creature.IsTeam ? eBuffColorType.Buff : eBuffColorType.DeBuff;
}
BuffContainer.Alloc();
BuffContainer.Asset.Init(Skill.Info.IconID, buff_color, Duration > 0f);
BuffContainer.Asset.OnUpdate(0f, 1f);
}
}
public void Fire(BattleSkill skill, eActionType fire_action, int fire_value)
{
SubActions.ForEach(a => a.Fire(skill, fire_action, fire_value));
switch (actionType)
{
case eActionType.hp_drain:
if (fire_action == eActionType.damage || fire_action == eActionType.dot_damage)
{
int apply_value = -fire_value *GetValue(skill.Creature.GradePercent, skill.Level) / 10000;
skill.Creature.SetHeal(apply_value, fire_action == eActionType.dot_damage);
TextManager.Instance.PushHeal(skill.Creature, apply_value, fire_action == eActionType.dot_damage?eTextPushType.Dot : eTextPushType.Normal);
}
break;
}
}
public void Init(BattleManager _manager, Battler _source, List <Battler> _targets, BattleSkill _skill)
{
manager = _manager;
source = _source;
targets = _targets;
//skill = _skill;
effects = GetComponents <BattleEffect>().ToList();
initalized = true;
}
void OnUseLeaderSkill(BattleSkill skill)
{
m_UILeaderSkill.SetDisable();
m_SkillInfo.Init(skill.Info);
m_SkillInfo.Show();
}
private void LoadSkill(JSONNode N)
{
string id = N[BattleConstants.ID];
string name = N[BattleConstants.NAME];
Dictionary<string, string> cost = this.GetDictionary((JSONClass)N.AsObject[BattleConstants.COST]);
float damageRange = float.Parse(N[BattleConstants.DAMAGE_RANGE]);
Dictionary<string, string> damage = this.GetDictionary((JSONClass)N.AsObject[BattleConstants.DAMAGE]);
int damageCharacterMaximum = int.Parse(N[BattleConstants.DAMAGE_CHARACTER_MAXIMUM]);
float healRange = float.Parse(N[BattleConstants.HEAL_RANGE]);
Dictionary<string, string> heal = this.GetDictionary((JSONClass)N.AsObject[BattleConstants.HEAL]);
int healCharacterMaximum = int.Parse(N[BattleConstants.HEAL_CHARACTER_MAXIMUM]);
BattleSkill skill = new BattleSkill(id, name, cost
, damageRange, damage, damageCharacterMaximum
, healRange, heal, healCharacterMaximum);
skills[id] = skill;
}
public void SetLeader(pe_UseLeaderSkillType condition, OnUseLeaderSkillDelegate callback)
{
UseLeaderSkillType = condition;
OnUseLeaderSkill = callback;
LeaderSkill = new BattleSkill(Info.TeamSkill, this, Level);
}
public void OnUseEnemyLeaderSkill(BattleSkill skill)
{
m_SkillEnemyInfo.Init(skill.Info);
m_SkillEnemyInfo.Show();
}
public bool CanAction(BattleSkill skill = null)
{
return(BattleBase.Instance.IsBattleStart == true && BattleBase.Instance.IsBattleEnd == false && !IsDead && !IsWin && !IsStunned(skill) && !IsSlept(skill));
}
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 bool IsSlept(BattleSkill skill = null)
{
return(Buffs.Any(b => b.IsFinish == false && b.ActionInfo.actionType == eActionType.sleep && b.Skill != skill));
}
public bool IsStunned(BattleSkill skill = null)
{
return(Buffs.Any(b => b.IsFinish == false && (b.ActionInfo.actionType == eActionType.stun || b.ActionInfo.actionType == eActionType.hidden) && b.Skill != skill));
}
public bool DoAction(BattleSkill skill, bool is_skill, bool ignore_distance)
{
if (CanAction() == false)
{
return(false);
}
if (is_skill == true)
{
if (Stat.IsMPFull == false)
{
return(false);
}
}
SkillTargetContainer target = skill.GetTargets(ignore_distance, skill.Info.MoveTarget);
if (target == null)
{
return(false);
}
CancelAction(false);
float delay = skill.IsDefault == false ? BattleConfig.Instance.SkillDelay : 0f;
CharacterAction action = Character.DoAction(delay, skill.Info.ActionName, target, skill.IsDefault == false, (ConfigData.Instance.UseBattleEffect == true && skill.IsDefault == false)?BattleBase.LightingScaleValue:Scale - 1f, skill.Duration);
if (is_skill == true || skill.Info.Type == eSkillType.leader_active)
{
if (skill.Info.Type == eSkillType.leader_active)
{
BattleBase.Instance.AddLightingTargets(IsTeam, target.targets, this);
}
else
{
BattleBase.Instance.PlayParticle(Character.transform, BattleBase.Instance.m_SkillCasting);
float slow_time = action.FirstActionTime;
if (slow_time > 0f)
{
BattleBase.Instance.AddLighting(this, slow_time + delay, action.Data.Effect.ScaleTime == 0f ? 0f : action.Data.Effect.ScaleTime + delay, action.Data.Effect.JumpScale);
BattleBase.Instance.AddLightingTargets(IsTeam, target.targets, this);
PlayTargetEffect(IsTeam, target.targets, skill.Info.MoveTarget == eMoveTarget.Character || skill.Info.Actions[0].check_distance == false);
}
else
{
Debug.LogErrorFormat("SetLightingTime Error : {0}, {1}, {2}", Info.Name, skill.Info.Name, slow_time);
}
}
}
if (skill.Info.Type != eSkillType.leader_active)
{
AttackNextTime += action.Length;
}
m_UseSkill = is_skill;
if (Stat.IsMPFull == true && is_skill == true)
{
Stat.MP = 0;
Battle.Instance.CheckManaFill(this);
}
else
{
AddMP(eMPFillType.Action, 1f);
}
if (skill.IsDefault == false && skill.IsLeaderActive == false)
{
SkillName.Show(skill.Info.Name, ConfigData.Instance.UseBattleEffect ? (1f + BattleBase.LightingScaleValue * 0.3f):Scale);
}
return(true);
}
public void AddSkill(BattleSkill skill)
{
this.skills.Add(skill);
}
public BattleCreature(MapCreatureInfo map_creature_info, CharacterContainer character_container, float attack_next_time, GameObject hpBarPrefab, GameObject skillPrefab)
{
MapStageDifficulty stage_info = Network.BattleStageInfo;
IsTeam = false;
Info = map_creature_info.CreatureInfo;
SkinName = map_creature_info.SkinName;
MapCreature = map_creature_info;
Grade = map_creature_info.Grade;
Level = map_creature_info.Level;
GradePercent = map_creature_info.GradePercent;
Enchant = map_creature_info.Enchant;
if (map_creature_info.UseLeaderSkillType != pe_UseLeaderSkillType.Manual && Info.TeamSkill != null)
{
SetLeader(map_creature_info.UseLeaderSkillType, BattleStage.Instance.OnUseEnemyLeaderSkill);
}
switch (map_creature_info.CreatureType)
{
case eMapCreatureType.Elite:
Scale = 1.2f;
break;
case eMapCreatureType.Boss:
Scale = 1.4f;
if (stage_info.MapInfo.MapType == "boss")
{
Level = Boss.CalculateLevel(Level, stage_info);
Grade = Boss.CalculateGrade(Level);
Enchant = Boss.CalculateEnchant(Level);
GradePercent = CreatureInfoManager.Instance.Grades[Grade].enchants[Enchant].stat_percent * GameConfig.Get <float>("boss_grade_percent");
}
Battle.Instance.m_BossHP.Init(this);
break;
case eMapCreatureType.WorldBoss:
Scale = 2.5f;
BattleWorldboss.Instance.m_BossHP.Init(this, true);
IgnoreTween = true;
TextOffset = -20f;
// IsShowText = false;
break;
}
Stat = new CreatureStat(map_creature_info.GetStat(Level, GradePercent, Enchant));
AutoSkillIndex = map_creature_info.AutoSkillIndex;
InitCommon(character_container, attack_next_time, hpBarPrefab, skillPrefab);
if (map_creature_info.CreatureType == eMapCreatureType.WorldBoss)
{
HPBar.gameObject.SetActive(false);
}
foreach (SkillInfo skill_info in Info.Skills)
{
if (skill_info.Type != eSkillType.active)
{
continue;
}
Skills.Add(new BattleSkill(skill_info, this, map_creature_info.Level));
}
if (map_creature_info.PassiveInfos.Count > 0)
{
foreach (var passive_info in map_creature_info.PassiveInfos)
{
bool first = true;
var battle_skill = new BattleSkill(passive_info.SkillInfo, this, map_creature_info.Level);
foreach (var action in passive_info.SkillInfo.Actions)
{
ISkillBuff buff = SkillTarget.DoBuff(action, this, this, battle_skill, 0, null);
if (first == true && string.IsNullOrEmpty(passive_info.SkillInfo.ActionName) == false)
{
first = false;
var comp = AssetManager.GetCharacterPrefab("PassiveEtc_" + passive_info.SkillInfo.ActionName).GetComponent <CharacterActionBuffComponent>();
// comp.data.InitEffect();
CharacterActionBuff new_action = comp.data.CreateAction(comp, PlaybackTime, Character, 999f, false, 1f);
buff.Action = new_action;
}
}
}
var buff_worldboss = Buffs.Find(b => b.ActionInfo.actionType == eActionType.worldboss);
if (buff_worldboss != null)
{
Stat.HP = Stat.MaxHP = buff_worldboss.ActionInfo.value;
}
else
{
Stat.HP = Stat.MaxHP = Stat.Stat.MaxHP;
}
Stat.MP = Stat.Stat.ManaInit;
}
}
