Fixed bugs where parsing hero abilities was sort of broken. Added support for hero ability requires scepter.

Justin · Justin · commit a1cccdd97659 · 2020-05-01T12:02:08.000-04:00
diff --git a/src/SourceSchemaParser/DOTA2/DotaAbilitySpecialSchemaItem.cs b/src/SourceSchemaParser/DOTA2/DotaAbilitySpecialSchemaItem.cs
@@ -6,5 +6,6 @@ internal class DotaAbilitySpecialSchemaItem
         public string Value { get; set; }
         public string VarType { get; set; }
         public string LinkedSpecialBonus { get; set; }
+        public bool RequiresScepter { get; set; }
     }
 }
diff --git a/src/SourceSchemaParser/DotaSchemaMapperProfile.cs b/src/SourceSchemaParser/DotaSchemaMapperProfile.cs
@@ -8,27 +8,26 @@ public class DotaSchemaMapperProfile : Profile
     {
         public DotaSchemaMapperProfile()
         {
-            CreateMap<DotaHeroSchemaItem, HeroSchemaModel>();
-            CreateMap<DotaSchema, Steam.Models.DOTA2.SchemaModel>();
-            CreateMap<DotaSchemaGameInfo, SchemaGameInfoModel>();
-            CreateMap<DotaSchemaRarity, SchemaRarityModel>();
-            CreateMap<DotaSchemaColor, SchemaColorModel>();
-            CreateMap<DotaSchemaItem, Steam.Models.DOTA2.SchemaItemModel>();
-            CreateMap<DotaSchemaPrefab, SchemaPrefabModel>();
-            CreateMap<DotaSchemaItemSet, Steam.Models.DOTA2.SchemaItemSetModel>();
-            CreateMap<DotaSchemaPrefab, SchemaPrefabModel>();
-            CreateMap<DotaSchemaItemAutograph, SchemaItemAutographModel>();
-            CreateMap<DotaSchemaQuality, SchemaQualityModel>();
-            CreateMap<DotaSchemaPrefabCapability, SchemaPrefabCapabilityModel>();
-            CreateMap<DotaSchemaItemTool, SchemaItemToolModel>();
-            CreateMap<DotaSchemaItemToolUsage, SchemaItemToolUsageModel>();
-            CreateMap<DotaSchemaItemPriceInfo, SchemaItemPriceInfoModel>();
-            CreateMap<DotaSchemaItemStaticAttribute, SchemaItemStaticAttributeModel>();
-            CreateMap<DotaItemAbilitySchemaItem, ItemAbilitySchemaItemModel>();
-            CreateMap<DotaAbilitySpecialSchemaItem, AbilitySpecialSchemaItemModel>();
-            CreateMap<DotaAbilitySchemaItem, AbilitySchemaItemModel>();
-            CreateMap<DotaItemBuildSchemaItem, ItemBuildSchemaItemModel>();
-            CreateMap<DotaItemBuildGroupSchemaItem, ItemBuildGroupSchemaItemModel>();
+            CreateMap<DotaHeroSchemaItem, Hero>();
+            CreateMap<DotaSchema, Schema>();
+            CreateMap<DotaSchemaGameInfo, SchemaGameInfo>();
+            CreateMap<DotaSchemaRarity, SchemaRarity>();
+            CreateMap<DotaSchemaColor, SchemaColor>();
+            CreateMap<DotaSchemaItem, SchemaItem>();
+            CreateMap<DotaSchemaPrefab, SchemaPrefab>();
+            CreateMap<DotaSchemaItemSet, SchemaItemSet>();
+            CreateMap<DotaSchemaItemAutograph, SchemaItemAutograph>();
+            CreateMap<DotaSchemaQuality, SchemaQuality>();
+            CreateMap<DotaSchemaPrefabCapability, SchemaPrefabCapability>();
+            CreateMap<DotaSchemaItemTool, SchemaItemTool>();
+            CreateMap<DotaSchemaItemToolUsage, SchemaItemToolUsage>();
+            CreateMap<DotaSchemaItemPriceInfo, SchemaItemPriceInfo>();
+            CreateMap<DotaSchemaItemStaticAttribute, SchemaItemStaticAttribute>();
+            CreateMap<DotaItemAbilitySchemaItem, ItemAbility>();
+            CreateMap<DotaAbilitySpecialSchemaItem, HeroAbilitySpecial>();
+            CreateMap<DotaAbilitySchemaItem, HeroAbility>();
+            CreateMap<DotaItemBuildSchemaItem, ItemBuild>();
+            CreateMap<DotaItemBuildGroupSchemaItem, ItemBuildGroup>();
             CreateMap<DotaLeague, LeagueModel>();
         }
     }
diff --git a/src/SourceSchemaParser/ISchemaParser.cs b/src/SourceSchemaParser/ISchemaParser.cs
@@ -5,15 +5,15 @@ namespace SourceSchemaParser
 {
     public interface ISchemaParser
     {
-        IReadOnlyCollection<AbilitySchemaItemModel> GetDotaHeroAbilities(IEnumerable<string> vdf);
-        IReadOnlyCollection<HeroSchemaModel> GetDotaHeroes(IEnumerable<string> vdf);
-        IReadOnlyCollection<ItemAbilitySchemaItemModel> GetDotaItemAbilities(IEnumerable<string> vdf);
-        ItemBuildSchemaItemModel GetDotaItemBuild(IEnumerable<string> vdf);
-        IReadOnlyCollection<SchemaPrefabModel> GetDotaItemPrefabs(IEnumerable<string> vdf);
+        IReadOnlyCollection<HeroAbility> GetDotaHeroAbilities(IEnumerable<string> vdf);
+        IReadOnlyCollection<Hero> GetDotaHeroes(IEnumerable<string> vdf);
+        IReadOnlyCollection<ItemAbility> GetDotaItemAbilities(IEnumerable<string> vdf);
+        ItemBuild GetDotaItemBuild(IEnumerable<string> vdf);
+        IReadOnlyCollection<SchemaPrefab> GetDotaItemPrefabs(IEnumerable<string> vdf);
         IReadOnlyCollection<LeagueModel> GetDotaLeaguesFromFile(string itemSchemaFilePath, string localizationFilePath);
         IReadOnlyCollection<LeagueModel> GetDotaLeaguesFromText(IEnumerable<string> itemSchemaVdfText, IEnumerable<string> localizationVdfText);
         IReadOnlyDictionary<string, string> GetDotaPanoramaLocalizationKeys(IEnumerable<string> vdf);
         IReadOnlyDictionary<string, string> GetDotaPublicLocalizationKeys(IEnumerable<string> vdf);
-        SchemaModel GetDotaSchema(IEnumerable<string> vdf);
+        Schema GetDotaSchema(IEnumerable<string> vdf);
     }
 }
diff --git a/src/SourceSchemaParser/JsonConverters/DotaAbilitySpecialSchemaItemJsonConverter.cs b/src/SourceSchemaParser/JsonConverters/DotaAbilitySpecialSchemaItemJsonConverter.cs
@@ -36,8 +36,11 @@ public override object ReadJson(JsonReader reader, Type objectType, object exist
                     continue;
                 }
 
-                string currentVarType = String.Empty;
-                string currentLinkedSpecialBonus = String.Empty;
+                string abilityName = string.Empty;
+                string abilityValue = string.Empty;
+                string abilityVarType = string.Empty;
+                string abilityLinkedSpecialBonus = string.Empty;
+                bool abilityRequiresScepter = false;
 
                 // we need to go through all the actual values of the special properties
                 var abilitySpecialIndividualProperties = abilitySpecialProperty.Value.Children<JProperty>();
@@ -47,26 +50,38 @@ public override object ReadJson(JsonReader reader, Type objectType, object exist
                     // record the var_type of this special
                     if (abilitySpecialIndividualProperty.Name == "var_type")
                     {
-                        currentVarType = abilitySpecialIndividualProperty.Value.ToString();
-                        continue;
+                        abilityVarType = abilitySpecialIndividualProperty.Value.ToString();
                     }
-
-                    if (abilitySpecialIndividualProperty.Name == "LinkedSpecialBonus")
+                    else if (abilitySpecialIndividualProperty.Name == "LinkedSpecialBonus")
                     {
-                        currentLinkedSpecialBonus = abilitySpecialIndividualProperty.Value.ToString();
-                        continue;
+                        abilityLinkedSpecialBonus = abilitySpecialIndividualProperty.Value.ToString();
                     }
-
-                    // construct the special attribute
-                    DotaAbilitySpecialSchemaItem abilitySpecial = new DotaAbilitySpecialSchemaItem()
+                    else if (abilitySpecialIndividualProperty.Name == "RequiresScepter")
                     {
-                        Name = abilitySpecialIndividualProperty.Name,
-                        Value = abilitySpecialIndividualProperty.Value.ToString(),
-                        VarType = currentVarType
-                    };
-
-                    abilitySpecials.Add(abilitySpecial);
+                        abilityRequiresScepter = abilitySpecialIndividualProperty.Value.ToString() == "1";
+                    }
+                    else if (abilitySpecialProperty.Name == "LinkedSpecialBonusOperation")
+                    {
+                        // no op until we want to handle this
+                    }
+                    else
+                    {
+                        abilityName = abilitySpecialIndividualProperty.Name;
+                        abilityValue = abilitySpecialIndividualProperty.Value.ToString();
+                    }
                 }
+
+                // construct the special attribute
+                DotaAbilitySpecialSchemaItem abilitySpecial = new DotaAbilitySpecialSchemaItem()
+                {
+                    Name = abilityName,
+                    Value = abilityValue,
+                    VarType = abilityVarType,
+                    LinkedSpecialBonus = abilityLinkedSpecialBonus,
+                    RequiresScepter = abilityRequiresScepter
+                };
+
+                abilitySpecials.Add(abilitySpecial);
             }
 
             return abilitySpecials;
diff --git a/src/SourceSchemaParser/SchemaParser.cs b/src/SourceSchemaParser/SchemaParser.cs
@@ -26,15 +26,15 @@ public SchemaParser(IVDFConvert vdfConvert, IMapper mapper)
 
         #region Dota Main Item Schema
 
-        public SchemaModel GetDotaSchema(IEnumerable<string> vdf)
+        public Schema GetDotaSchema(IEnumerable<string> vdf)
         {
             ValidateInput(vdf);
 
             var schemaContainer = vdfConvert.DeserializeObject<DotaSchemaContainer>(vdf.ToList());
-            return mapper.Map<DotaSchema, SchemaModel>(schemaContainer.Schema);
+            return mapper.Map<DotaSchema, Schema>(schemaContainer.Schema);
         }
 
-        public IReadOnlyCollection<ItemAbilitySchemaItemModel> GetDotaItemAbilities(IEnumerable<string> vdf)
+        public IReadOnlyCollection<ItemAbility> GetDotaItemAbilities(IEnumerable<string> vdf)
         {
             ValidateInput(vdf);
 
@@ -44,8 +44,8 @@ public IReadOnlyCollection<ItemAbilitySchemaItemModel> GetDotaItemAbilities(IEnu
             if (schema.TryGetValue("DOTAAbilities", out item))
             {
                 var itemAbilities = JsonConvert.DeserializeObject<IList<DotaItemAbilitySchemaItem>>(item.ToString(), new SchemaItemToDotaItemAbilityJsonConverter());
-                var itemAbilityModels = mapper.Map<IList<DotaItemAbilitySchemaItem>, IList<ItemAbilitySchemaItemModel>>(itemAbilities);
-                return new ReadOnlyCollection<ItemAbilitySchemaItemModel>(itemAbilityModels);
+                var itemAbilityModels = mapper.Map<IList<DotaItemAbilitySchemaItem>, IList<ItemAbility>>(itemAbilities);
+                return new ReadOnlyCollection<ItemAbility>(itemAbilityModels);
             }
             else
             {
@@ -75,7 +75,7 @@ public IReadOnlyDictionary<string, string> GetDotaPublicLocalizationKeys(IEnumer
 
         #region Dota Heroes
 
-        public IReadOnlyCollection<AbilitySchemaItemModel> GetDotaHeroAbilities(IEnumerable<string> vdf)
+        public IReadOnlyCollection<HeroAbility> GetDotaHeroAbilities(IEnumerable<string> vdf)
         {
             ValidateInput(vdf);
 
@@ -85,16 +85,16 @@ public IReadOnlyCollection<AbilitySchemaItemModel> GetDotaHeroAbilities(IEnumera
             if (schema.TryGetValue("DOTAAbilities", out item))
             {
                 var abilities = JsonConvert.DeserializeObject<IList<DotaAbilitySchemaItem>>(item.ToString(), new SchemaItemToDotaAbilityJsonConverter());
-                var abilityModels = mapper.Map<IList<DotaAbilitySchemaItem>, IList<AbilitySchemaItemModel>>(abilities);
-                return new ReadOnlyCollection<AbilitySchemaItemModel>(abilityModels);
+                var abilityModels = mapper.Map<IList<DotaAbilitySchemaItem>, IList<HeroAbility>>(abilities);
+                return new ReadOnlyCollection<HeroAbility>(abilityModels);
             }
             else
             {
                 throw new ArgumentException("You supplied a VDF file, but it wasn't the expected Dota Heroes Abilities schema file.");
             }
         }
 
-        public IReadOnlyCollection<HeroSchemaModel> GetDotaHeroes(IEnumerable<string> vdf)
+        public IReadOnlyCollection<Hero> GetDotaHeroes(IEnumerable<string> vdf)
         {
             ValidateInput(vdf);
 
@@ -104,16 +104,16 @@ public IReadOnlyCollection<HeroSchemaModel> GetDotaHeroes(IEnumerable<string> vd
             if (schema.TryGetValue("DOTAHeroes", out item))
             {
                 var heroes = JsonConvert.DeserializeObject<IList<DotaHeroSchemaItem>>(item.ToString(), new SchemaItemToDotaHeroJsonConverter());
-                var heroModels = mapper.Map<IList<DotaHeroSchemaItem>, IList<HeroSchemaModel>>(heroes);
-                return new ReadOnlyCollection<HeroSchemaModel>(heroModels);
+                var heroModels = mapper.Map<IList<DotaHeroSchemaItem>, IList<Hero>>(heroes);
+                return new ReadOnlyCollection<Hero>(heroModels);
             }
             else
             {
                 throw new ArgumentException("You supplied a VDF file, but it wasn't the expected Dota Heroes schema file.");
             }
         }
 
-        public ItemBuildSchemaItemModel GetDotaItemBuild(IEnumerable<string> vdf)
+        public ItemBuild GetDotaItemBuild(IEnumerable<string> vdf)
         {
             ValidateInput(vdf);
 
@@ -123,7 +123,7 @@ public ItemBuildSchemaItemModel GetDotaItemBuild(IEnumerable<string> vdf)
             if (schema.TryGetValue("itembuilds", out item))
             {
                 var itemBuild = item.ToObject<DotaItemBuildSchemaItem>();
-                var itemBuildModel = mapper.Map<DotaItemBuildSchemaItem, ItemBuildSchemaItemModel>(itemBuild);
+                var itemBuildModel = mapper.Map<DotaItemBuildSchemaItem, ItemBuild>(itemBuild);
                 return itemBuildModel;
             }
             else
@@ -238,7 +238,7 @@ private IReadOnlyCollection<DotaLeague> FlattenDotaSchemaItemLeagues(IReadOnlyCo
 
         #endregion
 
-        public IReadOnlyCollection<SchemaPrefabModel> GetDotaItemPrefabs(IEnumerable<string> vdf)
+        public IReadOnlyCollection<SchemaPrefab> GetDotaItemPrefabs(IEnumerable<string> vdf)
         {
             ValidateInput(vdf);
 
@@ -253,9 +253,9 @@ public IReadOnlyCollection<SchemaPrefabModel> GetDotaItemPrefabs(IEnumerable<str
 
                     var prefabs = JsonConvert.DeserializeObject<IList<DotaSchemaPrefab>>(item.ToString(), new DotaSchemaPrefabJsonConverter());
 
-                    var prefabModels = mapper.Map<IList<DotaSchemaPrefab>, IList<SchemaPrefabModel>>(prefabs);
+                    var prefabModels = mapper.Map<IList<DotaSchemaPrefab>, IList<SchemaPrefab>>(prefabs);
 
-                    return new ReadOnlyCollection<SchemaPrefabModel>(prefabModels);
+                    return new ReadOnlyCollection<SchemaPrefab>(prefabModels);
                 }
                 else
                 {
diff --git a/src/SourceSchemaParser/SourceSchemaParser.csproj b/src/SourceSchemaParser/SourceSchemaParser.csproj
@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <Description>Parses Valve Source Engine game schema files into easy to use object oriented structures.</Description>
-    <VersionPrefix>3.0.3</VersionPrefix>
+    <VersionPrefix>3.1.0</VersionPrefix>
     <Authors>Justin Skiles</Authors>
     <AssemblyName>SourceSchemaParser</AssemblyName>
     <PackageId>SourceSchemaParser</PackageId>
@@ -14,7 +14,7 @@
   <ItemGroup>
     <PackageReference Include="automapper" Version="9.0.0" />
     <PackageReference Include="newtonsoft.json" Version="12.0.3" />
-    <PackageReference Include="SteamWebAPI2" Version="4.1.3" />
+    <PackageReference Include="SteamWebAPI2" Version="4.2.0" />
 		<PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="3.1.3" />
   </ItemGroup>
 

Original file line number	Diff line number	Diff line change
`@@ -6,5 +6,6 @@ internal class DotaAbilitySpecialSchemaItem`
`6`	`6`	`public string Value { get; set; }`
`7`	`7`	`public string VarType { get; set; }`
`8`	`8`	`public string LinkedSpecialBonus { get; set; }`
	`9`	`+ public bool RequiresScepter { get; set; }`
`9`	`10`	`}`
`10`	`11`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5,15 +5,15 @@ namespace SourceSchemaParser`
`5`	`5`	`{`
`6`	`6`	`public interface ISchemaParser`
`7`	`7`	`{`
`8`		`- IReadOnlyCollection<AbilitySchemaItemModel> GetDotaHeroAbilities(IEnumerable<string> vdf);`
`9`		`- IReadOnlyCollection<HeroSchemaModel> GetDotaHeroes(IEnumerable<string> vdf);`
`10`		`- IReadOnlyCollection<ItemAbilitySchemaItemModel> GetDotaItemAbilities(IEnumerable<string> vdf);`
`11`		`- ItemBuildSchemaItemModel GetDotaItemBuild(IEnumerable<string> vdf);`
`12`		`- IReadOnlyCollection<SchemaPrefabModel> GetDotaItemPrefabs(IEnumerable<string> vdf);`
	`8`	`+ IReadOnlyCollection<HeroAbility> GetDotaHeroAbilities(IEnumerable<string> vdf);`
	`9`	`+ IReadOnlyCollection<Hero> GetDotaHeroes(IEnumerable<string> vdf);`
	`10`	`+ IReadOnlyCollection<ItemAbility> GetDotaItemAbilities(IEnumerable<string> vdf);`
	`11`	`+ ItemBuild GetDotaItemBuild(IEnumerable<string> vdf);`
	`12`	`+ IReadOnlyCollection<SchemaPrefab> GetDotaItemPrefabs(IEnumerable<string> vdf);`
`13`	`13`	`IReadOnlyCollection<LeagueModel> GetDotaLeaguesFromFile(string itemSchemaFilePath, string localizationFilePath);`
`14`	`14`	`IReadOnlyCollection<LeagueModel> GetDotaLeaguesFromText(IEnumerable<string> itemSchemaVdfText, IEnumerable<string> localizationVdfText);`
`15`	`15`	`IReadOnlyDictionary<string, string> GetDotaPanoramaLocalizationKeys(IEnumerable<string> vdf);`
`16`	`16`	`IReadOnlyDictionary<string, string> GetDotaPublicLocalizationKeys(IEnumerable<string> vdf);`
`17`		`- SchemaModel GetDotaSchema(IEnumerable<string> vdf);`
	`17`	`+ Schema GetDotaSchema(IEnumerable<string> vdf);`
`18`	`18`	`}`
`19`	`19`	`}`
Original file line number	Diff line number	Diff line change
`@@ -26,15 +26,15 @@ public SchemaParser(IVDFConvert vdfConvert, IMapper mapper)`
`26`	`26`
`27`	`27`	`#region Dota Main Item Schema`
`28`	`28`
`29`		`- public SchemaModel GetDotaSchema(IEnumerable<string> vdf)`
	`29`	`+ public Schema GetDotaSchema(IEnumerable<string> vdf)`
`30`	`30`	`{`
`31`	`31`	`ValidateInput(vdf);`
`32`	`32`
`33`	`33`	`var schemaContainer = vdfConvert.DeserializeObject<DotaSchemaContainer>(vdf.ToList());`
`34`		`- return mapper.Map<DotaSchema, SchemaModel>(schemaContainer.Schema);`
	`34`	`+ return mapper.Map<DotaSchema, Schema>(schemaContainer.Schema);`
`35`	`35`	`}`
`36`	`36`
`37`		`- public IReadOnlyCollection<ItemAbilitySchemaItemModel> GetDotaItemAbilities(IEnumerable<string> vdf)`
	`37`	`+ public IReadOnlyCollection<ItemAbility> GetDotaItemAbilities(IEnumerable<string> vdf)`
`38`	`38`	`{`
`39`	`39`	`ValidateInput(vdf);`
`40`	`40`
`@@ -44,8 +44,8 @@ public IReadOnlyCollection<ItemAbilitySchemaItemModel> GetDotaItemAbilities(IEnu`
`44`	`44`	`if (schema.TryGetValue("DOTAAbilities", out item))`
`45`	`45`	`{`
`46`	`46`	`var itemAbilities = JsonConvert.DeserializeObject<IList<DotaItemAbilitySchemaItem>>(item.ToString(), new SchemaItemToDotaItemAbilityJsonConverter());`
`47`		`- var itemAbilityModels = mapper.Map<IList<DotaItemAbilitySchemaItem>, IList<ItemAbilitySchemaItemModel>>(itemAbilities);`
`48`		`- return new ReadOnlyCollection<ItemAbilitySchemaItemModel>(itemAbilityModels);`
	`47`	`+ var itemAbilityModels = mapper.Map<IList<DotaItemAbilitySchemaItem>, IList<ItemAbility>>(itemAbilities);`
	`48`	`+ return new ReadOnlyCollection<ItemAbility>(itemAbilityModels);`
`49`	`49`	`}`
`50`	`50`	`else`
`51`	`51`	`{`
`@@ -75,7 +75,7 @@ public IReadOnlyDictionary<string, string> GetDotaPublicLocalizationKeys(IEnumer`
`75`	`75`
`76`	`76`	`#region Dota Heroes`
`77`	`77`
`78`		`- public IReadOnlyCollection<AbilitySchemaItemModel> GetDotaHeroAbilities(IEnumerable<string> vdf)`
	`78`	`+ public IReadOnlyCollection<HeroAbility> GetDotaHeroAbilities(IEnumerable<string> vdf)`
`79`	`79`	`{`
`80`	`80`	`ValidateInput(vdf);`
`81`	`81`
`@@ -85,16 +85,16 @@ public IReadOnlyCollection<AbilitySchemaItemModel> GetDotaHeroAbilities(IEnumera`
`85`	`85`	`if (schema.TryGetValue("DOTAAbilities", out item))`
`86`	`86`	`{`
`87`	`87`	`var abilities = JsonConvert.DeserializeObject<IList<DotaAbilitySchemaItem>>(item.ToString(), new SchemaItemToDotaAbilityJsonConverter());`
`88`		`- var abilityModels = mapper.Map<IList<DotaAbilitySchemaItem>, IList<AbilitySchemaItemModel>>(abilities);`
`89`		`- return new ReadOnlyCollection<AbilitySchemaItemModel>(abilityModels);`
	`88`	`+ var abilityModels = mapper.Map<IList<DotaAbilitySchemaItem>, IList<HeroAbility>>(abilities);`
	`89`	`+ return new ReadOnlyCollection<HeroAbility>(abilityModels);`
`90`	`90`	`}`
`91`	`91`	`else`
`92`	`92`	`{`
`93`	`93`	`throw new ArgumentException("You supplied a VDF file, but it wasn't the expected Dota Heroes Abilities schema file.");`
`94`	`94`	`}`
`95`	`95`	`}`
`96`	`96`
`97`		`- public IReadOnlyCollection<HeroSchemaModel> GetDotaHeroes(IEnumerable<string> vdf)`
	`97`	`+ public IReadOnlyCollection<Hero> GetDotaHeroes(IEnumerable<string> vdf)`
`98`	`98`	`{`
`99`	`99`	`ValidateInput(vdf);`
`100`	`100`
`@@ -104,16 +104,16 @@ public IReadOnlyCollection<HeroSchemaModel> GetDotaHeroes(IEnumerable<string> vd`
`104`	`104`	`if (schema.TryGetValue("DOTAHeroes", out item))`
`105`	`105`	`{`
`106`	`106`	`var heroes = JsonConvert.DeserializeObject<IList<DotaHeroSchemaItem>>(item.ToString(), new SchemaItemToDotaHeroJsonConverter());`
`107`		`- var heroModels = mapper.Map<IList<DotaHeroSchemaItem>, IList<HeroSchemaModel>>(heroes);`
`108`		`- return new ReadOnlyCollection<HeroSchemaModel>(heroModels);`
	`107`	`+ var heroModels = mapper.Map<IList<DotaHeroSchemaItem>, IList<Hero>>(heroes);`
	`108`	`+ return new ReadOnlyCollection<Hero>(heroModels);`
`109`	`109`	`}`
`110`	`110`	`else`
`111`	`111`	`{`
`112`	`112`	`throw new ArgumentException("You supplied a VDF file, but it wasn't the expected Dota Heroes schema file.");`
`113`	`113`	`}`
`114`	`114`	`}`
`115`	`115`
`116`		`- public ItemBuildSchemaItemModel GetDotaItemBuild(IEnumerable<string> vdf)`
	`116`	`+ public ItemBuild GetDotaItemBuild(IEnumerable<string> vdf)`
`117`	`117`	`{`
`118`	`118`	`ValidateInput(vdf);`
`119`	`119`
`@@ -123,7 +123,7 @@ public ItemBuildSchemaItemModel GetDotaItemBuild(IEnumerable<string> vdf)`
`123`	`123`	`if (schema.TryGetValue("itembuilds", out item))`
`124`	`124`	`{`
`125`	`125`	`var itemBuild = item.ToObject<DotaItemBuildSchemaItem>();`
`126`		`- var itemBuildModel = mapper.Map<DotaItemBuildSchemaItem, ItemBuildSchemaItemModel>(itemBuild);`
	`126`	`+ var itemBuildModel = mapper.Map<DotaItemBuildSchemaItem, ItemBuild>(itemBuild);`
`127`	`127`	`return itemBuildModel;`
`128`	`128`	`}`
`129`	`129`	`else`
`@@ -238,7 +238,7 @@ private IReadOnlyCollection<DotaLeague> FlattenDotaSchemaItemLeagues(IReadOnlyCo`
`238`	`238`
`239`	`239`	`#endregion`
`240`	`240`
`241`		`- public IReadOnlyCollection<SchemaPrefabModel> GetDotaItemPrefabs(IEnumerable<string> vdf)`
	`241`	`+ public IReadOnlyCollection<SchemaPrefab> GetDotaItemPrefabs(IEnumerable<string> vdf)`
`242`	`242`	`{`
`243`	`243`	`ValidateInput(vdf);`
`244`	`244`
`@@ -253,9 +253,9 @@ public IReadOnlyCollection<SchemaPrefabModel> GetDotaItemPrefabs(IEnumerable<str`
`253`	`253`
`254`	`254`	`var prefabs = JsonConvert.DeserializeObject<IList<DotaSchemaPrefab>>(item.ToString(), new DotaSchemaPrefabJsonConverter());`
`255`	`255`
`256`		`- var prefabModels = mapper.Map<IList<DotaSchemaPrefab>, IList<SchemaPrefabModel>>(prefabs);`
	`256`	`+ var prefabModels = mapper.Map<IList<DotaSchemaPrefab>, IList<SchemaPrefab>>(prefabs);`
`257`	`257`
`258`		`- return new ReadOnlyCollection<SchemaPrefabModel>(prefabModels);`
	`258`	`+ return new ReadOnlyCollection<SchemaPrefab>(prefabModels);`
`259`	`259`	`}`
`260`	`260`	`else`
`261`	`261`	`{`