public void Load()
{
if (!loaded)
loaded = true;
else
return;
WarriorXlsData = new WarriorConfig("Hero", "ID");
WarriorXlsData.Load();
SkillXlsData = new SkillConfig("Skill", 10001, 19999);
SkillXlsData.Load();
ExpSetXlsData = new XlsData("ExpSet", "Lv");
ExpSetXlsData.Load();
NatureXlsData = new NatureConfig("Nature", "ID");
NatureXlsData.Load();
AvatarXlsData = new XlsData("Avatar", "ID");
AvatarXlsData.Load();
GradeSetupXlsData = new GradeSetupConfig("GradeSetup", "ID");
GradeSetupXlsData.Load();
BuffXlsData = new XlsData("Buff", "ID");
BuffXlsData.Load();
LevelXlsData = new LevelConfig("Level", 1001, 9999);
LevelXlsData.Load();
LevelNpcXlsData = new LevelNpcConfig("LevelSet", 1001, 9999);
LevelNpcXlsData.Load();
LevelBgXlsData = new LevelBgConfig("LevelScene", 1001, 9999);
LevelBgXlsData.Load();
}
internal void Update(SkillConfig skillConfig)
{
Type = BattleTargetManager.GetRegionType(skillConfig.Target[2]);
range = skillConfig.Range;
CheckColor(skillConfig.Target[1]);
}
public SectorRangeAttackSkill(Charactor attackOne, SkillConfig skillConfig)
{
this.attackOne = attackOne;
this.skillConfig = skillConfig;
}
// Use this for initialization
void Awake()
{
_skillConfig = GameConfig.Get <SkillConfig>();
}
public void TryPlaySkill(int id, Ilife user, Ilife lockedTarget = null)
{
SkillConfig config = ConfigManager.Instance.GetSkillConfig(id);
if (null == config)
{
Debuger.Log("can't load skill id: " + id);
return;
}
//check cd
SkillCd cd = null;
if (m_CdStore.TryGetValue(id, out cd))
{
if (cd.cd > 0)
{
// can't play skill
return;
}
}
if (m_BeginCdStore.TryGetValue(id, out cd))
{
if (cd.cd > 0)
{
// can't play skill
return;
}
}
if (m_PlayingSkill.ContainsKey(id))
{
//can't play
return;
}
//per handle
HandleTarget target = HandleTarget.GetHandleTarget(user);
if (LimitMethods.HandleLimitExec(target, config.PerLimitId, null))
{
FuncMethods.HandleFuncExec(target, config.PerFuncId, null);
m_LockedTargetList.Add(id, lockedTarget);
if (config.BeginCd <= 0)
{
TriggerExecSkill(user, config);
}
else
{
if (m_BeginCdStore.ContainsKey(config.Id))
{
m_BeginCdStore.Add(config.Id, new SkillCd(config.InitCd, config, user));
}
else
{
m_BeginCdStore[config.Id] = new SkillCd(config.InitCd, config, user);
}
}
}
}
public SkillCd(int cd, SkillConfig config, Ilife user)
{
this.cd = cd;
this.config = config;
this.user = user;
}
protected sealed override void PrepareProtoSkill(SkillConfig config)
{
config.Category = GetCategory <SkillCategoryCombat>();
this.PrepareProtoWeaponsSkillRanged(config);
}
public WalkerPathSkill(Charactor attackone, SkillConfig skillconfig)
{
this.attackone = attackone;
this.skillconfig = skillconfig;
}
protected abstract void PrepareProtoSkill(SkillConfig config);
public SkillCd(int cd,SkillConfig config,Ilife user)
{
this.cd = cd;
this.config = config;
this.user = user;
}
private void TriggerExecSkill(Ilife user,SkillConfig config)
{
bool isLockedTarget = m_LockedTargetList.ContainsKey(config.Id) && m_LockedTargetList[config.Id] != null;
//add to playing list
m_PlayingSkill.Add(config.Id, config);
// play animation
FuncContext context = FuncContext.Create();
if (!isLockedTarget)
{
context.Put(FuncContext.ContextKey.TargetId, config.TargeteId);
}
else
{
context.Put(FuncContext.ContextKey.Target, m_LockedTargetList[config.Id]);
}
context.Put(FuncContext.ContextKey.User, user);
context.Put(FuncContext.ContextKey.LimitId, config.LimitId);
context.Put(FuncContext.ContextKey.FunctionId, config.FuncId);
ActionParam param = new ActionParam();
param.Id = config.Id;
param.Object = context;
ActionManager.Instance.PlayAction(config.ActionId, param);
if (m_CdStore.ContainsKey(config.Id))
{
m_CdStore.Add(config.Id, new SkillCd(config.InitCd));
}
else
{
m_CdStore[config.Id] = new SkillCd(config.InitCd);
}
}
public void Init()
{
_skills = GameConfig.Get <SkillConfig>();
GameModel.HandleGet <UnitModel>(OnUnitChange);
GameMessage.Listen <SkillControlMessage>(OnSkillControlMessage);
}
private void TrySkillAttack()
{
if (this.skillCD > 0)
{
this.skillCD -= Time.deltaTime;
return;
}
if (skills.Count == 0)
{
return;
}
if (this.charModel.currentState == CharModel.State.ATTACK)
{
return;
}
SkillItem skillItem = null;
if (this.skillPolicy == 1)
{
skillItem = skills[currentSkillIndex] as SkillItem;
currentSkillIndex++;
if (currentSkillIndex >= skills.Count)
{
currentSkillIndex = 0;
}
}
else if (this.skillPolicy == 2)
{
int odds = Random.Range(0, this.sumOfSkillOdds);
for (int i = 0; i < this.skills.Count; i++)
{
skillItem = (SkillItem)skills[i];
if (skillItem.odds >= odds)
{
break;
}
odds -= skillItem.odds;
}
}
if (skillItem == null)
{
this.skillCD = 1;
return;
}
SkillConfig skillConfig = Config.GetInstance().GetSkillCOnfig(skillItem.skillId);
this.skillCD = skillItem.cd + skillConfig.singTime;
if (skillConfig == null)
{
return;
}
skillConfig.b = skillItem.b;
SkillManager.PlaySkill(this, skillConfig);
}
public void Init(Role from, Role to, SkillConfig config)
{
this.from = from;
this.to = to;
this.config = config;
}
public void Init(Characer c, SkillConfig config)
{
caster = c;
this.config = config;
}
public void SetSkillConfigs(SkillConfig[] configs)
{
if (configs == null)
{
this.skillConfigsDic = new Dictionary<int, SkillConfig>();
}
else
{
if (f_am_cacheE == null)
{
f_am_cacheE = n => n.skillId;
}
if (f_am_cacheF == null)
{
f_am_cacheF = n => n;
}
this.skillConfigsDic = configs.ToDictionary<SkillConfig, int, SkillConfig>(f_am_cacheE, f_am_cacheF);
}
}
public Skill(int id)
{
SkillConfig = ConfigData.SkillDict[id];
}
public SkillRunner(SkillsEnum skill)
{
SceneLoader instance = SceneLoader.Instance;
Skill = skill;
m_skillState = SkillStateFactory.GetOrCreateSkillState(skill);
m_skillConfig = PersistentSingleton <Economies> .Instance.Skills.Find((SkillConfig s) => s.Name == Skill.ToString());
Cost.Value = PersistentSingleton <GameSettings> .Instance.SkillPurchaseCosts[(int)Skill];
LevelReq.Value = m_skillConfig.LevelReq;
LifetimeUsed = m_skillState.LifetimeUsed;
Locked = (from lvl in Singleton <HeroTeamRunner> .Instance.GetOrCreateHeroRunner(0).LifetimeLevel
select lvl < m_skillConfig.LevelReq).TakeUntilDestroy(instance).ToReactiveProperty();
Amount = m_skillState.Amount.CombineLatest(Locked, (int amount, bool locked) => (!locked) ? amount : 0).TakeUntilDestroy(instance).ToReactiveProperty();
UnlockTriggered = (from pair in Locked.Pairwise()
where pair.Previous && !pair.Current
select pair into _
select Skill).TakeUntilDestroy(instance).ToReadOnlyReactiveProperty();
m_skillState.CooldownTimeStamp.Subscribe(delegate
{
if (!Locked.Value)
{
UpdateCooldown();
}
}).AddTo(instance);
CanAffordPurchase = (from gems in PlayerData.Instance.Gems
select gems >= Cost.Value).TakeUntilDestroy(instance).ToReactiveProperty();
MaxDuration = (from duration in Singleton <CumulativeBonusRunner> .Instance.BonusMult[(int)(8 + Skill)]
select SkillsEnumHelper.IsDuration(Skill) ? duration.ToInt() : 0 into duration
select m_skillConfig.DurationSeconds + duration).TakeUntilDestroy(instance).ToReadOnlyReactiveProperty();
TickerService.MasterTicks.Subscribe(delegate(long ticks)
{
if (m_skillState.ElapsedTime.Value < 1728000000000L)
{
m_skillState.ElapsedTime.Value += ticks;
UpdateCooldown();
}
}).AddTo(instance);
SecondsLeft = m_skillState.ElapsedTime.CombineLatest(MaxDuration, (long elapsed, int dur) => Mathf.Max(0, dur - (int)(elapsed / 10000000))).DistinctUntilChanged().TakeUntilDestroy(instance)
.ToReactiveProperty();
Active = (from secs in SecondsLeft
select secs > 0).TakeUntilDestroy(instance).ToReactiveProperty();
(from act in Active.Pairwise()
where !act.Current && act.Previous
select act).Subscribe(delegate
{
m_skillState.CooldownTimeStamp.Value = ServerTimeService.NowTicks();
}).AddTo(instance);
(from act in Active.Pairwise()
where act.Current && act.Previous
select act).Subscribe(delegate
{
if (PersistentSingleton <GameAnalytics> .Instance != null)
{
PersistentSingleton <GameAnalytics> .Instance.SkillUsed.Value = Skill;
}
}).AddTo(instance);
Cooldown = (from secs in CooldownSeconds
select secs > 0).CombineLatest(Active, (bool cooldown, bool active) => cooldown && !active).TakeUntilDestroy(instance).ToReactiveProperty();
UniRx.IObservable <bool> observable = Active.CombineLatest(Cooldown, (bool active, bool cooldown) => !active && !cooldown).CombineLatest(Locked, (bool noTimer, bool locked) => noTimer && !locked);
Available = observable.TakeUntilDestroy(instance).ToReactiveProperty();
OutOfStock = observable.CombineLatest(Amount, (bool poss, int amount) => poss && amount <= 0).TakeUntilDestroy(instance).ToReactiveProperty();
LocalizedName = new ReactiveProperty <string>(PersistentSingleton <LocalizationService> .Instance.Text("Skill.Name." + Skill.ToString()));
LocalizedDesc = new ReactiveProperty <string>(PersistentSingleton <LocalizationService> .Instance.Text("Skill.Name.Desc." + Skill.ToString()));
(from order in Singleton <PrestigeRunner> .Instance.PrestigeTriggered
select order == PrestigeOrder.PrestigeStart).Subscribe(delegate
{
m_skillState.CooldownTimeStamp.Value = 0L;
m_skillState.ElapsedTime.Value = 1728000000000L;
}).AddTo(instance);
(from amount in Amount.Pairwise()
where amount.Current > amount.Previous
select amount).Subscribe(delegate
{
ResetCooldown();
}).AddTo(instance);
UpdateCooldown();
AdAvailable = Singleton <AdRunner> .Instance.AdReady.TakeUntilDestroy(instance).ToReadOnlyReactiveProperty();
(from ad in Singleton <AdRunner> .Instance.AdPlacementFinished
where ad.ToString() == Skill.ToString()
select ad).Subscribe(delegate
{
SkillAdFinished();
}).AddTo(instance);
(from ad in Singleton <AdRunner> .Instance.AdPlacementSkipped
where ad.ToString() == Skill.ToString()
select ad).Subscribe(delegate
{
SkillAdSkipped();
}).AddTo(instance);
(from ad in Singleton <AdRunner> .Instance.AdPlacementFailed
where ad.ToString() == Skill.ToString()
select ad).Subscribe(delegate
{
SkillAdSkipped();
}).AddTo(instance);
}
