Exemplo n.º 1
0
        public void Test_MergeTalentTrees_TrueResult_WithOrderBy()
        {
            TalentTree        objTalentTree = new TalentTree();
            TalentTree        objTalentTree2 = new TalentTree();
            List <TalentTree> lstTalentTreeList = new List <TalentTree>();
            List <TalentTree> lstTalentTreeList2 = new List <TalentTree>();
            bool blnTalentTreeIsInList, blnTalentTreeIsInList2, blnAlterFirst;

            objTalentTree.GetTalentTree(1);

            lstTalentTreeList.Add(objTalentTree);

            objTalentTree2.GetTalentTree(2);
            lstTalentTreeList2.Add(objTalentTree2);

            List <TalentTree> lstMergedTalentTrees = new List <TalentTree>();

            lstMergedTalentTrees   = TalentTree.MergeTalentTrees(lstTalentTreeList, lstTalentTreeList2, "TalentTreeName");
            blnTalentTreeIsInList  = TalentTree.IsTalentTreeInList(objTalentTree, lstMergedTalentTrees);
            blnTalentTreeIsInList2 = TalentTree.IsTalentTreeInList(objTalentTree2, lstMergedTalentTrees);
            if (lstMergedTalentTrees.IndexOf(objTalentTree2) == 0)
            {
                blnAlterFirst = true;
            }
            else
            {
                blnAlterFirst = false;
            }

            Assert.IsTrue(blnTalentTreeIsInList && blnTalentTreeIsInList2 && lstMergedTalentTrees.Count == 2 && blnAlterFirst);
        }
Exemplo n.º 2
0
        public void Test_IsTalentTreeInListList_FalseResult()
        {
            TalentTree        objTalentTree     = new TalentTree();
            TalentTree        objTalentTree2    = new TalentTree();
            List <TalentTree> lstTalentTreeList = new List <TalentTree>();
            List <TalentTree> lstNeedList       = new List <TalentTree>();
            bool blnTalentTreeIsInList;

            objTalentTree.GetTalentTree(1);
            objTalentTree2.GetTalentTree(2);

            for (int i = 0; i < 3; i++)
            {
                lstTalentTreeList.Add(objTalentTree);
            }

            for (int i = 0; i < 1; i++)
            {
                lstNeedList.Add(objTalentTree2);
            }

            blnTalentTreeIsInList = TalentTree.IsTalentTreeInList(lstNeedList, lstTalentTreeList);

            Assert.IsFalse(blnTalentTreeIsInList);
        }
Exemplo n.º 3
0
        public void Test_GetTalentTree_ByID_BadResult()
        {
            int        intTalentTreeID = 0;
            TalentTree objTalentTree   = new TalentTree();

            objTalentTree.GetTalentTree(intTalentTreeID);

            Assert.IsNull(objTalentTree.TalentTreeName);
        }
Exemplo n.º 4
0
        public void Test_GetTalentTree_ByID_GoodResult()
        {
            int        intTalentTreeID = 1;
            TalentTree objTalentTree   = new TalentTree();

            objTalentTree.GetTalentTree(intTalentTreeID);

            Assert.AreEqual(intTalentTreeID, objTalentTree.TalentTreeID);
        }
Exemplo n.º 5
0
        public void Test_GetTalentTree_ByName_BadResult()
        {
            string     strTalentTreeName = "blah blah";
            TalentTree objTalentTree     = new TalentTree();

            objTalentTree.GetTalentTree(strTalentTreeName);

            Assert.IsNull(objTalentTree.TalentTreeName);
        }
Exemplo n.º 6
0
        public void Test_GetTalentTree_ByName_GoodResult()
        {
            string     strTalentTreeName = "Alter";
            TalentTree objTalentTree     = new TalentTree();

            objTalentTree.GetTalentTree(strTalentTreeName);

            Assert.AreEqual(strTalentTreeName, objTalentTree.TalentTreeName);
        }
Exemplo n.º 7
0
        public void Test_IsTalentTreeInList_TrueResult()
        {
            TalentTree objTalentTree = new TalentTree();

            List <TalentTree> lstTalentTreeList = new List <TalentTree>();
            bool blnTalentTreeIsInList;

            objTalentTree.GetTalentTree(1);

            for (int i = 0; i < 3; i++)
            {
                lstTalentTreeList.Add(objTalentTree);
            }

            blnTalentTreeIsInList = TalentTree.IsTalentTreeInList(objTalentTree, lstTalentTreeList);

            Assert.IsTrue(blnTalentTreeIsInList);
        }
Exemplo n.º 8
0
        public void Test_MergeTalentTress_TrueResult_WithoutOrderBy()
        {
            TalentTree        objTalentTree = new TalentTree();
            TalentTree        objTalentTree2 = new TalentTree();
            List <TalentTree> lstTalentTreeList = new List <TalentTree>();
            List <TalentTree> lstTalentTreeList2 = new List <TalentTree>();
            bool blnTalentTreeIsInList, blnTalentTreeIsInList2;

            objTalentTree.GetTalentTree(1);

            lstTalentTreeList.Add(objTalentTree);

            objTalentTree2.GetTalentTree(2);
            lstTalentTreeList2.Add(objTalentTree2);

            List <TalentTree> lstMergedTalentTrees = new List <TalentTree>();

            lstMergedTalentTrees   = TalentTree.MergeTalentTrees(lstTalentTreeList, lstTalentTreeList2, "");
            blnTalentTreeIsInList  = TalentTree.IsTalentTreeInList(objTalentTree, lstMergedTalentTrees);
            blnTalentTreeIsInList2 = TalentTree.IsTalentTreeInList(objTalentTree2, lstMergedTalentTrees);

            Assert.IsTrue(blnTalentTreeIsInList && blnTalentTreeIsInList2 && lstMergedTalentTrees.Count == 2);
        }
        private void SetTalentTreeTalentFields()
        {
            string strPreTag = tvTalentTreeTalents.SelectedNode.Tag.ToString().Substring(0, 2);
            string strTag    = tvTalentTreeTalents.SelectedNode.Tag.ToString().Substring(2);
            int    intTag;

            int.TryParse(strTag, out intTag);

            if (strPreTag == "TT")
            {
                //Talent Tree
                TalentTree objTalentTree = new TalentTree();
                objTalentTree.GetTalentTree(intTag);
                ckbForceTalentTree.Checked = objTalentTree.ForceTalent;
                this.gbTalent.Visible      = false;

                this.btnSelectTalent.Enabled = false;
            }
            else
            {
                //Talent
                Talent objTalent = new Talent();
                objTalent.GetTalent(intTag);

                this.lblTalentName.Text        = objTalent.TalentName;
                this.txtTalentSpecial.Text     = objTalent.TalentSpecial;
                this.lblTurnSegment.Text       = objTalent.objTurnSegment.TurnSegmentName;
                this.txtTalentDescription.Text = objTalent.TalentDescription;

                lstFeatsReq.Items.Clear();
                lstTalentsReq.Items.Clear();
                lstSkillsReq.Items.Clear();
                lstAbilitiesReq.Items.Clear();
                lstForcePowerReq.Items.Clear();
                txtBaseAttackReq.Text = "";

                TalentTree objTT = new TalentTree();
                objTT.GetTalentTree(objTalent.TalentTreeID);
                ckbForceTalentTree.Checked = objTT.ForceTalent;

                this.gbTalent.Visible = true;
                bool blnShowPrereqs = false;
                //Fill out the prereqs
                if (objTalent.objTalentPrerequsiteFeat.Count > 0)
                {
                    foreach (Feat objFeat in objTalent.objTalentPrerequsiteFeat)
                    {
                        lstFeatsReq.Items.Add(objFeat.FeatName);
                    }
                    this.lblFeatPrereq.Visible = true;
                    this.lstFeatsReq.Visible   = true;
                    blnShowPrereqs             = true;
                }
                else
                {
                    this.lblFeatPrereq.Visible = false;
                    this.lstFeatsReq.Visible   = false;
                }

                if (objTalent.objPrerequsiteTalent.Count > 0)
                {
                    foreach (Talent objPrereqT in objTalent.objPrerequsiteTalent)
                    {
                        lstTalentsReq.Items.Add(objPrereqT.TalentName);
                    }
                    this.lblTalentRequired.Visible = true;
                    this.lstTalentsReq.Visible     = true;
                    blnShowPrereqs = true;
                }
                else
                {
                    this.lblTalentRequired.Visible = false;
                    this.lstTalentsReq.Visible     = false;
                }

                if (objTalent.objTalentPrerequsiteSkill.Count > 0)
                {
                    foreach (Skill objSkill in objTalent.objTalentPrerequsiteSkill)
                    {
                        lstSkillsReq.Items.Add(objSkill.SkillName);
                    }
                    this.lblSkillReq.Visible  = true;
                    this.lstSkillsReq.Visible = true;
                    blnShowPrereqs            = true;
                }
                else
                {
                    this.lblSkillReq.Visible  = false;
                    this.lstSkillsReq.Visible = false;
                }

                if (objTalent.objTalentPrerequisteAbility.Count > 0)
                {
                    foreach (TalentPrerequisteAbility objTPA in objTalent.objTalentPrerequisteAbility)
                    {
                        lstAbilitiesReq.Items.Add(objTPA.objAbility.AbilityName + " - " + objTPA.AbilityMinimum);
                    }
                    this.lblAbilitiesReq.Visible = true;
                    this.lstAbilitiesReq.Visible = true;
                    blnShowPrereqs = true;
                }
                else
                {
                    this.lblAbilitiesReq.Visible = false;
                    this.lstAbilitiesReq.Visible = false;
                }

                if (objTalent.objTalentPrerequisteForcePower.Count > 0)
                {
                    foreach (ForcePower objFP in objTalent.objTalentPrerequisteForcePower)
                    {
                        this.lstForcePowerReq.Items.Add(objFP.ForcePowerName);
                    }
                    this.lblForcePowerReq.Visible = true;
                    this.lstForcePowerReq.Visible = true;
                    blnShowPrereqs = true;
                }
                else
                {
                    this.lblForcePowerReq.Visible = false;
                    this.lstForcePowerReq.Visible = false;
                }

                if (objTalent.objBaseAttackPrerequisite.BaseAttackID != 0)
                {
                    this.txtBaseAttackReq.Text       = objTalent.objBaseAttackPrerequisite.BaseAttackNumber.ToString();
                    this.lblBaseAttackPrereq.Visible = true;
                    this.txtBaseAttackReq.Visible    = true;
                    blnShowPrereqs = true;
                }
                else
                {
                    this.lblBaseAttackPrereq.Visible = false;
                    this.txtBaseAttackReq.Visible    = false;
                }

                System.Drawing.Size szTDesc = new System.Drawing.Size(316, 268);
                System.Drawing.Size szTSpec = new System.Drawing.Size(316, 160);
                int intWidth = 504;

                this.gpTalentPrereqs.Visible = blnShowPrereqs;
                if (!blnShowPrereqs)
                {
                    szTDesc.Width = intWidth;
                    szTSpec.Width = intWidth;
                }

                txtTalentDescription.Size = szTDesc;
                txtTalentSpecial.Size     = szTSpec;

                btnSelectTalent.Enabled = true;
            }
        }