public static string CreateCharacter(Alignment alignment, Background background, int baseCharisma, int baseConstitution, int baseDexterity, int baseIntelligence, int baseStrength, int baseWisdom, List<Spell> cantrips, CharacterClass chClass, List<Skill> classSkills, List<Skill> classTools, int gender, int hairColor, int hairStyle, string name, Race race, List<Skill> raceSkills, int skinColor, List<Spell> spellsKnown, CharacterClass subClass, List<Power> selectedPowers)
 {
     CharacterCreation chr = new CharacterCreation()
     {
         Alignment = alignment,
         Background = background,
         BaseCharisma = baseCharisma,
         BaseConstitution = baseConstitution,
         BaseDexterity = baseDexterity,
         BaseIntelligence = baseIntelligence,
         BaseStrength = baseStrength,
         BaseWisdom = baseWisdom,
         Cantrips = cantrips,
         Class = chClass,
         ClassSkills = classSkills,
         ClassTools = classTools,
         Gender = gender,
         HairColor = hairColor,
         HairStyle = hairStyle,
         Name = name,
         Race = race,
         RaceSkills = raceSkills,
         SelectedPowers = selectedPowers,
         SessionId = SessionId,
         SkinColor = skinColor,
         SpellsKnown = spellsKnown,
         SubClass = subClass,
         UserId = UserId
     };
     try
     {
         string wrURI = baseServerTarget + "createcharacter";
         string msg = chr.ToString();
         WebRequest wreq = WebRequest.Create(wrURI + "?message=" + msg);
         wreq.Method = "POST";
         wreq.ContentLength = 0;
         WebResponse wresp = wreq.GetResponse();
         using (TextReader sr = new StreamReader(wresp.GetResponseStream()))
         {
             XmlSerializer xml = new XmlSerializer(typeof(string), StringNamespace);
             string resp = (string)xml.Deserialize(sr);
             return resp;
         }
     }
     catch 
     {
         return String.Empty;
     }
 }
Beispiel #2
0
        /// <summary>
        /// Load skills from the DataArrays\Races.txt folder and store them in _library
        /// </summary>
        public static void Load()
        {
            string file = System.IO.Directory.GetCurrentDirectory() + "\\DataArrays\\Races.txt";
            FileStream strLib = File.Open(file, FileMode.Open);
            using (StreamReader read = new StreamReader(strLib, Encoding.UTF7))
            {
                while (read.Peek() >= 0)
                {
                    Race toAdd = new Race(read.ReadLine());
                    toAdd.PlayableHairStyles = new Dictionary<int, int>();
                    foreach(string hair in Directory.GetFiles(System.IO.Directory.GetCurrentDirectory() + "\\Images\\Characters\\"+ toAdd.Id + "\\0\\Hair"))
                    {
                        string s = hair.Substring(hair.Length - 11, 2);
                        s = s.Trim('_');
                        int num;
                        int.TryParse(s, out num);
                        if(!toAdd.PlayableHairStyles.ContainsKey(0))
                        {
                            toAdd.PlayableHairStyles.Add(0, num);
                        }
                        else if(toAdd.PlayableHairStyles[0] + 1 == num)
                        {
                            toAdd.PlayableHairStyles[0]++;
                        }
                    }
                    foreach (string hair in Directory.GetFiles(System.IO.Directory.GetCurrentDirectory() + "\\Images\\Characters\\" + toAdd.Id + "\\1\\Hair"))
                    {
                        string s = hair.Substring(hair.Length - 11, 2);
                        s = s.Trim('_');
                        int num;
                        int.TryParse(s, out num);
                        if (!toAdd.PlayableHairStyles.ContainsKey(1))
                        {
                            toAdd.PlayableHairStyles.Add(1, num);
                        }
                        else if (toAdd.PlayableHairStyles[1] + 1 == num)
                        {
                            toAdd.PlayableHairStyles[1]++;
                        }
                    }
                    _library.Add(toAdd.Id, toAdd);
                }
            }

            file = System.IO.Directory.GetCurrentDirectory() + "\\DataArrays\\Race_SkinTone.txt";
            strLib = File.Open(file, FileMode.Open);
            using (StreamReader read = new StreamReader(strLib, Encoding.UTF7))
            {
                while (read.Peek() >= 0)
                {
                    string[] raceLine = read.ReadLine().Split(new char[] { '|' });
                    uint race = 0;
                    uint.TryParse(raceLine[0], out race);
                    List<SkinColor> colors = new List<SkinColor>();
                    foreach(string colorLine in raceLine)
                    {
                        if (!colorLine.Contains(',')) continue;
                        colors.Add(new SkinColor(colorLine));
                    }
                    _library[race].SkinColors = colors;   
                }
            }

            file = System.IO.Directory.GetCurrentDirectory() + "\\DataArrays\\Race_HairColor.txt";
            strLib = File.Open(file, FileMode.Open);
            using (StreamReader read = new StreamReader(strLib, Encoding.UTF7))
            {
                while (read.Peek() >= 0)
                {
                    string[] raceLine = read.ReadLine().Split(new char[] { '|' });
                    uint race = 0;
                    uint.TryParse(raceLine[0], out race);
                    List<SkinColor> colors = new List<SkinColor>();
                    foreach (string colorLine in raceLine)
                    {
                        if (!colorLine.Contains(',')) continue;
                        colors.Add(new SkinColor(colorLine));
                    }
                    _library[race].HairColors = colors;
                }
            }
        }
        public CharacterCreation(string buildLine)
        {
            Valid = false;
            string[] buildSplit = buildLine.Split(delim);
            if(buildSplit.Length != 24) { return; }
            Name = buildSplit[0];

            if(!int.TryParse(buildSplit[1], out Gender))
            {
                return;
            }

            uint tempUint = 0;
            if(!uint.TryParse(buildSplit[2], out tempUint))
            {
                return;
            }

            Race = Race.GetRace(tempUint);
            if(Race == null)
            {
                return;
            }

            if(!uint.TryParse(buildSplit[3], out tempUint))
            {
                return;
            }

            Class = CharacterClass.GetClass(tempUint);
            if(Class == null)
            {
                return;
            }

            if(!uint.TryParse(buildSplit[4], out tempUint))
            {
                return;
            }

            Background = Background.GetBackground(tempUint);
            if(Background == null)
            {
                return;
            }

            if(!uint.TryParse(buildSplit[5], out tempUint))
            {
                return;
            }

            Alignment = Alignment.GetAlignment(tempUint);
            if(Alignment == null)
            {
                return;
            }

            RaceSkills = new List<Skill>();
            string[] raceSkillSplit = buildSplit[6].Split(listDelim);
            foreach(string raceSkill in raceSkillSplit)
            {
                if(String.IsNullOrWhiteSpace(raceSkill))
                {
                    continue;
                }

                uint skillId = 0;
                if(!uint.TryParse(raceSkill, out skillId))
                {
                    return;
                }
                Skill toAdd = Skill.GetSkill(skillId);
                if(toAdd == null)
                {
                    return;
                }
                RaceSkills.Add(toAdd);
            }
            if(RaceSkills.Count > Race.FreeSkills)
            {
                return;
            }
            foreach(Skill sk in RaceSkills)
            {
                if(!Race.SelectedSkill.Contains(sk))
                {
                    return;
                }
            }

            ClassSkills = new List<Skill>();
            string[] classSkillSplit = buildSplit[7].Split(listDelim);
            foreach(string classSkill in classSkillSplit)
            {
                if(String.IsNullOrWhiteSpace(classSkill))
                {
                    continue;
                }

                uint skillId = 0;
                if(!uint.TryParse(classSkill, out skillId))
                {
                    return;
                }
                Skill toAdd = Skill.GetSkill(skillId);
                if(toAdd == null)
                {
                    return;
                }
                ClassSkills.Add(toAdd);
            }
            if(ClassSkills.Count > Class.SkillChoices)
            {
                return;
            }
            foreach(Skill sk in ClassSkills)
            {
                if (!Class.AvailableSkills.Contains(sk))
                {
                    return;
                }
            }

            ClassTools = new List<Skill>();
            string[] classToolSplit = buildSplit[8].Split(listDelim);
            foreach(string classTool in classToolSplit)
            {
                if(String.IsNullOrWhiteSpace(classTool))
                {
                    continue;
                }

                uint skillId = 0;
                if(!uint.TryParse(classTool, out skillId))
                {
                    return;
                }
                Skill toAdd = Skill.GetSkill(skillId);
                if(toAdd == null)
                {
                    return;
                }
                ClassTools.Add(toAdd);
            }
            if(ClassTools.Count > Class.ToolChoices)
            {
                return;
            }
            foreach(Skill sk in ClassTools)
            {
                if(!Class.AvailableTools.Contains(sk))
                {
                    return;
                }
            }

            Cantrips = new List<Spell>();
            if (Class.CantripsKnown != null &&
               Class.CantripsKnown.Count > 0)
            {
                string[] cantripsSplit = buildSplit[9].Split(listDelim);
                foreach(string cantrip in cantripsSplit)
                {
                    if(String.IsNullOrWhiteSpace(cantrip))
                    {
                        continue;
                    }

                    uint spellId = 0;
                    if(!uint.TryParse(cantrip, out spellId))
                    {
                        return;
                    }
                    Spell toAdd = Spell.GetSpell(spellId);
                    if(toAdd == null)
                    {
                        return;
                    }
                    Cantrips.Add(toAdd);
                }
                if(Cantrips.Count > Class.CantripsKnown[0])
                {
                    return;
                }
                if (Cantrips.Count > 0)
                {
                    if(Class.SpellList == null)
                    {
                        return;
                    }
                    if (!Class.SpellList.ContainsKey(0))
                    {
                        return;
                    }
                    foreach (Spell sp in Cantrips)
                    {
                        if(!Class.SpellList[0].Contains(sp))
                        {
                            return;
                        }
                    }
                }
            }

            SpellsKnown = new List<Spell>();
            if (Class.SpellsKnown != null &&
                Class.SpellsKnown.Count > 0)
            {
                string[] spellSplit = buildSplit[10].Split(listDelim);
                foreach(string spellKnown in spellSplit)
                {
                    if(String.IsNullOrWhiteSpace(spellKnown))
                    {
                        continue;
                    }
                    uint spellId = 0;
                    if(!uint.TryParse(spellKnown, out spellId))
                    {
                        return;
                    }
                    Spell toAdd = Spell.GetSpell(spellId);
                    if(toAdd == null)
                    {
                        return;
                    }
                    SpellsKnown.Add(toAdd);
                }
                if(SpellsKnown.Count > Class.SpellsKnown[0])
                {
                    return;
                }
                if(SpellsKnown.Count > 0)
                {
                    if(!Class.SpellList.ContainsKey(1))
                    {
                        return;
                    }
                    foreach(Spell sp in SpellsKnown)
                    {
                        if(!Class.SpellList[1].Contains(sp))
                        {
                            return;
                        }
                    }
                }
            }

            if(!int.TryParse(buildSplit[11], out BaseStrength))
            {
                return;
            }
            if(!AbilityScoreCosts.ContainsKey(BaseStrength))
            {
                return;
            }
            if(!int.TryParse(buildSplit[12], out BaseDexterity))
            {
                return;
            }
            if(!AbilityScoreCosts.ContainsKey(BaseDexterity))
            {
                return;
            }
            if(!int.TryParse(buildSplit[13], out BaseConstitution))
            {
                return;
            }
            if(!AbilityScoreCosts.ContainsKey(BaseConstitution))
            {
                return;
            }
            if(!int.TryParse(buildSplit[14], out BaseIntelligence))
            {
                return;
            }
            if(!AbilityScoreCosts.ContainsKey(BaseIntelligence))
            {
                return;
            }
            if(!int.TryParse(buildSplit[15], out BaseWisdom))
            {
                return;
            }
            if(!AbilityScoreCosts.ContainsKey(BaseWisdom))
            {
                return;
            }
            if(!int.TryParse(buildSplit[16], out BaseCharisma))
            {
                return;
            }
            if(!AbilityScoreCosts.ContainsKey(BaseCharisma))
            {
                return;
            }

            if(GetRemainingPoints(BaseStrength, BaseDexterity, BaseConstitution, BaseIntelligence, BaseWisdom, BaseCharisma, Race) < 0)
            {
                return;
            }

            if(!int.TryParse(buildSplit[17], out HairStyle))
            {
                return;
            }
            if(!int.TryParse(buildSplit[18], out HairColor))
            {
                return;
            }
            if(!int.TryParse(buildSplit[19], out SkinColor))
            {
                return;
            }
            UserId = buildSplit[20];

            if(!int.TryParse(buildSplit[21], out SessionId))
            {
                return;
            }

            if(!String.IsNullOrWhiteSpace(buildSplit[22]))
            {
                uint subClassId;
                if (!uint.TryParse(buildSplit[22], out subClassId))
                {
                    CharacterClass sub = CharacterClass.GetClass(subClassId);
                    if (sub == null)
                    {
                        return;
                    }
                    if (Class.SubClasses.Contains(sub))
                    {
                        SubClass = sub;
                    }
                    else
                    {
                        return;
                    }
                }
            }
            else
            {
                SubClass = null;
            }
            if(SubClass == null && Class.SubClassLevel == 1)
            {
                return;
            }
            if(SubClass != null && Class.SubClassLevel != 1)
            {
                return;
            }
            if(Class.SubClassLevel == 1)
            {
                if(!Class.SubClasses.Contains(SubClass))
                {
                    return;
                }
            }

            string[] powerSplit = buildSplit[23].Split(listDelim);
            List<Power> selPow = new List<Power>();
            SelectedPowers = new List<Power>();
            foreach(string powString in powerSplit)
            {
                if(String.IsNullOrWhiteSpace(powString))
                {
                    continue;
                }
                uint powIndex = uint.MaxValue;
                if(!uint.TryParse(powString, out powIndex))
                {
                    return;
                }
                Power toAdd = Power.GetPower(powIndex);
                if(toAdd == null)
                {
                    return;
                }
                selPow.Add(toAdd);
            }

            if(Class.ClassPowers.ContainsKey(1))
            {
                foreach(List<Power> classPowerList in Class.ClassPowers[1])
                {
                    foreach(Power classPower in classPowerList)
                    {
                        if(selPow.Contains(classPower))
                        {
                            selPow.Remove(classPower);
                            SelectedPowers.Add(classPower);
                            break;
                        }
                    }
                }
            }
            if(SubClass != null && Class.ClassPowers.ContainsKey(1))
            {
                foreach (List<Power> classPowerList in SubClass.ClassPowers[1])
                {
                    foreach (Power classPower in classPowerList)
                    {
                        if (selPow.Contains(classPower))
                        {
                            selPow.Remove(classPower);
                            SelectedPowers.Add(classPower);
                            break;
                        }
                    }
                }
            }
            if(selPow.Count > 0)
            {
                return;
            }

            Valid = true;
        }
        public static int GetRemainingPoints(int str, int dex, int con, int intel, int wis, int cha, Race race)
        {
            int _strengthCostAdjust = 0;
            int _dexterityCostAdjust = 0;
            int _constitutionCostAdjust = 0;
            int _wisdomCostAdjust = 0;
            int _intelligenceCostAdjust = 0;
            int _charismaCostAdjust = 0;
            if (race != null &&
                race.OtherBonusStats > 0)
            {
                int bonuses = race.OtherBonusStats;
                List<int> scores = new List<int>();
                if (race.Strength == 0) scores.Add(str);
                if (race.Dexterity == 0) scores.Add(dex);
                if (race.Constitution == 0) scores.Add(con);
                if (race.Intelligence == 0) scores.Add(intel);
                if (race.Wisdom == 0) scores.Add(wis);
                if (race.Charisma == 0) scores.Add(cha);

                scores.Sort();
                while (bonuses > 0)
                {
                    if (str == scores[scores.Count - bonuses] &&
                        _strengthCostAdjust == 0)
                    {
                        _strengthCostAdjust--;
                    }
                    else if (dex == scores[scores.Count - bonuses] &&
                        _dexterityCostAdjust == 0)
                    {
                        _dexterityCostAdjust--;
                    }
                    else if (con == scores[scores.Count - bonuses] &&
                        _constitutionCostAdjust == 0)
                    {
                        _constitutionCostAdjust--;
                    }
                    else if (intel == scores[scores.Count - bonuses] &&
                        _intelligenceCostAdjust == 0)
                    {
                        _intelligenceCostAdjust--;
                    }
                    else if (wis == scores[scores.Count - bonuses] &&
                        _wisdomCostAdjust == 0)
                    {
                        _wisdomCostAdjust--;
                    }
                    else if (cha == scores[scores.Count - bonuses] &&
                        _charismaCostAdjust == 0)
                    {
                        _charismaCostAdjust--;
                    }
                    bonuses--;
                }
            }


            return 40 - AbilityScoreCosts[str + _strengthCostAdjust] -
                        AbilityScoreCosts[dex + _dexterityCostAdjust] -
                        AbilityScoreCosts[con + _constitutionCostAdjust] -
                        AbilityScoreCosts[intel + _intelligenceCostAdjust] -
                        AbilityScoreCosts[wis + _wisdomCostAdjust] -
                        AbilityScoreCosts[cha + _charismaCostAdjust];
        }
 private static void RaceBox_ItemSelectionChanged(object sender, ListViewItemSelectionChangedEventArgs e)
 {
     if (e.IsSelected)
     {
         Race selectedRace = Race.GetRace((uint)e.Item.Tag);
         if (selectedRace != null)
         {
             e.Item.Selected = false; // Because we'll get extra simultaneous events if we don't do this.
             raceText.Text = e.Item.Name;
             raceIcon.BackgroundImage = selectedRace.Icon;
             _selectedRace = selectedRace;
             if (_selectedGender > -1)
             {
                 scene.Remove(displayChar);
                 displayChar.CharacterRace = _selectedRace.Id;
                 displayChar.Clothes = 0;
                 displayChar.ClothColorA = 0;
                 displayChar.ClothColorB = 0;
                 displayChar.Hair = 0;
                 displayChar.HairColor = 0;
                 displayChar.Height = _selectedRace.Height;
                 displayChar.Sex = _selectedGender;
                 displayChar.SkinColor = 0;
                 EditAppearance();
             }
             else
             { 
                 _populateRaceList();
             }
         }
         UpdateAbilityScores();
         UpdateSkills();
         _updateCharacterSheetPowers();
     }
 }