private void SetReaderToObject(ref FeatPrereqORCondition objFeatPrereqORCondition, ref SqlDataReader result)
        {
            if (result.HasRows)
            {
                objFeatPrereqORCondition.FeatPrereqORConditionID = (int)result.GetValue(result.GetOrdinal("FeatPrereqORConditionID"));
                objFeatPrereqORCondition.FeatID                   = (int)result.GetValue(result.GetOrdinal("FeatID"));
                objFeatPrereqORCondition.TalentID                 = (int)result.GetValue(result.GetOrdinal("TalentID"));
                objFeatPrereqORCondition.FeatRequirementID        = (int)result.GetValue(result.GetOrdinal("FeatRequirementID"));
                objFeatPrereqORCondition.RaceID                   = (int)result.GetValue(result.GetOrdinal("RaceID"));
                objFeatPrereqORCondition.TalentTreeID             = (int)result.GetValue(result.GetOrdinal("TalentTreeID"));
                objFeatPrereqORCondition.TalentTreeTalentQuantity = (int)result.GetValue(result.GetOrdinal("TalentTreeTalentQuantity"));
                objFeatPrereqORCondition.AbilityID                = (int)result.GetValue(result.GetOrdinal("AbilityID"));
                objFeatPrereqORCondition.AbilityMinimum           = (int)result.GetValue(result.GetOrdinal("AbilityMinimum"));
                objFeatPrereqORCondition.SkillID                  = (int)result.GetValue(result.GetOrdinal("SkillID"));

                Talent objT = new Talent(objFeatPrereqORCondition.TalentID);
                objFeatPrereqORCondition.objTalent = objT;

                Feat objF = new Feat(objFeatPrereqORCondition.FeatRequirementID);
                objFeatPrereqORCondition.objFeatRequirement = objF;

                Race objR = new Race(objFeatPrereqORCondition.RaceID);
                objFeatPrereqORCondition.objRace = objR;

                TalentTree objTT = new TalentTree(objFeatPrereqORCondition.TalentTreeID);
                objFeatPrereqORCondition.objTalentTree = objTT;

                Ability objA = new Ability(objFeatPrereqORCondition.AbilityID);
                objFeatPrereqORCondition.objAbility = objA;

                Skill objS = new Skill(objFeatPrereqORCondition.SkillID);
                objFeatPrereqORCondition.objSkill = objS;
            }
        }
Beispiel #2
0
        /// <summary>
        /// Sets the reader to object.
        /// </summary>
        /// <param name="objFeat">The object feat.</param>
        /// <param name="result">The result.</param>
        private void SetReaderToObject(ref Feat objFeat, ref SqlDataReader result)
        {
            if (result.HasRows)
            {
                objFeat.FeatID              = (int)result.GetValue(result.GetOrdinal("FeatID"));
                objFeat.FeatName            = result.GetValue(result.GetOrdinal("FeatName")).ToString();
                objFeat.FeatDescription     = result.GetValue(result.GetOrdinal("FeatDescription")).ToString();
                objFeat.FeatSpecial         = result.GetValue(result.GetOrdinal("FeatSpecial")).ToString();
                objFeat.RageRequired        = (bool)result.GetValue(result.GetOrdinal("RageRequired"));
                objFeat.ShapeShiftRequired  = (bool)result.GetValue(result.GetOrdinal("ShapeShiftRequired"));
                objFeat.MultipleSelection   = (int)result.GetValue(result.GetOrdinal("MultipleSelection"));
                objFeat.BookID              = (int)result.GetValue(result.GetOrdinal("BookID"));
                objFeat.SkillTrainingFeat   = (bool)result.GetValue(result.GetOrdinal("SkillTrainingFeat"));
                objFeat.SkillFocusFeat      = (bool)result.GetValue(result.GetOrdinal("SkillFocusFeat"));
                objFeat.WeaponProficiencyID = (bool)result.GetValue(result.GetOrdinal("WeaponProficiencyID"));
                objFeat.ArmorProficiencyID  = (bool)result.GetValue(result.GetOrdinal("ArmorProficiencyID"));

                FeatPrerequisiteAbility objFeatPrerequisiteAbility = new FeatPrerequisiteAbility();
                Feat       objPreReqFeat = new Feat();
                BaseAttack objBaseAttack = new BaseAttack();
                Skill      objSkill      = new Skill();
                Race       objRace       = new Race();
                Class      objClass      = new Class();
                Size       objSize       = new Size();
                FeatPrerequisiteDarkSide objFeatPrerequisiteDarkSide = new FeatPrerequisiteDarkSide();
                FeatPrereqORCondition    objFeatPrereqORCondition    = new FeatPrereqORCondition();

                objFeat.objFeatPrerequisiteAbilities = objFeatPrerequisiteAbility.GetFeatPrerequisiteAbilites(" FeatID=" + objFeat.FeatID.ToString(), "");
                objFeat.objFeatPrerequisiteFeats     = objPreReqFeat.GetFeatPrerequisiteFeats(" [otmFeatPrequisiteFeat].FeatID=" + objFeat.FeatID.ToString(), " FeatName");
                objFeat.objBaseAttackPrerequisite    = objBaseAttack.GetFeatPrequisiteBaseAttackBonus(objFeat.FeatID);
                objFeat.objSkillPrerequisite         = objSkill.GetFeatPrerequisiteSkill(objFeat.FeatID);
                objFeat.objFeatPrerequisiteClasses   = objClass.GetFeatPrerequisiteClass(objFeat.FeatID);
                objFeat.objRacePrerequisite          = objRace.GetFeatPrerequisiteRace(objFeat.FeatID);
                objFeat.objFeatPrerequisiteSize      = objSize.GetFeatPrerequisiteSize(objFeat.FeatID);
                objFeat.objFeatPrerequisiteDarkSide  = objFeatPrerequisiteDarkSide.GetFeatPrerequisiteDarkSide(objFeat.FeatID);
                objFeat.lstFeatPrereqORConditions    = objFeatPrereqORCondition.GetFeatPrereqORConditions(objFeat.FeatID);

                objFeat._objComboBoxData.Add(objFeat.FeatID, objFeat.FeatName);
            }
        }
        private List <FeatPrereqORCondition> GetFeatPrereqORConditionList(string strSprocName, string strWhere, string strOrderBy)
        {
            List <FeatPrereqORCondition> FeatPrereqORConditions = new List <FeatPrereqORCondition>();

            SqlDataReader      result;
            DatabaseConnection dbconn     = new DatabaseConnection();
            SqlCommand         command    = new SqlCommand();
            SqlConnection      connection = new SqlConnection(dbconn.SQLSEVERConnString);

            try
            {
                connection.Open();
                command.Connection  = connection;
                command.CommandType = CommandType.StoredProcedure;
                command.CommandText = strSprocName;
                command.Parameters.Add(dbconn.GenerateParameterObj("@strWhere", SqlDbType.VarChar, strWhere, 1000));
                command.Parameters.Add(dbconn.GenerateParameterObj("@strOrderBy", SqlDbType.VarChar, strOrderBy, 1000));
                result = command.ExecuteReader();

                while (result.Read())
                {
                    FeatPrereqORCondition objFeatPrereqORCondition = new FeatPrereqORCondition();
                    SetReaderToObject(ref objFeatPrereqORCondition, ref result);
                    FeatPrereqORConditions.Add(objFeatPrereqORCondition);
                }
            }
            catch
            {
                Exception e = new Exception();
                throw e;
            }
            finally
            {
                command.Dispose();
                connection.Close();
            }
            return(FeatPrereqORConditions);
        }
Beispiel #4
0
        static public bool FeatOrConditionsMeet(Character objChar, Feat objFeat)
        {
            bool returnVal = false;
            List <FeatPrereqORCondition> lstFPORCond = new List <FeatPrereqORCondition>();
            FeatPrereqORCondition        objFPORCond = new FeatPrereqORCondition();


            List <Talent> lstORTalents = new List <Talent>();
            List <Feat>   lstORFeats   = new List <Feat>();
            List <Race>   lstORRaces   = new List <Race>();
            List <TalentTalentTreeRequirement> lstORTalentTrees = new List <TalentTalentTreeRequirement>();
            List <TalentAbilityRequirement>    lstORAbility     = new List <TalentAbilityRequirement>();
            List <Skill> lstORSkill = new List <Skill>();

            lstFPORCond = objFPORCond.GetFeatPrereqORConditions(objFeat.FeatID);

            if (lstFPORCond.Count == 0)
            {
                returnVal = true;
            }
            else
            {
                foreach (FeatPrereqORCondition objOrCond in lstFPORCond)
                {
                    if (objOrCond.FeatRequirementID != 0)
                    {
                        Feat objFR = new Feat();
                        objFR.GetFeat(objOrCond.FeatRequirementID);
                        lstORFeats.Add(objFR);
                    }
                    if (objOrCond.TalentID != 0)
                    {
                        Talent objTalent = new Talent();
                        objTalent.GetTalent(objOrCond.TalentID);
                        lstORTalents.Add(objTalent);
                    }
                    if (objOrCond.RaceID != 0)
                    {
                        Race objRace = new Race();
                        objRace.GetRace(objOrCond.RaceID);
                        lstORRaces.Add(objRace);
                    }
                    if (objOrCond.TalentTreeID != 0)
                    {
                        TalentTalentTreeRequirement objTTTR = new TalentTalentTreeRequirement();
                        objTTTR.TalentTreeID             = objOrCond.TalentTreeID;
                        objTTTR.TalentTreeTalentQuantity = objOrCond.TalentTreeTalentQuantity;
                        lstORTalentTrees.Add(objTTTR);
                    }
                    if (objOrCond.AbilityID != 0)
                    {
                        TalentAbilityRequirement objTAR = new TalentAbilityRequirement();
                        objTAR.AbilityID     = objOrCond.AbilityID;
                        objTAR.AbilityMinium = objOrCond.AbilityMinimum;
                        lstORAbility.Add(objTAR);
                    }
                    if (objOrCond.SkillID != 0)
                    {
                        Skill objSkill = new Skill();
                        objSkill.GetSkill(objOrCond.SkillID);
                        lstORSkill.Add(objSkill);
                    }
                }

                //Got all the lists full, have to check to see if the character has ANY of these, if they do then we jump out and are done
                //Talent
                bool blnTalentFound = false;
                foreach (Talent objSearchTalent in lstORTalents)
                {
                    if (Talent.IsTalentInList(objSearchTalent, objChar.lstTalents))
                    {
                        blnTalentFound = true;
                    }
                }

                if (blnTalentFound)
                {
                    return(blnTalentFound);
                }

                //Feat
                bool blnFeatFound = false;
                foreach (Feat objSearchFeat in lstORFeats)
                {
                    if (Feat.IsFeatInList(objSearchFeat, objChar.lstFeats))
                    {
                        blnFeatFound = true;
                    }
                }

                if (blnFeatFound)
                {
                    return(blnFeatFound);
                }

                //Race
                bool blnRaceFound = false;
                foreach (Race objSearchRace in lstORRaces)
                {
                    if (objSearchRace.RaceID == objChar.RaceID)
                    {
                        blnRaceFound = true;
                    }
                }

                if (blnRaceFound)
                {
                    return(blnRaceFound);
                }

                //TalentTree talents (Has x number of talents in a particular tree
                bool blnTalentTreeQuantityFound = false;
                foreach (Talent objSearchTalent in lstORTalents)
                {
                    if (Talent.IsTalentInList(objSearchTalent, objChar.lstTalents))
                    {
                        blnTalentTreeQuantityFound = true;
                    }
                }

                if (blnTalentTreeQuantityFound)
                {
                    return(blnTalentTreeQuantityFound);
                }


                //Ability
                bool blnAbilityFound = false;
                foreach (TalentAbilityRequirement objSearchAbility in lstORAbility)
                {
                    if (Ability.AblityRequirementMet(objSearchAbility.AbilityID, objSearchAbility.AbilityMinium, objChar))
                    {
                        blnAbilityFound = true;
                    }
                }

                if (blnTalentTreeQuantityFound)
                {
                    return(blnAbilityFound);
                }

                //public int SkillID { get; set; }
                //Race
                bool blnSkillFound = false;
                foreach (Skill objSearchSkill in lstORSkill)
                {
                    if (CharacterSkill.IsSkillInList(objSearchSkill, objChar.lstCharacterSkills))
                    {
                        blnSkillFound = true;
                    }
                }

                if (blnSkillFound)
                {
                    return(blnSkillFound);
                }
            }

            //went thru everything, nothing found return false;
            return(returnVal);
        }