Beispiel #1
0
    protected void SetCareer(int index)
    {
        if (!DataReader <JobIndex> .Contains(this.TypeID))
        {
            return;
        }
        JobIndex jobIndex = DataReader <JobIndex> .Get(this.TypeID);

        int num = (index >= 0) ? ((index <= jobIndex.AdvancedJobId.get_Count() - 1) ? index : (jobIndex.AdvancedJobId.get_Count() - 1)) : 0;

        this.CurCareer = jobIndex.AdvancedJobId.get_Item(num);
        for (int i = 0; i < this.careerUnitList.get_Count(); i++)
        {
            this.careerUnitList.get_Item(i).SetClickState(i == num);
        }
        if (!DataReader <AdvancedJob> .Contains(this.CurCareer))
        {
            return;
        }
        AdvancedJob advancedJob = DataReader <AdvancedJob> .Get(this.CurCareer);

        this.SetPreview(advancedJob.advanced1Model);
        this.SetSuccessSign();
        this.SetAttrText(advancedJob.attrsDelta);
        this.SetSkill(advancedJob.passiveSkill, advancedJob.description);
    }
Beispiel #2
0
    public override DatabaseEntry Copy()
    {
        List <JobReq> reqs = new List <JobReq>();

        foreach (JobReq req in JobRequirements)
        {
            reqs.Add(req.Copy());
        }

        AdvancedJob temp = new AdvancedJob(key, reqs);

        temp.Name        = Name;
        temp.Descript    = Descript;
        temp.AbilitNames = AbilitNames;

        //finish copying stats and stuff
        temp.baseStats  = (StatsContainer)baseStats.Copy();
        temp.statGrowth = (StatsContainer)statGrowth.Copy();

        foreach (Discipline d in avalibleDisciples)
        {
            temp.avalibleDisciples.Add((Discipline)d.Copy());
        }

        foreach (ItemType t in allowedItemTypes)
        {
            temp.allowedItemTypes.Add(t);
        }

        temp.descript = descript;

        return(temp);
    }
Beispiel #3
0
    public bool IsAllRankUpFinish()
    {
        if (!DataReader <JobIndex> .Contains(this.CurType))
        {
            return(false);
        }
        JobIndex jobIndex = DataReader <JobIndex> .Get(this.CurType);

        if (jobIndex.AdvancedJobId.get_Count() == 0)
        {
            return(false);
        }
        if (this.CurCareer != jobIndex.AdvancedJobId.get_Item(jobIndex.AdvancedJobId.get_Count() - 1))
        {
            return(false);
        }
        if (!DataReader <AdvancedJob> .Contains(this.CurCareer))
        {
            return(false);
        }
        AdvancedJob advancedJob = DataReader <AdvancedJob> .Get(this.CurCareer);

        if (advancedJob.stageId.get_Count() == 0)
        {
            return(false);
        }
        if (this.CurStage != advancedJob.stageId.get_Item(advancedJob.stageId.get_Count() - 1))
        {
            return(false);
        }
        if (!DataReader <StageInfo> .Contains(this.CurStage))
        {
            return(false);
        }
        StageInfo stageInfo = DataReader <StageInfo> .Get(this.CurStage);

        if (stageInfo.taskid.get_Count() == 0)
        {
            return(false);
        }
        for (int i = 0; i < stageInfo.taskid.get_Count(); i++)
        {
            if (!this.IsTaskFinished(stageInfo.taskid.get_Item(i)))
            {
                return(false);
            }
        }
        return(true);
    }
Beispiel #4
0
    protected bool IsAllRankUpFinish()
    {
        if (!DataReader <JobIndex> .Contains(this.TypeID))
        {
            return(false);
        }
        JobIndex jobIndex = DataReader <JobIndex> .Get(this.TypeID);

        if (jobIndex.AdvancedJobId.get_Count() == 0)
        {
            return(false);
        }
        if (this.DefaultCareer != jobIndex.AdvancedJobId.get_Item(jobIndex.AdvancedJobId.get_Count() - 1))
        {
            return(false);
        }
        if (!DataReader <AdvancedJob> .Contains(this.DefaultCareer))
        {
            return(false);
        }
        AdvancedJob advancedJob = DataReader <AdvancedJob> .Get(this.DefaultCareer);

        if (advancedJob.stageId.get_Count() == 0)
        {
            return(false);
        }
        if (this.DefaultStage != advancedJob.stageId.get_Item(advancedJob.stageId.get_Count() - 1))
        {
            return(false);
        }
        if (!DataReader <StageInfo> .Contains(this.DefaultStage))
        {
            return(false);
        }
        StageInfo stageInfo = DataReader <StageInfo> .Get(this.DefaultStage);

        if (stageInfo.taskid.get_Count() == 0)
        {
            return(false);
        }
        for (int i = 0; i < stageInfo.taskid.get_Count(); i++)
        {
            if (!RankUpChangeManager.Instance.IsTaskFinished(stageInfo.taskid.get_Item(i)))
            {
                return(false);
            }
        }
        return(true);
    }
Beispiel #5
0
    protected void InitStage(Action callback = null)
    {
        if (!DataReader <AdvancedJob> .Contains(this.CurCareer))
        {
            return;
        }
        AdvancedJob careerData = DataReader <AdvancedJob> .Get(this.CurCareer);

        this.stageUnitList.Clear();
        this.RankUpChangeUIStageUnitSR.OnHasBuilt = delegate
        {
            if (callback != null)
            {
                callback.Invoke();
            }
        };
        this.stageListPool.Create(careerData.stageId.get_Count(), delegate(int index)
        {
            if (index < careerData.stageId.get_Count() && index < this.stageListPool.Items.get_Count())
            {
                RankUpChangeUIStageUnit component = this.stageListPool.Items.get_Item(index).GetComponent <RankUpChangeUIStageUnit>();
                if (!DataReader <StageInfo> .Contains(careerData.stageId.get_Item(index)))
                {
                    return;
                }
                StageInfo stageInfo = DataReader <StageInfo> .Get(careerData.stageId.get_Item(index));
                RankUpChangeStageState stageState = this.GetStageState(careerData.stageId.get_Item(index));
                XDict <int, bool> xDict           = new XDict <int, bool>();
                int num = (stageInfo.taskid.get_Count() >= stageInfo.description.get_Count()) ? stageInfo.description.get_Count() : stageInfo.taskid.get_Count();
                for (int i = 0; i < num; i++)
                {
                    if (xDict.ContainsKey(stageInfo.description.get_Item(i)))
                    {
                        xDict[stageInfo.description.get_Item(i)] = this.GetIsTaskFinished(stageState, stageInfo.taskid.get_Item(i));
                    }
                    else
                    {
                        xDict.Add(stageInfo.description.get_Item(i), this.GetIsTaskFinished(stageState, stageInfo.taskid.get_Item(i)));
                    }
                }
                component.SetData(stageInfo.title, xDict, stageState);
                this.stageUnitList.Add(component);
            }
        });
    }
Beispiel #6
0
    public void TryShowCareerFinishUI()
    {
        if (!this.IsWaitForShowCareerFinish)
        {
            return;
        }
        this.IsWaitForShowCareerFinish = false;
        if (!DataReader <AdvancedJob> .Contains(this.WaitForShowPreCareer))
        {
            return;
        }
        AdvancedJob advancedJob = DataReader <AdvancedJob> .Get(this.WaitForShowPreCareer);

        RankUpChangePreviewUI rankUpChangePreviewUI = UIManagerControl.Instance.OpenUI("RankUpChangePreviewUI", UINodesManager.MiddleUIRoot, false, UIType.NonPush) as RankUpChangePreviewUI;

        if (rankUpChangePreviewUI)
        {
            rankUpChangePreviewUI.SetData(advancedJob.advanced1Model);
        }
    }
Beispiel #7
0
 protected void InitCareerUnit(List <int> careerDataList, Action callback = null)
 {
     this.careerUnitList.Clear();
     this.careerListPool.Create(careerDataList.get_Count(), delegate(int index)
     {
         if (index < careerDataList.get_Count() && index < this.careerListPool.Items.get_Count())
         {
             RankUpChangeUICareerUnit component = this.careerListPool.Items.get_Item(index).GetComponent <RankUpChangeUICareerUnit>();
             if (!DataReader <AdvancedJob> .Contains(careerDataList.get_Item(index)))
             {
                 return;
             }
             AdvancedJob advancedJob = DataReader <AdvancedJob> .Get(careerDataList.get_Item(index));
             component.SetData(index, advancedJob.name, new Action <int>(this.OnClickCareerBtn));
             this.careerUnitList.Add(component);
         }
         if (index == careerDataList.get_Count() - 1 && callback != null)
         {
             callback.Invoke();
         }
     });
 }
Beispiel #8
0
    protected void OnRankUpNty(short state, AdvanceFinishedNty down = null)
    {
        if (state != 0)
        {
            StateManager.Instance.StateShow(state, 0);
            return;
        }
        if (down == null)
        {
            return;
        }
        if (DataReader <AdvancedJob> .Contains(down.nextAdvancedCfgId))
        {
            AdvancedJob advancedJob = DataReader <AdvancedJob> .Get(down.nextAdvancedCfgId);

            if (advancedJob.stageId.get_Count() > 0)
            {
                this.CurCareer = down.nextAdvancedCfgId;
                this.CurStage  = DataReader <AdvancedJob> .Get(this.CurCareer).stageId.get_Item(0);

                this.CurStageFinishedTask.Clear();
            }
            else
            {
                Debug.LogError("Cfg Error: careerData.stageId == 0");
            }
        }
        else
        {
            if (DataReader <AdvancedJob> .Contains(down.curAdvancedCfgId))
            {
                this.CurCareer = down.curAdvancedCfgId;
            }
            if (DataReader <AdvancedJob> .Contains(this.CurCareer))
            {
                AdvancedJob advancedJob2 = DataReader <AdvancedJob> .Get(this.CurCareer);

                if (advancedJob2.stageId.get_Count() > 0)
                {
                    if (DataReader <StageInfo> .Contains(advancedJob2.stageId.get_Item(advancedJob2.stageId.get_Count() - 1)))
                    {
                        this.CurStage = advancedJob2.stageId.get_Item(advancedJob2.stageId.get_Count() - 1);
                    }
                    if (DataReader <StageInfo> .Contains(this.CurStage))
                    {
                        this.CurStageFinishedTask.Clear();
                        this.CurStageFinishedTask.AddRange(DataReader <StageInfo> .Get(this.CurStage).taskid);
                    }
                    else
                    {
                        Debug.LogError("Cfg Error: !DataReader<StageInfo>.Contains(CurStage)");
                    }
                }
                else
                {
                    Debug.LogError("Cfg Error: careerData.stageId == 0");
                }
            }
            else
            {
                Debug.LogError("Cfg Error: !DataReader<AdvancedJob>.Get(CurCareer)");
            }
        }
        this.TryUpdateCareerFinish(down.curAdvancedCfgId, down.nextAdvancedCfgId);
    }