C# Legends.World类代码示例

 public Duel(List<Property> properties, World world)
     : base(properties, world)
 {
     foreach (Property property in properties)
         switch (property.Name)
         {
             case "ordinal": Ordinal = String.Intern(property.Value); break;
             case "coords": Coordinates = Formatting.ConvertToLocation(property.Value); break;
             case "parent_eventcol": ParentCollection = world.GetEventCollection(Convert.ToInt32(property.Value)); break;
             case "subregion_id": Region = world.GetRegion(Convert.ToInt32(property.Value)); break;
             case "feature_layer_id": UndergroundRegion = world.GetUndergroundRegion(Convert.ToInt32(property.Value)); break;
             case "site_id": Site = world.GetSite(Convert.ToInt32(property.Value)); break;
             case "attacking_hfid": Attacker = world.GetHistoricalFigure(Convert.ToInt32(property.Value)); break;
             case "defending_hfid": Defender = world.GetHistoricalFigure(Convert.ToInt32(property.Value)); break;
         }
     //foreach (WorldEvent collectionEvent in Collection) this.AddEvent(collectionEvent);
     if (ParentCollection != null && ParentCollection.GetType() == typeof(Battle))
         foreach (HFDied death in Collection.OfType<HFDied>())
         {
             Battle battle = ParentCollection as Battle;
             if (battle.NotableAttackers.Contains(death.HistoricalFigure))
             {
                 battle.AttackerDeathCount++;
                 battle.Attackers.Single(squad => squad.Race == death.HistoricalFigure.Race).Deaths++;
                 (battle.ParentCollection as War).AttackerDeathCount++;
             }
             else if (battle.NotableDefenders.Contains(death.HistoricalFigure))
             {
                 battle.DefenderDeathCount++;
                 battle.Defenders.Single(squad => squad.Race == death.HistoricalFigure.Race).Deaths++;
                 (battle.ParentCollection as War).DefenderDeathCount++;
             }
             (ParentCollection.ParentCollection as War).DeathCount++;
         }
 }

        public HistoricalFigureLink(List<Property> properties, World world)
        {
            Strength = 0;
            foreach (Property property in properties)
            {
                switch (property.Name)
                {
                    case "hfid":
                        int id = Convert.ToInt32(property.Value);
                        HistoricalFigure = world.GetHistoricalFigure(id);
                        if (HistoricalFigure == null)
                            notYetLoadedHFID = id;
                        break;
                    case "link_strength": Strength = Convert.ToInt32(property.Value); break;
                    case "link_type":
                        HistoricalFigureLinkType linkType = HistoricalFigureLinkType.Unknown;
                        if (!Enum.TryParse(Formatting.InitCaps(property.Value), out linkType))
                        {
                            Type = HistoricalFigureLinkType.Unknown;
                            world.ParsingErrors.Report("Unknown HF Link Type: " + property.Value);
                        }
                        else
                            Type = linkType;
                        break;
                }
            }

            //XML states that deity links, that should be 100, are 0.
            if (Type == HistoricalFigureLinkType.Deity && Strength == 0)
                Strength = 100;
        }

 protected EventCollection(List<Property> properties, World world)
 {
     Initialize();
     World = world;
     foreach(Property property in properties)
         switch(property.Name)
         {
             case "id": this.ID = Convert.ToInt32(property.Value); property.Known = true; break;
             case "start_year": this.StartYear = Convert.ToInt32(property.Value); property.Known = true; break;
             case "start_seconds72": this.StartSeconds72 = Convert.ToInt32(property.Value); property.Known = true; break;
             case "end_year": this.EndYear = Convert.ToInt32(property.Value); property.Known = true; break;
             case "end_seconds72": this.EndSeconds72 = Convert.ToInt32(property.Value); property.Known = true; break;
             case "type": this.Type = Formatting.InitCaps(String.Intern(property.Value)); property.Known = true; break;
             case "event":
                 WorldEvent collectionEvent = world.GetEvent(Convert.ToInt32(property.Value));
                 //Some Events don't exist in the XML now with 34.01? 
                 ///TODO: Investigate EventCollection Events that don't exist in the XML, check if they exist in game or if this is just errors.
                 if (collectionEvent != null)
                 {
                     collectionEvent.ParentCollection = this;
                     this.Collection.Add(collectionEvent); property.Known = true;
                 }
                 break;
             case "eventcol": this.CollectionIDs.Add(Convert.ToInt32(property.Value)); property.Known = true; break;
             default: break;
         }
 }

 public UndergroundRegion(List<Property> properties, World world)
     : base(properties, world)
 {
     Depth = 0;
     Type = "";
     Battles = new List<Battle>();
     Coordinates = new List<Location>();
     foreach (Property property in properties)
         switch(property.Name)
         {
             case "depth": Depth = Convert.ToInt32(property.Value); break;
             case "type": Type = Formatting.InitCaps(property.Value); break;
             case "coords":
                 string[] coordinateStrings = property.Value.Split(new char[] { '|' },
                     StringSplitOptions.RemoveEmptyEntries);
                 foreach (var coordinateString in coordinateStrings)
                 {
                     string[] xYCoordinates = coordinateString.Split(',');
                     int x = Convert.ToInt32(xYCoordinates[0]);
                     int y = Convert.ToInt32(xYCoordinates[1]);
                     Coordinates.Add(new Location(x, y));
                 }
                 break;
         }
 }

        public Theft(List<Property> properties, World world)
            : base(properties, world)
        {
            foreach (Property property in properties)
                switch (property.Name)
                {
                    case "ordinal": Ordinal = String.Intern(property.Value); break;
                    case "coords": Coordinates = Formatting.ConvertToLocation(property.Value); break;
                    case "parent_eventcol": ParentCollection = world.GetEventCollection(Convert.ToInt32(property.Value)); break;
                    case "subregion_id": Region = world.GetRegion(Convert.ToInt32(property.Value)); break;
                    case "feature_layer_id": UndergroundRegion = world.GetUndergroundRegion(Convert.ToInt32(property.Value)); break;
                    case "site_id": Site = world.GetSite(Convert.ToInt32(property.Value)); break;
                    case "attacking_enid": Attacker = world.GetEntity(Convert.ToInt32(property.Value)); break;
                    case "defending_enid": Defender = world.GetEntity(Convert.ToInt32(property.Value)); break;
                }

            foreach (ItemStolen theft in Collection.OfType<ItemStolen>())
            {
                theft.Site = Site;
                Site.AddEvent(theft);
                Site.Events = Site.Events.OrderBy(ev => ev.ID).ToList();
                if (Attacker.SiteHistory.Count == 1)
                {
                    theft.ReturnSite = Attacker.SiteHistory.First().Site;
                    theft.ReturnSite.AddEvent(theft);
                    theft.ReturnSite.Events = theft.ReturnSite.Events.OrderBy(ev => ev.ID).ToList();
                }

            }
        }

        public static HTMLPrinter GetPrinter(object printObject, World world)
        {
            Type printType = printObject.GetType();
            if (printType == typeof(Battle))
                return new BattlePrinter(printObject as Battle, world);
            if (printType == typeof(BeastAttack))
                return new BeastAttackPrinter(printObject as BeastAttack, world);
            if (printType == typeof(Entity))
                return new EntityPrinter(printObject as Entity, world);
            if (printType == typeof(Era))
                return new EraPrinter(printObject as Era);
            if (printType == typeof(HistoricalFigure))
                return new HistoricalFigureHTMLPrinter(printObject as HistoricalFigure, world);
            if (printType == typeof(WorldRegion))
                return new RegionPrinter(printObject as WorldRegion, world);
            if (printType == typeof(SiteConquered))
                return new SiteConqueredPrinter(printObject as SiteConquered, world);
            if (printType == typeof(Site))
                return new SitePrinter(printObject as Site, world);
            if (printType == typeof(UndergroundRegion))
                return new UndergroundRegionPrinter(printObject as UndergroundRegion, world);
            if (printType == typeof(War))
                return new WarPrinter(printObject as War, world);
            if (printType == typeof(World))
                return new WorldStatsPrinter(world);
            if (printType == typeof(Artifact))
                return new ArtifactPrinter(printObject as Artifact);
            if (printType == typeof(WorldContruction))
                return new WorldConstructionPrinter(printObject as WorldContruction);

            if (printType == typeof(string))
                return new StringPrinter(printObject as string);

            throw new Exception("No HTML Printer for type: " + printObject.GetType().ToString());
        }

 public XMLParser(World world, string xmlFile)
 {
     World = world;
     StreamReader reader = new StreamReader(xmlFile, Encoding.GetEncoding("windows-1252"));
     XML = new XmlTextReader(reader);
     XML.WhitespaceHandling = WhitespaceHandling.Significant;
 }

        public SiteConquered(List<Property> properties, World world)
            : base(properties, world)
        {
            Initialize();
            foreach (Property property in properties)
                switch (property.Name)
                {
                    case "ordinal": Ordinal = Convert.ToInt32(property.Value); break;
                    case "war_eventcol": ParentCollection = world.GetEventCollection(Convert.ToInt32(property.Value)); break;
                    case "site_id": Site = world.GetSite(Convert.ToInt32(property.Value)); break;
                    case "attacking_enid": Attacker = world.GetEntity(Convert.ToInt32(property.Value)); break;
                    case "defending_enid": Defender = world.GetEntity(Convert.ToInt32(property.Value)); break;
                }

            

            if (Collection.OfType<PlunderedSite>().Any()) ConquerType = SiteConqueredType.Pillaging;
            else if (Collection.OfType<DestroyedSite>().Any()) ConquerType = SiteConqueredType.Destruction;
            else if (Collection.OfType<NewSiteLeader>().Any() || Collection.OfType<SiteTakenOver>().Any()) ConquerType = SiteConqueredType.Conquest;
            else ConquerType = SiteConqueredType.Unknown;

            if (ConquerType == SiteConqueredType.Pillaging) Notable = false;

            Site.Warfare.Add(this);
            if (ParentCollection != null)
            {
                (ParentCollection as War).DeathCount += Collection.OfType<HFDied>().Count();

                if (Attacker == (ParentCollection as War).Attacker) 
                    (ParentCollection as War).AttackerVictories.Add(this);
                else 
                    (ParentCollection as War).DefenderVictories.Add(this);
            }

        }

 public EntityEntityLink(List<Property> properties, World world)
 {
     Type = EntityEntityLinkType.Unknown;
     foreach (Property property in properties)
     {
         switch (property.Name)
         {
             case "type":
                 switch (property.Value)
                 {
                     case "CHILD":
                         Type = EntityEntityLinkType.Child;
                         break;
                     case "PARENT":
                         Type = EntityEntityLinkType.Parent;
                         break;
                     default:
                         world.ParsingErrors.Report("Unknown Entity Entity Link Type: " + property.Value);
                         break;
                 }
                 break;
             case "target":
                 Target = world.GetEntity(Convert.ToInt32(property.Value));
                 break;
             case "strength":
                 Strength = Convert.ToInt32(property.Value);
                 break;
         }
     }
 }

        public BeastAttack(List<Property> properties, World world)
            : base(properties, world)
        {
            Initialize();

            foreach (Property property in properties)
                switch (property.Name)
                {
                    case "ordinal": Ordinal = Convert.ToInt32(property.Value); break;
                    case "coords": Coordinates = Formatting.ConvertToLocation(property.Value); break;
                    case "parent_eventcol": ParentCollection = world.GetEventCollection(Convert.ToInt32(property.Value)); break;
                    case "subregion_id": Region = world.GetRegion(Convert.ToInt32(property.Value)); break;
                    case "feature_layer_id": UndergroundRegion = world.GetUndergroundRegion(Convert.ToInt32(property.Value)); break;
                    case "site_id": Site = world.GetSite(Convert.ToInt32(property.Value)); break;
                    case "defending_enid": Defender = world.GetEntity(Convert.ToInt32(property.Value)); break;
                }

            Site.BeastAttacks.Add(this);

            //--------Attacking Beast is calculated after parsing event collections in ParseXML()
            //--------So that it can also look at eventsList from duel sub collections to calculate the Beast

            //-------Fill in some missing event details with details from collection
            //-------Filled in after parsing event collections in ParseXML()
        }

 public WorldContruction(List<Property> properties, World world)
     : base(properties, world)
 {
     Name = "Untitled";
     Coordinates = new List<Location>();
     foreach (Property property in properties)
     {
         switch (property.Name)
         {
             case "name": Name = Formatting.InitCaps(property.Value); break;
             case "type": Type = Formatting.InitCaps(property.Value); break;
             case "coords":
                 string[] coordinateStrings = property.Value.Split(new char[] { '|' },
                     StringSplitOptions.RemoveEmptyEntries);
                 foreach (var coordinateString in coordinateStrings)
                 {
                     string[] xYCoordinates = coordinateString.Split(',');
                     int x = Convert.ToInt32(xYCoordinates[0]);
                     int y = Convert.ToInt32(xYCoordinates[1]);
                     Coordinates.Add(new Location(x, y));
                 }
                 break;
         }
     }
 }

 public HTMLControl(object htmlObject, DwarfTabControl tabControl, World world)
 {
     World = world;
     HTMLObject = htmlObject;
     Printer = HTMLPrinter.GetPrinter(htmlObject, world);
     Title = Printer.GetTitle();
     TabControl = tabControl;
 }

 public Journey(List<Property> properties, World world)
     : base(properties, world)
 {
     foreach (Property property in properties)
         switch (property.Name)
         {
             case "ordinal": Ordinal = String.Intern(property.Value); break;
         }
 }

        public dlgHF(World world)
        {
            InitializeComponent();

            var hfByRace = world.HistoricalFigures.GroupBy(hf => hf.Race).Select(hf => hf.Key).OrderBy(hf => hf);
            foreach (var race in hfByRace)
            {
                listHFRaces.Items.Add(race);
            }
        }

 public WorldRegion(List<Property> properties, World world)
     : base(properties, world)
 {
     Battles = new List<Battle>();
     foreach(Property property in properties)
         switch(property.Name)
         {
             case "name": Name = Formatting.InitCaps(property.Value); break;
             case "type": Type = String.Intern(property.Value); break;
         }
 }