public static SkillData ParseSkillData(IDictionary info, SkillData fill)
{
if (fill == null)
{
fill = new SkillData();
}
fill.CoolDown = int.Parse(info["cooldown"].ToString());
fill.DeathStatus = info.Contains("deathStatus") && bool.Parse(info["deathStatus"].ToString());
fill.EffectStatus = info.Contains("effectStatus") && bool.Parse(info["effectStatus"].ToString());
fill.SkillId = int.Parse(info["id"].ToString());
fill.Index = CombatantIndex.Parse(info["index"] as IDictionary);
fill.Level = int.Parse(info["level"].ToString());
ArrayList required = info.Contains("required") ? info["required"] as ArrayList : null;
if (required != null)
{
var enumerator = required.GetEnumerator();
while (enumerator.MoveNext())
{
var idx = enumerator.Current;
fill.Required.Add(int.Parse(idx.ToString()));
}
}
return(fill);
}
public static CombatantData ParseCombatantData(IDictionary info, CombatantData fill)
{
if (fill == null)
{
fill = new CombatantData();
}
fill.IsPlayer = info.Contains("isUser") && info["isUser"] != null && bool.Parse(info["isUser"].ToString());
fill.IsPlayerMirror = info.Contains("isUserMirror") && info["isUserMirror"] != null && bool.Parse(info["isUserMirror"].ToString());
fill.PlayerId = info.Contains("uid") && info["uid"] != null?long.Parse(info["uid"].ToString()) : 0;
fill.IsEnemy = info.Contains("isEnemy") && info["isEnemy"] != null && bool.Parse(info["isEnemy"].ToString());
fill.EnemyId = info.Contains("enemyId") && info["enemyId"] != null?int.Parse(info["enemyId"].ToString()) : 0;
fill.IsPlayerTroop = info.Contains("isPlayerTroop") && info["isPlayerTroop"] != null && bool.Parse(info["isPlayerTroop"].ToString());
fill.IsPlayerTroopMirror = info.Contains("isPlayerTroopMirror") && info["isPlayerTroopMirror"] != null && bool.Parse(info["isPlayerTroopMirror"].ToString());
fill.IsEnemyTroop = info.Contains("isEnemyTroop") && info["isEnemyTroop"] != null && bool.Parse(info["isEnemyTroop"].ToString());
fill.TroopId = info.Contains("troopId") && info["troopId"] != null?int.Parse(info["troopId"].ToString()) : 0;
fill.Threaten = info.Contains("threaten") && bool.Parse(info["threaten"].ToString());
fill.Level = info.Contains("level") && info["level"] != null?int.Parse(info["level"].ToString()) : 0;
fill.Name = info.Contains("name") ? info["name"].ToString() : string.Empty;
fill.Model = info["model"].ToString();
fill.Portrait = info["portrait"].ToString();
fill.Position = info["pos"].ToString();
fill.TplId = int.Parse(info["tplId"].ToString());
fill.CharacterId = int.Parse(info["characterId"].ToString());
fill.Index = CombatantIndex.Parse(info["index"] as IDictionary);
ArrayList equipments = info.Contains("equipments") ? info["equipments"] as ArrayList : null;
if (equipments != null)
{
fill.Equipments.Clear();
var enumerator = equipments.GetEnumerator();
while (enumerator.MoveNext())
{
IDictionary equip = enumerator.Current as IDictionary;
string name = equip["name"].ToString();
string assetName = equip["assetName"].ToString();
fill.Equipments[name] = assetName;
}
}
if (string.IsNullOrEmpty(fill.Name))
{
fill.Name = (string)GlobalUtils.CallStaticHotfixEx("Hotfix_LT.Data.CharacterTemplateManager", "Instance", "GetHeroName", fill.CharacterId);
}
return(fill);
}
public static ImpactData ParseImpactData(IDictionary info, ImpactData fill)
{
if (fill == null)
{
fill = new ImpactData();
}
fill.Fadeout = bool.Parse(info["fadeout"].ToString());
fill.ImpactId = int.Parse(info["id"].ToString());
fill.ImpactIndex = int.Parse(info["impact_index"].ToString());
fill.Sender = CombatantIndex.Parse(info["sender"] as IDictionary);
fill.SkillId = int.Parse(info["skill_id"].ToString());
fill.TurnLeft = int.Parse(info["turn_left"].ToString());
return(fill);
}
public override bool Parse(Hashtable info)
{
if (!base.Parse(info))
{
return(false);
}
RemoveIndex = CombatantIndex.Parse(info["removeIndex"] as Hashtable);
if (RemoveIndex == null)
{
EB.Debug.LogWarning("RemoveCombatantEffectEvent.Parse: removeIndex is empty {0}", EB.JSON.Stringify(info));
return(false);
}
return(true);
}
public override bool Parse(Hashtable info)
{
m_timing = ParseTiming(info);
if (m_timing == eCombatEventTiming.INVALID)
{
EB.Debug.LogWarning("CombatEffectEvent.Parse: invalid timing = {0}", m_timing);
return(false);
}
int target_team_index = EB.Dot.Integer("target.team", info, -1);
if (target_team_index < 0)
{
EB.Debug.LogWarning("CombatEffectEvent.Parse: target.team is empty");
return(false);
}
int target_index_on_team = EB.Dot.Integer("target.combatant", info, -1);
if (target_index_on_team < 0)
{
EB.Debug.LogWarning("CombatEffectEvent.Parse: target.combatant is empty");
return(false);
}
m_target = new CombatantIndex();
m_target.TeamIndex = target_team_index;
m_target.IndexOnTeam = target_index_on_team;
int parent_effect_index = EB.Dot.Integer("parent", info, -1);
if (parent_effect_index >= 0)
{
m_parent = parent_effect_index;
}
int sender_team_index = EB.Dot.Integer("sender.team", info, -1);
int sender_index_on_team = EB.Dot.Integer("sender.combatant", info, -1);
if (sender_team_index >= 0 && sender_index_on_team >= 0)
{
m_sender = new CombatantIndex();
m_sender.TeamIndex = sender_team_index;
m_sender.IndexOnTeam = sender_index_on_team;
}
return(true);
}
protected static CombatantIndex ParseTarget(Hashtable info)
{
CombatantIndex target = new CombatantIndex();
target.TeamIndex = EB.Dot.Integer("target.team", info, -1);
if (target.TeamIndex < 0)
{
return(null);
}
target.IndexOnTeam = EB.Dot.Integer("target.combatant", info, -1);
if (target.IndexOnTeam < 0)
{
return(null);
}
return(target);
}
protected static CombatantIndex ParseTrigger(Hashtable info)
{
CombatantIndex trigger = new CombatantIndex();
trigger.TeamIndex = EB.Dot.Integer("trigger.team", info, -1);
if (trigger.TeamIndex < 0)
{
return(null);
}
trigger.IndexOnTeam = EB.Dot.Integer("trigger.combatant", info, -1);
if (trigger.IndexOnTeam < 0)
{
return(null);
}
return(trigger);
}
protected static CombatantIndex ParseSender(Hashtable info)
{
CombatantIndex sender = new CombatantIndex();
sender.TeamIndex = EB.Dot.Integer("sender.team", info, -1);
if (sender.TeamIndex < 0)
{
return(null);
}
sender.IndexOnTeam = EB.Dot.Integer("sender.combatant", info, -1);
if (sender.IndexOnTeam < 0)
{
return(null);
}
return(sender);
}
protected static HashSet <CombatantIndex> ParseTargets(Hashtable info)
{
ArrayList targets_info = EB.Dot.Array("targets", info, null);
if (targets_info == null)
{
return(null);
}
if (targets_info.Count == 0)
{
return(null);
}
HashSet <CombatantIndex> targets = new HashSet <CombatantIndex>();
var enumerator = targets_info.GetEnumerator();
while (enumerator.MoveNext())
{
Hashtable target_info = enumerator.Current as Hashtable;
CombatantIndex target = new CombatantIndex();
target.TeamIndex = EB.Dot.Integer("team", target_info, -1);
if (target.TeamIndex < 0)
{
return(null);
}
target.IndexOnTeam = EB.Dot.Integer("combatant", target_info, -1);
if (target.IndexOnTeam < 0)
{
return(null);
}
targets.Add(target);
}
return(targets);
}
public override bool Parse(Hashtable info)
{
m_owner = CombatantIndex.Parse(info["sender"] as Hashtable);
if (m_owner == null)
{
EB.Debug.LogWarning("CombatImpactEvent.Parse: owner is empty {0}", EB.JSON.Stringify(info));
return(false);
}
ImpactData = CombatUtil.ParseImpactData(info["impact_data"] as Hashtable, null);
List <CombatEvent> children = CombatUtil.ParseEffects(info);
if (children != null)
{
m_children = children;
}
int len = m_children.Count;
for (int i = 0; i < len; i++)
{
CombatEffectEvent effect = m_children[i] as CombatEffectEvent;
if (effect.Timing == eCombatEventTiming.AUTO)
{
effect.Timing = eCombatEventTiming.ON_START;
}
if (effect.Sender == null)
{
effect.Sender = new CombatantIndex(m_owner.TeamIndex, m_owner.IndexOnTeam);
}
}
return(true);
}
public ReactionEffectEvent FindComboTriggerReaction(CombatSkillEvent combo_skill)
{
bool res = (bool)GlobalUtils.CallStaticHotfixEx("Hotfix_LT.Data.SkillTemplateManager", "Instance", "IsComBo", combo_skill.SkillId);
if (!res)
{
return(null);
}
CombatantIndex trigger = combo_skill.Trigger;
if (trigger == null)
{
return(null);
}
int len = m_children.Count;
for (int i = 0; i < len; i++)
{
CombatEffectEvent effect = m_children[i] as CombatEffectEvent;
if (effect.EffectType != eCombatEffectType.REACTION)
{
continue;
}
if (!effect.Target.Equals(trigger))
{
continue;
}
return(effect as ReactionEffectEvent);
}
return(null);
}
public SkillData FindSkillData(CombatantIndex idx)
{
return(m_dataList.Where(m => m.Index.Equals(idx)).FirstOrDefault());
}
public override bool Parse(Hashtable info)
{
if (!base.Parse(info))
{
return(false);
}
IsCombo = m_timing != eCombatEventTiming.AUTO;
ComboDelay = EB.Dot.Single("delay", info, 0.0f);
// skip flag
m_skip = EB.Dot.Bool("skip", info, false);
m_sender = ParseSender(info);
if (m_sender == null)
{
EB.Debug.LogWarning("CombatSkillEvent.Parse: sender is empty {0}", EB.JSON.Stringify(info));
return(false);
}
// may be empty
m_trigger = ParseTrigger(info);
m_target = ParseTarget(info);
m_skillId = ParseSkillId(info);
if (m_skillId < 0)
{
EB.Debug.LogWarning("CombatSkillEvent.Parse: skill is empty {0}", EB.JSON.Stringify(info));
return(false);
}
m_targets = ParseTargets(info);
if (m_targets == null)
{
if (m_skip && m_target == null)
{
m_targets = new HashSet <CombatantIndex>();
}
else
{
EB.Debug.LogWarning("CombatSkillEvent.Parse: targets is empty {0}", EB.JSON.Stringify(info));
return(false);
}
}
m_comboIndex = EB.Dot.Integer("combo_index", info, m_comboIndex);
m_children = CombatUtil.ParseEffects(info);
if (m_children == null)
{
if (m_skip && m_target == null)
{
m_children = new List <CombatEvent>();
}
else
{
EB.Debug.LogWarning("CombatSkillEvent.Parse: effects is empty {0}", EB.JSON.Stringify(info));
return(false);
}
}
int len = m_children.Count;
for (int i = 0; i < len; i++)
{
CombatEffectEvent effect = m_children[i] as CombatEffectEvent;
if (effect.Timing == eCombatEventTiming.AUTO)
{
effect.Timing = eCombatEventTiming.RUNTIME;
}
if (effect.Sender == null)
{
effect.Sender = new CombatantIndex(m_sender.TeamIndex, m_sender.IndexOnTeam);
}
}
return(true);
}
