void ExportPointsSummary(GCACharacter pc, GCAWriter fw)
 {
     fw.WriteLine();
 }
 void ExportEquiment(GCACharacter pc, GCAWriter fw)
 {
     fw.WriteHeader("Equipment [$" + pc.get_Cost(modConstants.Equipment) + "]");
     foreach (var item in ComplexListTrait(TraitTypes.Equipment, fw).Where(x => string.IsNullOrEmpty(x) != true))
     {
         fw.Write(item);
     }
     fw.WriteLine();
 }
 void ExportLoadout(GCACharacter pc, GCAWriter fw)
 {
     fw.WriteLine();
 }
        string AdvantageFormatter(GCATrait trait, GCAWriter fw)
        {
            var builder = new StringBuilder();
            builder.Append(trait.Name);
            if (!trait.get_TagItem("level").Equals("1") || !string.IsNullOrEmpty(trait.get_TagItem("upto")) || !string.IsNullOrEmpty(trait.LevelName)) // has more than one level
            {
                builder.AppendFormat(" {0}", string.IsNullOrEmpty(trait.LevelName) ? trait.get_TagItem("level") : trait.LevelName);
            }

            var label = builder.ToString();

            builder.Clear();
            if (!string.IsNullOrEmpty(trait.NameExt) || trait.Mods.Count() > 0)
                builder.Append(" (");
            if (!string.IsNullOrEmpty(trait.NameExt))
                builder.Append(trait.NameExt);
            if (!string.IsNullOrEmpty(trait.NameExt) && trait.Mods.Count() > 0)
                builder.Append("; ");
            if (trait.Mods.Count() > 0)
            {
                var mods = new List<GCAModifier>();
                foreach (GCAModifier item in trait.Mods)
                {
                    mods.Add(item);
                }
                builder.Append(String.Join("; ", mods.Select(x => ModifierFormatter(x, fw))));
            }
            if (!string.IsNullOrEmpty(trait.NameExt) || trait.Mods.Count() > 0)
                builder.Append(")");

            builder.AppendFormat(" [{0}]", trait.Points);

            return fw.FormatTrait(label, builder.ToString());
        }
        void ExportCultural(GCACharacter pc, GCAWriter fw)
        {
            fw.WriteHeader("Cultural Background");
            var label = "TL:";
            var curItem = pc.ItemByNameAndExt("Tech Level", modConstants.Stats);
            if (curItem != null)
            {
                var buffer = curItem.DisplayScore;
                if (curItem.Points != 0)
                {
                    buffer = string.Format("{0} [{1}]", buffer, curItem.Points);
                }
                fw.WriteTrait(label, buffer);
            }
            fw.WriteLine();

            if (pc.get_Count(modConstants.Cultures) > 0)
            {
                label = "Cultures: ";
                var buffer = SimpleStringTrait(TraitTypes.Cultures);
                fw.WriteTrait(label, buffer);
            }
            if (pc.get_Count(modConstants.Languages) > 0)
            {
                label = "Languages: ";
                var buffer = SimpleStringTrait(TraitTypes.Languages);
                fw.WriteTrait(label, buffer);
            }
            fw.WriteLine();
        }
 string FormatTrait(GCATrait trait, GCAWriter fw, int childDepth = 0)
 {
     //fw.WriteLine("DEBUG TRAIT {0} DEPTH {1}", trait.Name, childDepth);
     TraitFormatter formatter = null;
     switch (trait.ItemType)
     {
         case TraitTypes.Attributes:
             formatter = AttributeFormatter;
             break;
         case TraitTypes.Languages:
             formatter = AdvantageFormatter;
             break;
         case TraitTypes.Cultures:
             formatter = AdvantageFormatter;
             break;
         case TraitTypes.Advantages:
             formatter = AdvantageFormatter;
             break;
         case TraitTypes.Perks:
             formatter = AdvantageFormatter;
             break;
         case TraitTypes.Disadvantages:
             formatter = AdvantageFormatter;
             break;
         case TraitTypes.Quirks:
             formatter = AdvantageFormatter;
             break;
         case TraitTypes.Skills:
             formatter = SkillFormatter;
             break;
         case TraitTypes.Spells:
             formatter = SkillFormatter;
             break;
         case TraitTypes.Equipment:
             formatter = EquipmentFormatter;
             break;
         case TraitTypes.Templates:
             formatter = TemplateFormatter;
             break;
     }
     var builder = new StringBuilder();
     if ( string.IsNullOrEmpty(trait.get_TagItem("parentkey")) || childDepth > 0)
     {
         for (int i = 0; i < childDepth; i++)
         {
             builder.Append(":");
         }
         builder.Append(formatter != null ? formatter(trait, fw) : string.Empty);
         builder.Append(Environment.NewLine);
         if (!string.IsNullOrEmpty(trait.get_ChildKeyList()))
         {
             var keys = trait.get_ChildKeyList().Split(',');
             //fw.WriteLine("DEBUG TRAIT '{0}' CHILDREN '{1}'", trait.Name, string.Join(",", keys));
             foreach (var key in keys)
             {
                 var cleanKey = key.Trim().Substring(1);
                 var child = Traits.FirstOrDefault(x => x.IDKey.Equals(Convert.ToInt32( cleanKey)));
                 //fw.WriteLine("DEBUG TRAIT '{0}' KEY '{1}' CHILD '{2}'", trait.Name, cleanKey, child);
                 if (child != null)
                 {
                     //fw.WriteLine("DEBUG FORMATTING CHILD '{2}'", trait.Name, cleanKey, child);
                     builder.Append(FormatTrait(child, fw, childDepth + 1));
                 }
             }
         }
     }
     return builder.ToString();
 }
        string SkillFormatter(GCATrait trait, GCAWriter fw)
        {
            var builder = new StringBuilder();
            builder.AppendFormat("{0} {1}:", trait.DisplayName, trait.get_TagItem("type"));
            var label = builder.ToString();

            builder.Clear();
            switch ((SkillType)int.Parse(trait.get_TagItem("sd")))
            {
                case SkillType.Skill:
                    string stepOff = trait.get_TagItem("stepoff");
                    if (!stepOff.Equals(string.Empty))
                    {
                        builder.Append(stepOff);
                        string step = trait.get_TagItem("step");
                        if (!step.Equals(string.Empty))
                            builder.Append(step);
                        else
                            builder.Append("?");
                    }
                    else
                    {
                        builder.Append("?+?");
                    }
                    builder.AppendFormat(" - {0}", trait.get_TagItem("level"));
                    break;
                case SkillType.Technique:
                    builder.AppendFormat(" - {0}", trait.get_TagItem("level"));
                    break;
                case SkillType.Combo:
                    builder.AppendFormat(" - {0}", trait.get_TagItem("combolevel"));
                    break;
                default:
                    break;
            }
            builder.AppendFormat(" [{0}]", trait.Points);

            return fw.FormatTrait(label, builder.ToString());
        }
        string EquipmentFormatter(GCATrait trait, GCAWriter fw)
        {
            var builder = new StringBuilder();
            builder.Append(trait.DisplayName);

            var label = builder.ToString();

            builder.Clear();
            if (!string.IsNullOrEmpty(trait.NameExt) || trait.Mods.Count() > 0)
                builder.Append("(");
            if (!string.IsNullOrEmpty(trait.NameExt))
                builder.Append(trait.NameExt);
            if (!string.IsNullOrEmpty(trait.NameExt) && trait.Mods.Count() > 0)
                builder.Append("; ");
            if (trait.Mods.Count() > 0)
            {
                var mods = new List<GCAModifier>();
                foreach (GCAModifier item in trait.Mods)
                {
                    mods.Add(item);
                }
                builder.Append(String.Join("; ", mods.Select(x => ModifierFormatter(x, fw))));
            }
            if (!string.IsNullOrEmpty(trait.NameExt) || trait.Mods.Count() > 0)
                builder.Append(")");

            if ( Convert.ToInt32( trait.get_TagItem("count")) > 1 )
            {
                builder.AppendFormat(" {0} lbs, ${1} ×{2} = {3} lbs ${4}", trait.get_TagItem("precountweight"), trait.get_TagItem("precountcost"), trait.get_TagItem("count"), trait.get_TagItem("weight"), trait.get_TagItem("cost"));
            }
            else
            {
                builder.AppendFormat(" {0} lbs ${1}", trait.get_TagItem("weight"), trait.get_TagItem("cost"));
            }
            return fw.FormatTrait(label, builder.ToString());
        }
        void ExportAttributes(GCACharacter pc, GCAWriter fw)
        {
            fw.WriteHeader("Attributes [" + pc.get_Cost(modConstants.Stats) + "]");

            var StatNames = new List<string> {
                "ST",
                "DX",
                "IQ",
                "HT"};
            foreach (var item in ComplexListAttributes(StatNames, fw))
            {
                fw.Write(item);
            }
            fw.WriteLine();
            StatNames.Clear();

            StatNames.AddRange(new string[] {
                "Hit Points",
                "Will",
                "Perception",
                "Fatigue Points"}
            );
            foreach (var item in ComplexListAttributes(StatNames, fw))
            {
                fw.Write(item);
            }
            fw.WriteLine();
        }
Exemple #10
0
        /// <summary>
        /// Generates a SJG-formatted list of the specified trait type, visible traits only.
        /// This includes level, name extensions, and modifiers, but not "effective skill".
        /// </summary>
        /// <param name="traitType">Type of trait to harvest.</param>
        /// <returns>A semicolon separated, period-terminated list.</returns>
        string ComplexStringAdsDisads(TraitTypes traitType, GCAWriter fw)
        {
            var result = from trait in Traits
                         where trait.ItemType == traitType
                         where string.IsNullOrEmpty(trait.get_TagItem("hide"))
                         select trait;

            return String.Join("; ", result.Select(x => AdvantageFormatter(x, fw))) + ".";
        }
Exemple #11
0
 void DoCharacterSeparator(int separatorOptionChoice, GCAWriter fw)
 {
     string separator = " ";
     switch ((CharacterSeparators)separatorOptionChoice)
     {
         case CharacterSeparators.DoNothing:
             break;
         case CharacterSeparators.PrintStars:
             separator = "*";
             break;
         case CharacterSeparators.PrintEquals:
             separator = "=";
             break;
         case CharacterSeparators.PrintHyphens:
             separator = "-";
             break;
         case CharacterSeparators.PrintHTMLHR:
             separator = "<hr/>";
             break;
     }
     if (!Equals(separator, " ") && !Equals(separator, "<hr/>"))
     {
         fw.WriteLine(new String(separator.ToCharArray()[0], 60));
     }
     else if (Equals(separator, "<hr/>"))
     {
         fw.WriteLine(separator);
     }
     fw.WriteLine();
 }
Exemple #12
0
 IEnumerable<string> ComplexListTrait(TraitTypes traitType, GCAWriter fw)
 {
     var result = from trait in Traits
                  where trait.ItemType == traitType
                  where string.IsNullOrEmpty(trait.get_TagItem("hide"))
                  select FormatTrait(trait, fw);
     return result;
 }
Exemple #13
0
 IEnumerable<string> ComplexListAttributes(List<string> attributeList, GCAWriter fw)
 {
     var result = from trait in Traits
                  where trait.ItemType == TraitTypes.Attributes
                  where attributeList.Contains( trait.Name )
                  //where !string.IsNullOrEmpty(trait.get_TagItem("mainwin"))
                  //where !string.IsNullOrEmpty(trait.get_TagItem("display"))
                  //where string.IsNullOrEmpty(trait.get_TagItem("hide"))
                  orderby trait.get_TagItem("mainwin")
                  select FormatTrait(trait, fw);
     return result;
 }
Exemple #14
0
        string AttributeFormatter(GCATrait trait, GCAWriter fw)
        {
            var builder = new StringBuilder();
            builder.Append(trait.DisplayName);

            var label = builder.ToString();

            builder.Clear();
            builder.Append(trait.DisplayScore);

            builder.AppendFormat(" [{0}]", trait.Points);
            return fw.FormatTrait(label, builder.ToString());
        }
Exemple #15
0
 void ExportReaction(GCACharacter pc, GCAWriter fw)
 {
     fw.WriteHeader("Reaction Modifiers");
     fw.WriteLine();
 }
Exemple #16
0
        void ExportBiography(GCACharacter CurChar, GCAWriter fw)
        {
            fw.WriteTrait("Name:", CurChar.Name);
            fw.WriteTrait("Player:", CurChar.Player);
            fw.WriteTrait("Race:", CurChar.Race);
            if (! string.IsNullOrEmpty( CurChar.Appearance))
                fw.WriteTrait("Appearance: ", CurChar.Appearance);

            if (!string.IsNullOrEmpty(CurChar.Height))
                fw.WriteTrait("Height:", CurChar.Height);

            if (!string.IsNullOrEmpty(CurChar.Weight))
                fw.WriteTrait("Weight:", CurChar.Weight);

            if (!string.IsNullOrEmpty(CurChar.Age))
                fw.WriteTrait("Age:", CurChar.Age);

            fw.WriteLine("");
        }
Exemple #17
0
 void ExportSpells(GCACharacter pc, GCAWriter fw)
 {
     fw.WriteHeader("Spells [" + pc.get_Cost(modConstants.Spells) + "]");
     foreach (var item in ComplexListTrait(TraitTypes.Spells, fw).Where(x => string.IsNullOrEmpty(x) != true))
     {
         fw.Write(item);
     }
     fw.WriteLine();
 }
Exemple #18
0
        void ExportCharacter(GCACharacter pc, GCAWriter fw)
        {
            this.Traits = new List<GCATrait>();
            foreach (GCATrait item in pc.Items)
            {
                this.Traits.Add(item);
            }

            ExportBiography(pc, fw);
            ExportAttributes(pc, fw);
            ExportCultural(pc, fw);
            ExportReaction(pc, fw);
            ExportAdvantages(pc, fw);
            ExportPerks(pc, fw);
            ExportDisadvantages(pc, fw);
            ExportQuirks(pc, fw);
            ExportSkills(pc, fw);
            ExportSpells(pc, fw);
            ExportMeta(pc, fw);
            ExportPointsSummary(pc, fw);
            ExportEquiment(pc, fw);
            ExportCombat(pc, fw);
            ExportLoadout(pc, fw);
        }
Exemple #19
0
 string ModifierFormatter(GCAModifier trait, GCAWriter fw)
 {
     var builder = new StringBuilder();
     builder.Append(trait.DisplayName.Trim());
     if (!trait.get_TagItem("level").Equals("1") || !string.IsNullOrEmpty(trait.get_TagItem("upto")) || !string.IsNullOrEmpty(trait.LevelName())) // has more than one level or has named levels
     {
         builder.AppendFormat(" {0}", string.IsNullOrEmpty(trait.LevelName()) ? trait.get_TagItem("level") : trait.LevelName());
     }
     builder.AppendFormat(", {0}", trait.get_TagItem("value"));
     return builder.ToString();
 }
Exemple #20
0
 void ExportCombat(GCACharacter pc, GCAWriter fw)
 {
     fw.WriteLine();
 }
Exemple #21
0
 string TemplateFormatter(GCATrait trait, GCAWriter fw)
 {
     return AdvantageFormatter(trait, fw);
 }
Exemple #22
0
        /// <summary>
        /// This creates the export file on disk.
        /// </summary>
        /// <param name="Party"></param>
        /// <param name="TargetFilename"></param>
        /// <param name="Options"></param>
        /// <returns></returns>
        bool IExportSheet.GenerateExport(Party Party, string TargetFilename, SheetOptionsManager Options)
        {
            MyOptions = Options;

            bool printMults = (int)MyOptions.get_Value("OutputCharacters") == 1;
            try
            {
                using (var fw = new GCAWriter(TargetFilename, false, MyOptions))
                {
                    if (Party.Characters.Count > 1 && printMults)
                        foreach (GCACharacter pc in Party.Characters)
                        {
                            ExportCharacter(pc, fw);
                            DoCharacterSeparator((int)MyOptions.get_Value("CharacterSeparator"), fw);
                        }
                    else
                        ExportCharacter(Party.Current, fw);
                }
            }
            catch (Exception ex)
            {
                modHelperFunctions.Notify(Name + ": failed on export. " + ex.Message + "\n" + "Stack Trace: " + "\n" + ex.StackTrace, Priority.Red);
            }

            return true;
        }