コード例 #1
0
        public void SetupInfrastructure()
        {
            var metadata = new ScenarioMetadata
            {
                FeatureName  = FeatureContext.FeatureInfo.Title,
                ScenarioName = ScenarioContext.ScenarioInfo.Title
            };

            Register(metadata);

            var factory = new PossumLabs.Specflow.Core.Variables.ObjectFactory();

            Register(factory);
            Register(new PossumLabs.Specflow.Core.Variables.Interpeter(factory));
            var logger = new DefaultLogger(new DirectoryInfo(Environment.CurrentDirectory));

            Register((PossumLabs.Specflow.Core.Logging.ILog)logger);
            Register(new PossumLabs.Specflow.Core.Exceptions.ActionExecutor(logger));

            Register(new FileManager(new DatetimeManager()
            {
                Now = () => DateTime.Now
            }));
            FileManager.Initialize(FeatureContext.FeatureInfo.Title, ScenarioContext.ScenarioInfo.Title, null /*Specflow limitation*/);
            var templateManager = new PossumLabs.Specflow.Core.Variables.TemplateManager();

            templateManager.Initialize(Assembly.GetExecutingAssembly());
            Register(templateManager);

            Log.Message($"feature: {FeatureContext.FeatureInfo.Title} scenario: {ScenarioContext.ScenarioInfo.Title} \n" +
                        $"Tags: {FeatureContext.FeatureInfo.Tags.LogFormat()} {ScenarioContext.ScenarioInfo.Tags.LogFormat()}");
        }
コード例 #2
0
        /// <summary>
        /// Loads a unit type definition from the given XML node.
        /// </summary>
        /// <param name="unitTypeElem">The XML node to load from.</param>
        /// <param name="metadata">The metadata object being constructed.</param>
        private static void LoadUnitType(XElement unitTypeElem, ScenarioMetadata metadata)
        {
            XAttribute nameAttr = unitTypeElem.Attribute(XmlMetadataConstants.TYPE_NAME_ATTR);

            if (nameAttr == null)
            {
                throw new SimulatorException("Unit type name not defined!");
            }

            UnitType unitType = new UnitType(nameAttr.Value, metadata);

            LoadScenarioElementType(unitTypeElem, unitType, metadata);

            XElement createdInElem = unitTypeElem.Element(XmlMetadataConstants.CREATEDIN_ELEM);

            if (createdInElem != null)
            {
                Tuple <string, string> createdIn = ParseBuildingAddonStr(createdInElem.Value);
                unitType.SetCreatedIn(createdIn.Item1);
                if (createdIn.Item2 != null)
                {
                    unitType.SetNecessaryAddonName(createdIn.Item2);
                }
            }

            metadata.AddUnitType(unitType);
        }
コード例 #3
0
        public MovieLogger(MovieLoggerConfig movieLoggerConfig, ScenarioMetadata scenarioMetadata)
        {
            ScenarioMetadata  = scenarioMetadata;
            MovieLoggerConfig = movieLoggerConfig;

            Stopwatch   = Stopwatch.StartNew();
            StepLogger  = new SrtLogger("step");
            OtherLogger = new SrtLogger("other");
            Images      = new List <Tuple <TimeSpan, byte[]> >();
        }
コード例 #4
0
        /// <summary>
        /// Loads a missile type definition from the given XML node.
        /// </summary>
        /// <param name="missileTypeElem">The XML node to load from.</param>
        /// <param name="metadata">The metadata object being constructed.</param>
        private static void LoadMissileType(XElement missileTypeElem, ScenarioMetadata metadata)
        {
            XAttribute nameAttr = missileTypeElem.Attribute(XmlMetadataConstants.TYPE_NAME_ATTR);

            if (nameAttr == null)
            {
                throw new SimulatorException("Missile type name not defined!");
            }

            MissileType missileType = new MissileType(nameAttr.Value, metadata);

            LoadScenarioElementType(missileTypeElem, missileType, metadata);

            XElement launchAnimElem = missileTypeElem.Element(XmlMetadataConstants.LAUNCHANIMATION_ELEM);

            if (launchAnimElem != null)
            {
                XAttribute launchDelayAttr = launchAnimElem.Attribute(XmlMetadataConstants.LAUNCH_DELAY_ATTR);
                if (launchDelayAttr == null)
                {
                    throw new SimulatorException("Launch delay not defined for missile type!");
                }
                int launchDelay = XmlHelper.LoadInt(launchDelayAttr.Value);
                missileType.SetLaunchAnimation(launchAnimElem.Value, launchDelay);
            }

            XElement flyingAnimElem = missileTypeElem.Element(XmlMetadataConstants.FLYINGANIMATION_ELEM);

            if (flyingAnimElem != null)
            {
                missileType.SetFlyingAnimation(flyingAnimElem.Value);
            }

            XElement trailAnimElem = missileTypeElem.Element(XmlMetadataConstants.TRAILANIMATION_ELEM);

            if (trailAnimElem != null)
            {
                XAttribute trailAnimFreqAttr = trailAnimElem.Attribute(XmlMetadataConstants.TRAILANIMATION_FREQUENCY_ATTR);
                if (trailAnimFreqAttr == null)
                {
                    throw new SimulatorException("Trail animation frequency not defined for missile type!");
                }
                int trailAnimFreq = XmlHelper.LoadInt(trailAnimFreqAttr.Value);
                missileType.SetTrailAnimation(trailAnimElem.Value, trailAnimFreq);
            }

            XElement impactAnimElem = missileTypeElem.Element(XmlMetadataConstants.IMPACTANIMATION_ELEM);

            if (impactAnimElem != null)
            {
                missileType.SetImpactAnimation(impactAnimElem.Value);
            }

            metadata.AddMissileType(missileType);
        }
コード例 #5
0
        /// <summary>
        /// Loads an upgrade effect definition from the given XML node.
        /// </summary>
        /// <param name="effectElem">The XML node to load from.</param>
        /// <param name="metadata">The metadata object.</param>
        /// <returns>The constructed upgrade effect definition.</returns>
        private static UpgradeEffectBase LoadUpgradeEffect(XElement effectElem, ScenarioMetadata metadata)
        {
            string     actionName     = effectElem.Name.ToString();
            XAttribute targetTypeAttr = effectElem.Attribute(XmlMetadataConstants.EFFECT_TARGETTYPE_ATTR);

            if (targetTypeAttr == null)
            {
                throw new SimulatorException("Target type not defined for an upgrade effect!");
            }

            return(UpgradeEffectFactory.CreateUpgradeEffect(actionName, effectElem.Value, targetTypeAttr.Value, metadata));
        }
コード例 #6
0
        /// <summary>
        /// Loads a building type definition from the given XML node.
        /// </summary>
        /// <param name="buildingTypeElem">The XML node to load from.</param>
        /// <param name="metadata">The metadata object being constructed.</param>
        private static void LoadBuildingType(XElement buildingTypeElem, ScenarioMetadata metadata)
        {
            XAttribute nameAttr = buildingTypeElem.Attribute(XmlMetadataConstants.TYPE_NAME_ATTR);

            if (nameAttr == null)
            {
                throw new SimulatorException("Building type name not defined!");
            }

            BuildingType buildingType = new BuildingType(nameAttr.Value, metadata);

            LoadScenarioElementType(buildingTypeElem, buildingType, metadata);

            metadata.AddBuildingType(buildingType);
        }
コード例 #7
0
        public void SetupInfrastructure()
        {
            var metadata = new ScenarioMetadata
            {
                FeatureName  = FeatureContext.FeatureInfo.Title,
                ScenarioName = ScenarioContext.ScenarioInfo.Title
            };

            Register(metadata);

            var factory = new PossumLabs.Specflow.Core.Variables.ObjectFactory();

            Register(factory);
            Register(new PossumLabs.Specflow.Core.Variables.Interpeter(factory));
            var logger = new DefaultLogger(new DirectoryInfo(Environment.CurrentDirectory));

            Register((PossumLabs.Specflow.Core.Logging.ILog)logger);

            IConfiguration config = new ConfigurationBuilder()
                                    .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
                                    .Build();

            var configFactory = new ConfigurationFactory(config);

            ObjectContainer.RegisterInstanceAs(configFactory.Create <MovieLoggerConfig>());
            ObjectContainer.RegisterInstanceAs(configFactory.Create <ImageLoggingConfig>());

            Register <ElementFactory>(new ElementFactory());
            Register <XpathProvider>(new XpathProvider());
            Register <SelectorFactory>(new SelectorFactory(ElementFactory, XpathProvider).UseBootstrap());

            Register(new PossumLabs.Specflow.Selenium.WebDriverManager(
                         this.Interpeter,
                         this.ObjectFactory,
                         new PossumLabs.Specflow.Selenium.Configuration.SeleniumGridConfiguration()));

            Log.Message($"feature: {FeatureContext.FeatureInfo.Title} scenario: {ScenarioContext.ScenarioInfo.Title} \n" +
                        $"Tags: {FeatureContext.FeatureInfo.Tags.LogFormat()} {ScenarioContext.ScenarioInfo.Tags.LogFormat()}");

            WebDriverManager.Initialize(BuildDriver);
        }
コード例 #8
0
        /// <summary>
        /// Loads an upgrade type definition from the given XML node.
        /// </summary>
        /// <param name="upgradeTypeElem">The XML node to load from.</param>
        /// <param name="metadata">The metadata object being constructed.</param>
        private static void LoadUpgradeType(XElement upgradeTypeElem, ScenarioMetadata metadata)
        {
            XAttribute nameAttr = upgradeTypeElem.Attribute(XmlMetadataConstants.TYPE_NAME_ATTR);

            if (nameAttr == null)
            {
                throw new SimulatorException("Upgrade type name not defined!");
            }

            UpgradeType upgradeType = new UpgradeType(nameAttr.Value, metadata);

            LoadScenarioElementType(upgradeTypeElem, upgradeType, metadata);

            XElement researchedInElem = upgradeTypeElem.Element(XmlMetadataConstants.RESEARCHEDIN_ELEM);

            if (researchedInElem != null)
            {
                upgradeType.SetResearchedIn(researchedInElem.Value);
            }

            XElement previousLevelElem = upgradeTypeElem.Element(XmlMetadataConstants.PREVIOUSLEVEL_ELEM);

            if (previousLevelElem != null)
            {
                upgradeType.SetPreviousLevelName(previousLevelElem.Value);
            }

            XElement effectsElem = upgradeTypeElem.Element(XmlMetadataConstants.EFFECTS_ELEM);

            if (effectsElem != null)
            {
                foreach (XElement effectElem in effectsElem.Elements())
                {
                    upgradeType.AddEffect(LoadUpgradeEffect(effectElem, metadata));
                }
            }

            metadata.AddUpgradeType(upgradeType);
        }
コード例 #9
0
        public void SetupInfrastructure()
        {
            var metadata = new ScenarioMetadata
            {
                FeatureName  = FeatureContext.FeatureInfo.Title,
                ScenarioName = ScenarioContext.ScenarioInfo.Title
            };

            Register(metadata);

            var factory = new PossumLabs.Specflow.Core.Variables.ObjectFactory();

            Register(factory);
            Register(new PossumLabs.Specflow.Core.Variables.Interpeter(factory));
            var logger = new DefaultLogger(new DirectoryInfo(Environment.CurrentDirectory));

            Register((PossumLabs.Specflow.Core.Logging.ILog)logger);

            var templateManager = new PossumLabs.Specflow.Core.Variables.TemplateManager();

            templateManager.Initialize(Assembly.GetExecutingAssembly());
            Register(templateManager);
        }
コード例 #10
0
        /// <summary>
        /// Loads an addon type definition from the given XML node.
        /// </summary>
        /// <param name="addonTypeElem">The XML node to load from.</param>
        /// <param name="metadata">The metadata object being constructed.</param>
        private static void LoadAddonType(XElement addonTypeElem, ScenarioMetadata metadata)
        {
            XAttribute nameAttr = addonTypeElem.Attribute(XmlMetadataConstants.TYPE_NAME_ATTR);

            if (nameAttr == null)
            {
                throw new SimulatorException("Addon type name not defined!");
            }

            AddonType addonType = new AddonType(nameAttr.Value, metadata);

            LoadScenarioElementType(addonTypeElem, addonType, metadata);

            XElement mainBuildingElem = addonTypeElem.Element(XmlMetadataConstants.MAINBUILDING_ELEM);

            if (mainBuildingElem == null)
            {
                throw new SimulatorException("Main building not found for addon type!");
            }
            addonType.SetMainBuilding(mainBuildingElem.Value);

            metadata.AddAddonType(addonType);
        }
コード例 #11
0
        /// <summary>
        /// Loads a missile definition from the given XML node.
        /// </summary>
        /// <param name="missileElem">The XML node to load from.</param>
        /// <param name="metadata">The metadata object.</param>
        /// <returns>The constructed missile definition.</returns>
        private static MissileData LoadMissileData(XElement missileElem, ScenarioMetadata metadata)
        {
            XAttribute missileTypeAttr = missileElem.Attribute(XmlMetadataConstants.WPN_MISSILE_TYPE_ATTR);

            if (missileTypeAttr == null)
            {
                throw new SimulatorException("Missile type not defined!");
            }

            MissileData missile = new MissileData(missileTypeAttr.Value, metadata);

            foreach (XElement launchElem in missileElem.Elements(XmlMetadataConstants.WPN_MISSILE_LAUNCH_ELEM))
            {
                XAttribute directionAttr = launchElem.Attribute(XmlMetadataConstants.WPN_MISSILE_LAUNCH_DIR_ATTR);
                XAttribute positionAttr  = launchElem.Attribute(XmlMetadataConstants.WPN_MISSILE_LAUNCH_POS_ATTR);
                if (directionAttr == null)
                {
                    throw new SimulatorException("Direction not defined for missile data launch position!");
                }
                if (positionAttr == null)
                {
                    throw new SimulatorException("Relative position not defined for missile data launch position!");
                }

                MapDirection direction;
                if (!EnumMap <MapDirection, string> .TryDemap(directionAttr.Value, out direction))
                {
                    throw new SimulatorException(string.Format("Unexpected MapDirection '{0}' defined in missile data!", directionAttr.Value));
                }

                RCNumVector relativePosition = XmlHelper.LoadNumVector(positionAttr.Value);
                missile.AddRelativeLaunchPosition(direction, relativePosition);
            }

            return(missile);
        }
コード例 #12
0
ファイル: ActionExecutor.cs プロジェクト: Possum-Labs/DSL
 public ActionExecutor(ILog logger, ScenarioMetadata metadata)
 {
     Logger            = logger;
     Metadata          = metadata;
     IgnoredExceptions = new List <Exception>();
 }
コード例 #13
0
        /// <summary>
        /// Loads the weapon data of a building/unit type from the given element.
        /// </summary>
        /// <param name="weaponDataElem">The XML element to load from.</param>
        /// <param name="metadata">The metadata object.</param>
        private static WeaponData LoadWeaponData(XElement weaponDataElem, ScenarioMetadata metadata)
        {
            XAttribute nameAttr          = weaponDataElem.Attribute(XmlMetadataConstants.WPN_NAME_ATTR);
            XAttribute displayedNameAttr = weaponDataElem.Attribute(XmlMetadataConstants.WPN_DISPLAYEDNAME_ATTR);
            XElement   cooldownElem      = weaponDataElem.Element(XmlMetadataConstants.WPN_COOLDOWN_ELEM);
            XElement   damageElem        = weaponDataElem.Element(XmlMetadataConstants.WPN_DAMAGE_ELEM);
            XElement   damageTypeElem    = weaponDataElem.Element(XmlMetadataConstants.WPN_DAMAGETYPE_ELEM);
            XElement   incrementElem     = weaponDataElem.Element(XmlMetadataConstants.WPN_INCREMENT_ELEM);
            XElement   rangeMaxElem      = weaponDataElem.Element(XmlMetadataConstants.WPN_RANGEMAX_ELEM);
            XElement   rangeMinElem      = weaponDataElem.Element(XmlMetadataConstants.WPN_RANGEMIN_ELEM);
            XElement   splashTypeElem    = weaponDataElem.Element(XmlMetadataConstants.WPN_SPLASHTYPE_ELEM);

            if (nameAttr == null)
            {
                throw new SimulatorException("Weapon name not defined!");
            }

            WeaponTypeEnum weaponType;

            if (!EnumMap <WeaponTypeEnum, string> .TryDemap(weaponDataElem.Name.LocalName, out weaponType))
            {
                throw new SimulatorException(string.Format("Unexpected weapon type '{0}' defined in weapon data!", weaponDataElem.Name.LocalName));
            }

            WeaponData weaponData = new WeaponData(nameAttr.Value, metadata, weaponType);

            if (cooldownElem != null)
            {
                weaponData.SetCooldown(XmlHelper.LoadInt(cooldownElem.Value));
            }
            if (damageElem != null)
            {
                weaponData.SetDamage(XmlHelper.LoadInt(damageElem.Value));
            }
            if (rangeMaxElem != null)
            {
                weaponData.SetRangeMax(XmlHelper.LoadInt(rangeMaxElem.Value));
            }

            if (damageTypeElem != null)
            {
                DamageTypeEnum damageType;
                if (!EnumMap <DamageTypeEnum, string> .TryDemap(damageTypeElem.Value, out damageType))
                {
                    throw new SimulatorException(string.Format("Unexpected damage type '{0}' defined in weapon data!", damageTypeElem.Value));
                }
                weaponData.SetDamageType(damageType);
            }

            if (displayedNameAttr != null)
            {
                weaponData.SetDisplayedName(displayedNameAttr.Value);
            }
            if (incrementElem != null)
            {
                weaponData.SetIncrement(XmlHelper.LoadInt(incrementElem.Value));
            }
            if (rangeMinElem != null)
            {
                weaponData.SetRangeMin(XmlHelper.LoadInt(rangeMinElem.Value));
            }
            if (splashTypeElem != null)
            {
                SplashTypeEnum splashType;
                if (!EnumMap <SplashTypeEnum, string> .TryDemap(splashTypeElem.Value, out splashType))
                {
                    throw new SimulatorException(string.Format("Unexpected splash type '{0}' defined in weapon data!", splashTypeElem.Value));
                }
                weaponData.SetSplashType(splashType);
            }

            foreach (XElement missileElem in weaponDataElem.Elements(XmlMetadataConstants.WPN_MISSILE_ELEM))
            {
                weaponData.AddMissile(LoadMissileData(missileElem, metadata));
            }

            return(weaponData);
        }
コード例 #14
0
        /// <summary>
        /// Loads an animation palette definition from the given XML node.
        /// </summary>
        /// <param name="animPaletteElem">The XML node to load from.</param>
        /// <param name="metadata">The metadata object.</param>
        /// <param name="spritePalette">The sprite palette that the animation palette is based on.</param>
        /// <returns>The constructed animation palette definition.</returns>
        private static AnimationPalette LoadAnimationPalette(XElement animPaletteElem, ISpritePalette <MapDirection> spritePalette, ScenarioMetadata metadata)
        {
            /// Create the animation palette object.
            AnimationPalette animPalette = new AnimationPalette(metadata);

            /// Load the animations.
            foreach (XElement animElem in animPaletteElem.Elements(XmlMetadataConstants.ANIMATION_ELEM))
            {
                Animation animation = LoadAnimation(animElem, animPalette.Count, spritePalette);
                animPalette.AddAnimation(animation);
            }
            return(animPalette);
        }
コード例 #15
0
        /// <summary>
        /// Loads the necessary data of a scenario element type.
        /// </summary>
        /// <param name="elementTypeElem">The XML node to load from.</param>
        /// <param name="elementType">The scenario element type being constructed.</param>
        /// <param name="metadata">The metadata object.</param>
        private static void LoadScenarioElementType(XElement elementTypeElem, ScenarioElementType elementType, ScenarioMetadata metadata)
        {
            /// Load the displayed name of the element type.
            XAttribute displayedNameAttr = elementTypeElem.Attribute(XmlMetadataConstants.TYPE_DISPLAYEDNAME_ATTR);

            if (displayedNameAttr != null)
            {
                elementType.SetDisplayedName(displayedNameAttr.Value);
            }

            /// Load the has owner flag of the element type.
            XAttribute hasOwnerAttr = elementTypeElem.Attribute(XmlMetadataConstants.TYPE_HASOWNER_ATTR);

            elementType.SetHasOwner(hasOwnerAttr != null && XmlHelper.LoadBool(hasOwnerAttr.Value));

            /// Load the sprite palette of the element type.
            XElement spritePaletteElem = elementTypeElem.Element(XmlMetadataConstants.SPRITEPALETTE_ELEM);
            ISpritePalette <MapDirection> spritePalette = null;

            if (spritePaletteElem != null)
            {
                spritePalette = XmlHelper.LoadSpritePalette(spritePaletteElem, MapDirection.Undefined, tmpImageDir);
                elementType.SetSpritePalette(spritePalette);
            }

            /// Load the HP indicator icon palette of this element type.
            XElement hpIconPaletteElem = elementTypeElem.Element(XmlMetadataConstants.HPICONPALETTE_ELEM);

            if (hpIconPaletteElem != null)
            {
                ISpritePalette hpIconPalette = XmlHelper.LoadSpritePalette(hpIconPaletteElem, tmpImageDir);
                elementType.SetHPIconPalette(hpIconPalette);
            }

            /// Load the animation palette of the element type.
            XElement animPaletteElem = elementTypeElem.Element(XmlMetadataConstants.ANIMPALETTE_ELEM);

            if (animPaletteElem != null)
            {
                if (spritePalette == null)
                {
                    throw new SimulatorException("Animation palette definition requires a sprite palette definition!");
                }
                elementType.SetAnimationPalette(LoadAnimationPalette(animPaletteElem, spritePalette, metadata));
            }

            /// Load the cost data of the element type.
            XElement costsDataElem = elementTypeElem.Element(XmlMetadataConstants.COSTS_ELEM);

            if (costsDataElem != null)
            {
                LoadCostsData(costsDataElem, elementType);
            }

            /// Load the general data of the element type.
            XElement genDataElem = elementTypeElem.Element(XmlMetadataConstants.GENERALDATA_ELEM);

            if (genDataElem != null)
            {
                LoadGeneralData(genDataElem, elementType);
            }

            /// Load the shadow data of the element type.
            XElement shadowDataElem = elementTypeElem.Element(XmlMetadataConstants.SHADOWDATA_ELEM);

            if (shadowDataElem != null)
            {
                LoadShadowData(shadowDataElem, elementType);
            }

            /// Load the ground weapon definitions of the element type.
            foreach (XElement gndWeaponElem in elementTypeElem.Elements(XmlMetadataConstants.GROUNDWEAPON_ELEM))
            {
                elementType.AddWeapon(LoadWeaponData(gndWeaponElem, metadata));
            }

            /// Load the air weapon definitions of the element type.
            foreach (XElement airWeaponElem in elementTypeElem.Elements(XmlMetadataConstants.AIRWEAPON_ELEM))
            {
                elementType.AddWeapon(LoadWeaponData(airWeaponElem, metadata));
            }

            /// Load the air-ground weapon definitions of the element type.
            foreach (XElement airGroundWeaponElem in elementTypeElem.Elements(XmlMetadataConstants.AIRGROUNDWEAPON_ELEM))
            {
                elementType.AddWeapon(LoadWeaponData(airGroundWeaponElem, metadata));
            }

            /// Load the custom weapon definitions of the element type.
            foreach (XElement customWeaponElem in elementTypeElem.Elements(XmlMetadataConstants.CUSTOMWEAPON_ELEM))
            {
                elementType.AddWeapon(LoadWeaponData(customWeaponElem, metadata));
            }

            /// Load the requirements of the element type.
            XElement requiresElem = elementTypeElem.Element(XmlMetadataConstants.REQUIRES_ELEM);

            if (requiresElem != null)
            {
                string   reqListStr         = requiresElem.Value.Trim();
                string[] requirementStrings = reqListStr.Split(',');
                foreach (string reqStr in requirementStrings)
                {
                    Tuple <string, string> buildingAddonPair = ParseBuildingAddonStr(reqStr);
                    elementType.AddRequirement(new Requirement(buildingAddonPair.Item1, buildingAddonPair.Item2, metadata));
                }
            }
        }
コード例 #16
0
        /// <summary>
        /// Reads metadata from the given XML document and loads it to the given metadata object.
        /// </summary>
        /// <param name="xmlStr">The string that contains the XML document to read.</param>
        /// <param name="imageDir">The directory where the referenced images can be found. (TODO: this is a hack!)</param>
        /// <param name="metadata">Reference to the metadata object being constructed.</param>
        public static void Read(string xmlStr, string imageDir, ScenarioMetadata metadata)
        {
            if (xmlStr == null)
            {
                throw new ArgumentNullException("xmlStr");
            }
            if (imageDir == null)
            {
                throw new ArgumentNullException("imageDir");
            }
            if (metadata == null)
            {
                throw new ArgumentNullException("metadata");
            }

            tmpImageDir = imageDir;

            /// Load the XML document.
            XDocument xmlDoc = XDocument.Parse(xmlStr);

            /// Load the scenario element type definitions.
            foreach (XElement metadataElement in xmlDoc.Root.Elements())
            {
                if (metadataElement.Name == XmlMetadataConstants.BUILDINGTYPE_ELEM)
                {
                    LoadBuildingType(metadataElement, metadata);
                }
                else if (metadataElement.Name == XmlMetadataConstants.UNITTYPE_ELEM)
                {
                    LoadUnitType(metadataElement, metadata);
                }
                else if (metadataElement.Name == XmlMetadataConstants.ADDONTYPE_ELEM)
                {
                    LoadAddonType(metadataElement, metadata);
                }
                else if (metadataElement.Name == XmlMetadataConstants.UPGRADETYPE_ELEM)
                {
                    LoadUpgradeType(metadataElement, metadata);
                }
                else if (metadataElement.Name == XmlMetadataConstants.MISSILETYPE_ELEM)
                {
                    LoadMissileType(metadataElement, metadata);
                }
                else if (metadataElement.Name == XmlMetadataConstants.CUSTOMTYPE_ELEM)
                {
                    XAttribute nameAttr = metadataElement.Attribute(XmlMetadataConstants.TYPE_NAME_ATTR);
                    if (nameAttr == null)
                    {
                        throw new SimulatorException("Custom type name not defined!");
                    }

                    ScenarioElementType elementType = new ScenarioElementType(nameAttr.Value, metadata);
                    LoadScenarioElementType(metadataElement, elementType, metadata);
                    metadata.AddCustomType(elementType);
                }
                else if (metadataElement.Name == XmlMetadataConstants.SHADOWPALETTE_ELEM)
                {
                    metadata.SetShadowPalette(XmlHelper.LoadSpritePalette(metadataElement, imageDir));
                }
            }
        }
コード例 #17
0
 /// <summary>
 /// Helper to get the <see cref="Scenario"/> Name (defined in <see cref="ScenarioMetadata"/>)
 /// </summary>
 /// <returns></returns>
 public string GetName() => ScenarioMetadata.GetName(this.GetType());
コード例 #18
0
 /// <summary>
 /// Helper to get the <see cref="Scenario"/> Description (defined in <see cref="ScenarioMetadata"/>)
 /// </summary>
 /// <returns></returns>
 public string GetDescription() => ScenarioMetadata.GetDescription(this.GetType());