BlockitemBase

.gitignore

@@ -187,3 +187,4 @@ FakesAssemblies/
 GeneratedArtifacts/
 _Pvt_Extensions/
 ModelManifest.xml
+/Releases

Filtration.LootExplosionStudio.Tests/Filtration.LootExplosionStudio.Tests.csproj

@@ -0,0 +1,74 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{56D0887E-B10D-4F9C-A88E-09CF8E8E06E3}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>Filtration.LootExplosionStudio.Tests</RootNamespace>
+    <AssemblyName>Filtration.LootExplosionStudio.Tests</AssemblyName>
+    <TargetFrameworkVersion>v4.5.1</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="Moq">
+      <HintPath>..\packages\Moq.4.2.1507.0118\lib\net40\Moq.dll</HintPath>
+    </Reference>
+    <Reference Include="nunit.framework">
+      <HintPath>..\packages\NUnit.2.6.4\lib\nunit.framework.dll</HintPath>
+    </Reference>
+    <Reference Include="PresentationCore" />
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="Services\TestItemFilterBlockFinderService.cs" />
+    <Compile Include="Services\TestLootItemAppearanceService.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="packages.config" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\Filtration.LootExplosionStudio\Filtration.LootExplosionStudio.csproj">
+      <Project>{c8009b11-14d0-4421-94f0-9ef4603cb363}</Project>
+      <Name>Filtration.LootExplosionStudio</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\Filtration.ObjectModel\Filtration.ObjectModel.csproj">
+      <Project>{4aac3beb-1dc1-483e-9d11-0e9334e80227}</Project>
+      <Name>Filtration.ObjectModel</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>

Filtration.LootExplosionStudio.Tests/Properties/AssemblyInfo.cs

@@ -0,0 +1,36 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("Filtration.LootExplosionStudio.Tests")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("Microsoft")]
+[assembly: AssemblyProduct("Filtration.LootExplosionStudio.Tests")]
+[assembly: AssemblyCopyright("Copyright © Microsoft 2015")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("24ce1315-7f86-4389-a63c-22a40baa4c6d")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers 
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]

Filtration.LootExplosionStudio.Tests/Services/TestItemFilterBlockFinderService.cs

@@ -0,0 +1,178 @@
+using Filtration.LootExplosionStudio.Services;
+using Filtration.ObjectModel;
+using Filtration.ObjectModel.BlockItemTypes;
+using Filtration.ObjectModel.Enums;
+using Filtration.ObjectModel.LootExplosionStudio;
+using NUnit.Framework;
+
+namespace Filtration.LootExplosionStudio.Tests.Services
+{
+    [TestFixture]
+    public class TestItemFilterBlockFinderService
+    {
+        private ItemFilterBlockFinderServiceTestUtility _testUtility;
+
+        [SetUp]
+        public void ItemFilterProcessingServiceTestSetup()
+        {
+            _testUtility = new ItemFilterBlockFinderServiceTestUtility();
+        }
+
+        [Test]
+        public void FindBlockForLootItem_SingleBlock_BaseType_Matches()
+        {
+            // Arrange
+            var testInputBaseType = "TestBaseType";
+            var testInputBlockItem = new BaseTypeBlockItem();
+            testInputBlockItem.Items.Add(testInputBaseType);
+
+            _testUtility.TestLootItem.BaseType = testInputBaseType;
+            _testUtility.TestBlock.BlockItems.Add(testInputBlockItem);
+
+
+            // Act
+            var result = _testUtility.Service.FindBlockForLootItem(_testUtility.TestLootItem, _testUtility.TestScript);
+
+            // Assert
+            Assert.AreEqual(_testUtility.TestBlock, result);
+        }
+
+        [Test]
+        public void FindBlockForLootItem_SingleHideBlock_Matches()
+        {
+            // Arrange
+
+            _testUtility.TestBlock.Action = BlockAction.Hide;
+
+            // Act
+            var result = _testUtility.Service.FindBlockForLootItem(_testUtility.TestLootItem, _testUtility.TestScript);
+
+            // Assert
+            Assert.AreEqual(_testUtility.TestBlock, result);
+        }
+
+        [Test]
+        public void FindBlockForLootItem_SingleBlock_MultipleBlockItems_Matches()
+        {
+            // Arrange
+            var testInputBaseType = "TestBaseType";
+            var testInputBaseTypeBlockItem = new BaseTypeBlockItem();
+            testInputBaseTypeBlockItem.Items.Add(testInputBaseType);
+
+            var testInputClass = "Test Class";
+            var testInputClassBlockItem = new ClassBlockItem();
+            testInputClassBlockItem.Items.Add(testInputClass);
+
+            var testInputItemLevel = 57;
+            var testInputItemLevelBlockItem = new ItemLevelBlockItem(FilterPredicateOperator.GreaterThan, 50);
+
+            _testUtility.TestLootItem.BaseType = testInputBaseType;
+            _testUtility.TestLootItem.Class = testInputClass;
+            _testUtility.TestLootItem.ItemLevel = testInputItemLevel;
+
+            _testUtility.TestBlock.BlockItems.Add(testInputBaseTypeBlockItem);
+            _testUtility.TestBlock.BlockItems.Add(testInputClassBlockItem);
+            _testUtility.TestBlock.BlockItems.Add(testInputItemLevelBlockItem);
+
+
+            // Act
+            var result = _testUtility.Service.FindBlockForLootItem(_testUtility.TestLootItem, _testUtility.TestScript);
+
+            // Assert
+            Assert.AreEqual(_testUtility.TestBlock, result);
+        }
+
+
+
+        [Test]
+        public void FindBlockForLootItem_SingleBlock_MultipleBlockItemsOneWithoutMatch_Matches()
+        {
+            // Arrange
+            var testInputBaseType = "TestBaseType";
+            var testInputBaseTypeBlockItem = new BaseTypeBlockItem();
+            testInputBaseTypeBlockItem.Items.Add(testInputBaseType);
+
+            var testInputClass = "Test Class";
+            var testInputClassBlockItem = new ClassBlockItem();
+            testInputClassBlockItem.Items.Add(testInputClass);
+
+            var testInputItemLevel = 57;
+            var testInputItemLevelBlockItem = new ItemLevelBlockItem(FilterPredicateOperator.GreaterThan, 50);
+
+            var testInputDropLevel = 35;
+            var testInputDropLevelBlockItem = new DropLevelBlockItem(FilterPredicateOperator.GreaterThanOrEqual, 89);
+
+            _testUtility.TestLootItem.BaseType = testInputBaseType;
+            _testUtility.TestLootItem.Class = testInputClass;
+            _testUtility.TestLootItem.ItemLevel = testInputItemLevel;
+            _testUtility.TestLootItem.DropLevel = testInputDropLevel;
+
+            _testUtility.TestBlock.BlockItems.Add(testInputBaseTypeBlockItem);
+            _testUtility.TestBlock.BlockItems.Add(testInputClassBlockItem);
+            _testUtility.TestBlock.BlockItems.Add(testInputItemLevelBlockItem);
+            _testUtility.TestBlock.BlockItems.Add(testInputDropLevelBlockItem);
+
+            // Act
+            var result = _testUtility.Service.FindBlockForLootItem(_testUtility.TestLootItem, _testUtility.TestScript);
+
+            // Assert
+            Assert.IsNull(result);
+        }
+
+        [Test]
+        public void FindBlockForLootItem_MultipleBlocksBlock_Matches()
+        {
+            // Arrange
+            var testInputBlock1 = new ItemFilterBlock();
+            var testInputClass1 = "Test Class";
+            var testInputClassBlockItem1 = new ClassBlockItem();
+            testInputClassBlockItem1.Items.Add(testInputClass1);
+            testInputBlock1.BlockItems.Add(testInputClassBlockItem1);
+
+            _testUtility.TestScript.ItemFilterBlocks.Add(testInputBlock1);
+
+            var testInputBaseType = "TestBaseType";
+            var testInputBaseTypeBlockItem = new BaseTypeBlockItem();
+            testInputBaseTypeBlockItem.Items.Add(testInputBaseType);
+
+            var testInputClass = "Test Class";
+            var testInputClassBlockItem = new ClassBlockItem();
+            testInputClassBlockItem.Items.Add(testInputClass);
+
+            var testInputItemLevel = 57;
+            var testInputItemLevelBlockItem = new ItemLevelBlockItem(FilterPredicateOperator.GreaterThan, 50);
+            
+            _testUtility.TestLootItem.BaseType = testInputBaseType;
+            _testUtility.TestLootItem.Class = testInputClass;
+            _testUtility.TestLootItem.ItemLevel = testInputItemLevel;
+
+            _testUtility.TestBlock.BlockItems.Add(testInputBaseTypeBlockItem);
+            _testUtility.TestBlock.BlockItems.Add(testInputClassBlockItem);
+            _testUtility.TestBlock.BlockItems.Add(testInputItemLevelBlockItem);
+
+            // Act
+            var result = _testUtility.Service.FindBlockForLootItem(_testUtility.TestLootItem, _testUtility.TestScript);
+
+            // Assert
+            Assert.AreEqual(_testUtility.TestBlock, result);
+        }
+
+        private class ItemFilterBlockFinderServiceTestUtility
+        {
+            public ItemFilterBlockFinderServiceTestUtility()
+            {
+                TestBlock = new ItemFilterBlock();
+                TestScript = new ItemFilterScript();
+                TestScript.ItemFilterBlocks.Add(TestBlock);
+                TestLootItem = new LootItem();
+
+                Service = new ItemFilterBlockFinderService();
+            }
+
+            public ItemFilterScript TestScript { get; private set; }
+            public ItemFilterBlock TestBlock { get; private set; }
+            public LootItem TestLootItem { get; private set; }
+            public ItemFilterBlockFinderService Service { get; private set; }
+        }
+    }
+}

Filtration.LootExplosionStudio.Tests/Services/TestLootItemAppearanceService.cs

@@ -0,0 +1,275 @@
+using System.Windows.Media;
+using Filtration.LootExplosionStudio.Services;
+using Filtration.ObjectModel;
+using Filtration.ObjectModel.BlockItemTypes;
+using Filtration.ObjectModel.Enums;
+using Filtration.ObjectModel.LootExplosionStudio;
+using Moq;
+using NUnit.Framework;
+
+namespace Filtration.LootExplosionStudio.Tests.Services
+{
+    [TestFixture]
+    class TestLootItemAppearanceService
+    {
+        private LootItemAppearanceServiceTestUtility _testUtility;
+
+        [SetUp]
+        public void ItemFilterProcessingServiceTestSetup()
+        {
+            _testUtility = new LootItemAppearanceServiceTestUtility();
+        }
+
+        [Test]
+        public void ProcessLootItemAgainstScript_NoMatchingBlocks_NormalItem_SetsCorrectTextColor()
+        {
+            // Arrange
+            _testUtility.TestLootItem.Rarity = ItemRarity.Normal;
+            
+            // Act
+            _testUtility.Service.ProcessLootItemAgainstFilterScript(_testUtility.TestLootItem, _testUtility.TestScript);
+
+            // Assert
+            Assert.AreEqual(DefaultLootItemAppearanceConstants.NormalTextColor, _testUtility.TestLootItem.TextColor);
+        }
+
+        [Test]
+        public void ProcessLootItemAgainstScript_NoMatchingBlocks_MagicItem_SetsCorrectTextColor()
+        {
+            // Arrange
+            _testUtility.TestLootItem.Rarity = ItemRarity.Magic;
+            _testUtility.TestBlock.BlockItems.Add(new ItemLevelBlockItem(FilterPredicateOperator.GreaterThan, 99));
+
+            // Act
+            _testUtility.Service.ProcessLootItemAgainstFilterScript(_testUtility.TestLootItem, _testUtility.TestScript);
+
+            // Assert
+            Assert.AreEqual(DefaultLootItemAppearanceConstants.MagicTextColor, _testUtility.TestLootItem.TextColor);
+        }
+
+        [Test]
+        public void ProcessLootItemAgainstScript_NoMatchingBlocks_RareItem_SetsCorrectTextColor()
+        {
+            // Arrange
+            _testUtility.TestLootItem.Rarity = ItemRarity.Rare;
+            _testUtility.TestBlock.BlockItems.Add(new ItemLevelBlockItem(FilterPredicateOperator.GreaterThan, 99));
+
+            // Act
+            _testUtility.Service.ProcessLootItemAgainstFilterScript(_testUtility.TestLootItem, _testUtility.TestScript);
+
+            // Assert
+            Assert.AreEqual(DefaultLootItemAppearanceConstants.RareTextColor, _testUtility.TestLootItem.TextColor);
+        }
+
+        [Test]
+        public void ProcessLootItemAgainstScript_NoMatchingBlocks_UniqueItem_SetsCorrectTextColor()
+        {
+            // Arrange
+            _testUtility.TestLootItem.Rarity = ItemRarity.Unique;
+            _testUtility.TestBlock.BlockItems.Add(new ItemLevelBlockItem(FilterPredicateOperator.GreaterThan, 99));
+
+            // Act
+            _testUtility.Service.ProcessLootItemAgainstFilterScript(_testUtility.TestLootItem, _testUtility.TestScript);
+
+            // Assert
+            Assert.AreEqual(DefaultLootItemAppearanceConstants.UniqueTextColor, _testUtility.TestLootItem.TextColor);
+        }
+
+        [Test]
+        public void ProcessLootItemAgainstScript_NoMatchingBlocks_SetsCorrectBackgroundColor()
+        {
+            // Arrange
+            _testUtility.TestBlock.BlockItems.Add(new ItemLevelBlockItem(FilterPredicateOperator.GreaterThan, 99));
+
+            // Act
+            _testUtility.Service.ProcessLootItemAgainstFilterScript(_testUtility.TestLootItem, _testUtility.TestScript);
+
+            // Assert
+            Assert.AreEqual(DefaultLootItemAppearanceConstants.BackgroundColor, _testUtility.TestLootItem.BackgroundColor);
+        }
+
+        [Test]
+        public void ProcessLootItemAgainstScript_NoMatchingBlocks_SetsCorrectBorderColor()
+        {
+            // Arrange
+            _testUtility.TestBlock.BlockItems.Add(new ItemLevelBlockItem(FilterPredicateOperator.GreaterThan, 99));
+
+            // Act
+            _testUtility.Service.ProcessLootItemAgainstFilterScript(_testUtility.TestLootItem, _testUtility.TestScript);
+
+            // Assert
+            Assert.AreEqual(DefaultLootItemAppearanceConstants.BorderColor, _testUtility.TestLootItem.BorderColor);
+        }
+
+        [Test]
+        public void ProcessLootItemAgainstScript_MatchingTextColorOnly_SetsColorsCorrectly()
+        {
+            // Arrange
+            var testInputTextColor = new Color {R = 123, G = 5, B = 22, A = 200};
+            _testUtility.TestBlock.BlockItems.Add(new TextColorBlockItem {Color = testInputTextColor});
+
+            // Act
+            _testUtility.Service.ProcessLootItemAgainstFilterScript(_testUtility.TestLootItem, _testUtility.TestScript);
+
+            // Assert
+            Assert.AreEqual(testInputTextColor, _testUtility.TestLootItem.TextColor);
+            Assert.AreEqual(DefaultLootItemAppearanceConstants.BackgroundColor, _testUtility.TestLootItem.BackgroundColor);
+            Assert.AreEqual(DefaultLootItemAppearanceConstants.BorderColor, _testUtility.TestLootItem.BorderColor);
+            Assert.AreEqual(DefaultLootItemAppearanceConstants.FontSize, _testUtility.TestLootItem.FontSize );
+        }
+
+        [Test]
+        public void ProcessLootItemAgainstScript_MatchingBackgroundColorOnly_RarityNormal_SetsColorsCorrectly()
+        {
+            // Arrange
+            var testInputBackgroundColor = new Color {R = 123, G = 5, B = 22, A = 200};
+            _testUtility.TestBlock.BlockItems.Add(new BackgroundColorBlockItem {Color = testInputBackgroundColor});
+
+            // Act
+            _testUtility.Service.ProcessLootItemAgainstFilterScript(_testUtility.TestLootItem, _testUtility.TestScript);
+
+            // Assert
+            Assert.AreEqual(testInputBackgroundColor, _testUtility.TestLootItem.BackgroundColor);
+            Assert.AreEqual(DefaultLootItemAppearanceConstants.NormalTextColor, _testUtility.TestLootItem.TextColor);
+            Assert.AreEqual(DefaultLootItemAppearanceConstants.BorderColor, _testUtility.TestLootItem.BorderColor);
+            Assert.AreEqual(DefaultLootItemAppearanceConstants.FontSize, _testUtility.TestLootItem.FontSize);
+        }
+
+        [Test]
+        public void ProcessLootItemAgainstScript_MatchingBackgroundColorOnly_RarityMagic_SetsColorsCorrectly()
+        {
+            // Arrange
+            var testInputBackgroundColor = new Color { R = 123, G = 5, B = 22, A = 200 };
+            _testUtility.TestBlock.BlockItems.Add(new BackgroundColorBlockItem {Color = testInputBackgroundColor});
+            _testUtility.TestLootItem.Rarity = ItemRarity.Magic;
+
+            // Act
+            _testUtility.Service.ProcessLootItemAgainstFilterScript(_testUtility.TestLootItem, _testUtility.TestScript);
+
+            // Assert
+            Assert.AreEqual(testInputBackgroundColor, _testUtility.TestLootItem.BackgroundColor);
+            Assert.AreEqual(DefaultLootItemAppearanceConstants.MagicTextColor, _testUtility.TestLootItem.TextColor);
+            Assert.AreEqual(DefaultLootItemAppearanceConstants.BorderColor, _testUtility.TestLootItem.BorderColor);
+            Assert.AreEqual(DefaultLootItemAppearanceConstants.FontSize, _testUtility.TestLootItem.FontSize);
+        }
+
+        [Test]
+        public void ProcessLootItemAgainstScript_MatchingBackgroundColorOnly_RarityRare_SetsColorsCorrectly()
+        {
+            // Arrange
+            var testInputBackgroundColor = new Color { R = 123, G = 5, B = 22, A = 200 };
+            _testUtility.TestBlock.BlockItems.Add(new BackgroundColorBlockItem { Color = testInputBackgroundColor });
+            _testUtility.TestLootItem.Rarity = ItemRarity.Rare;
+
+            // Act
+            _testUtility.Service.ProcessLootItemAgainstFilterScript(_testUtility.TestLootItem, _testUtility.TestScript);
+
+            // Assert
+            Assert.AreEqual(testInputBackgroundColor, _testUtility.TestLootItem.BackgroundColor);
+            Assert.AreEqual(DefaultLootItemAppearanceConstants.RareTextColor, _testUtility.TestLootItem.TextColor);
+            Assert.AreEqual(DefaultLootItemAppearanceConstants.BorderColor, _testUtility.TestLootItem.BorderColor);
+            Assert.AreEqual(DefaultLootItemAppearanceConstants.FontSize, _testUtility.TestLootItem.FontSize);
+        }
+
+        [Test]
+        public void ProcessLootItemAgainstScript_MatchingBackgroundColorOnly_RarityUnique_SetsColorsCorrectly()
+        {
+            // Arrange
+            var testInputBackgroundColor = new Color { R = 123, G = 5, B = 22, A = 200 };
+            _testUtility.TestBlock.BlockItems.Add(new BackgroundColorBlockItem { Color = testInputBackgroundColor });
+            _testUtility.TestLootItem.Rarity = ItemRarity.Unique;
+
+            // Act
+            _testUtility.Service.ProcessLootItemAgainstFilterScript(_testUtility.TestLootItem, _testUtility.TestScript);
+
+            // Assert
+            Assert.AreEqual(testInputBackgroundColor, _testUtility.TestLootItem.BackgroundColor);
+            Assert.AreEqual(DefaultLootItemAppearanceConstants.UniqueTextColor, _testUtility.TestLootItem.TextColor);
+            Assert.AreEqual(DefaultLootItemAppearanceConstants.BorderColor, _testUtility.TestLootItem.BorderColor);
+            Assert.AreEqual(DefaultLootItemAppearanceConstants.FontSize, _testUtility.TestLootItem.FontSize);
+        }
+        
+        [Test]
+        public void ProcessLootItemAgainstScript_MatchingBorderColorOnly_RarityUnique_SetsColorsCorrectly()
+        {
+            // Arrange
+            var testInputBorderColor = new Color { R = 123, G = 5, B = 22, A = 200 };
+            _testUtility.TestBlock.BlockItems.Add(new BorderColorBlockItem { Color = testInputBorderColor });
+
+            // Act
+            _testUtility.Service.ProcessLootItemAgainstFilterScript(_testUtility.TestLootItem, _testUtility.TestScript);
+
+            // Assert
+            Assert.AreEqual(testInputBorderColor, _testUtility.TestLootItem.BorderColor);
+            Assert.AreEqual(DefaultLootItemAppearanceConstants.NormalTextColor, _testUtility.TestLootItem.TextColor);
+            Assert.AreEqual(DefaultLootItemAppearanceConstants.BackgroundColor, _testUtility.TestLootItem.BackgroundColor);
+            Assert.AreEqual(DefaultLootItemAppearanceConstants.FontSize, _testUtility.TestLootItem.FontSize);
+        }
+
+        [Test]
+        public void ProcessLootItemAgainstScript_MatchingFontSizeOnly_RarityUnique_SetsColorsCorrectly()
+        {
+            // Arrange
+            var testInputFontSize = 22;
+            _testUtility.TestBlock.BlockItems.Add(new FontSizeBlockItem(22));
+
+            // Act
+            _testUtility.Service.ProcessLootItemAgainstFilterScript(_testUtility.TestLootItem, _testUtility.TestScript);
+
+            // Assert
+            Assert.AreEqual(testInputFontSize, _testUtility.TestLootItem.FontSize);
+            Assert.AreEqual(DefaultLootItemAppearanceConstants.NormalTextColor, _testUtility.TestLootItem.TextColor);
+            Assert.AreEqual(DefaultLootItemAppearanceConstants.BackgroundColor, _testUtility.TestLootItem.BackgroundColor);
+            Assert.AreEqual(DefaultLootItemAppearanceConstants.BorderColor, _testUtility.TestLootItem.BorderColor);
+        }
+
+        [Test]
+        public void ProcessLootItemAgainstScript_AllAppearanceMatching_SetsColorsCorrectly()
+        {
+            // Arrange
+            var testInputFontSize = 22;
+            var testInputTextColor = new Color { R = 123, G = 5, B = 22, A = 200 };
+            var testInputBackgroundColor = new Color { R = 123, G = 59, B = 27, A = 50 };
+            var testInputBorderColor = new Color { R = 166, G = 0, B = 100, A = 255 };
+
+            _testUtility.TestBlock.BlockItems.Add(new FontSizeBlockItem(22));
+            _testUtility.TestBlock.BlockItems.Add(new BorderColorBlockItem { Color = testInputBorderColor });
+            _testUtility.TestBlock.BlockItems.Add(new BackgroundColorBlockItem { Color = testInputBackgroundColor });
+            _testUtility.TestBlock.BlockItems.Add(new TextColorBlockItem { Color = testInputTextColor });
+
+            // Act
+            _testUtility.Service.ProcessLootItemAgainstFilterScript(_testUtility.TestLootItem, _testUtility.TestScript);
+
+            // Assert
+            Assert.AreEqual(testInputFontSize, _testUtility.TestLootItem.FontSize);
+            Assert.AreEqual(testInputTextColor, _testUtility.TestLootItem.TextColor);
+            Assert.AreEqual(testInputBackgroundColor, _testUtility.TestLootItem.BackgroundColor);
+            Assert.AreEqual(testInputBorderColor, _testUtility.TestLootItem.BorderColor);
+        }
+
+        private class LootItemAppearanceServiceTestUtility
+        {
+            public LootItemAppearanceServiceTestUtility()
+            {
+                TestBlock = new ItemFilterBlock();
+                TestScript = new ItemFilterScript();
+                TestScript.ItemFilterBlocks.Add(TestBlock);
+                TestLootItem = new LootItem();
+
+                MockItemFilterBlockFinderService = new Mock<IItemFilterBlockFinderService>();
+                MockItemFilterBlockFinderService.Setup(
+                    b => b.FindBlockForLootItem(TestLootItem, TestScript))
+                    .Returns(TestBlock);
+
+                Service = new LootItemAppearanceService(MockItemFilterBlockFinderService.Object);
+            }
+
+            public Mock<IItemFilterBlockFinderService> MockItemFilterBlockFinderService { get; private set; }
+
+            public ItemFilterScript TestScript { get; private set; }
+            public ItemFilterBlock TestBlock { get; private set; }
+            public LootItem TestLootItem { get; private set; }
+            public LootItemAppearanceService Service { get; private set; }
+        }
+    }
+}

Filtration.LootExplosionStudio.Tests/packages.config

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<packages>
+  <package id="Moq" version="4.2.1507.0118" targetFramework="net451" />
+  <package id="NUnit" version="2.6.4" targetFramework="net451" />
+</packages>

Filtration.LootExplosionStudio/Filtration.LootExplosionStudio.csproj

@@ -0,0 +1,72 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{C8009B11-14D0-4421-94F0-9EF4603CB363}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>Filtration.LootExplosionStudio</RootNamespace>
+    <AssemblyName>Filtration.LootExplosionStudio</AssemblyName>
+    <TargetFrameworkVersion>v4.5.1</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="Castle.Core">
+      <HintPath>..\packages\Castle.Core.3.3.0\lib\net45\Castle.Core.dll</HintPath>
+    </Reference>
+    <Reference Include="Castle.Windsor">
+      <HintPath>..\packages\Castle.Windsor.3.3.0\lib\net45\Castle.Windsor.dll</HintPath>
+    </Reference>
+    <Reference Include="PresentationCore" />
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="Services\ItemFilterBlockFinderService.cs" />
+    <Compile Include="Services\LootItemAppearanceService.cs" />
+    <Compile Include="Services\LootItemCollectionItemFilterCombinerService.cs" />
+    <Compile Include="WindsorInstallers\ServicesInstaller.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\Filtration.ObjectModel\Filtration.ObjectModel.csproj">
+      <Project>{4aac3beb-1dc1-483e-9d11-0e9334e80227}</Project>
+      <Name>Filtration.ObjectModel</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="packages.config" />
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>

Filtration.LootExplosionStudio/Properties/AssemblyInfo.cs

@@ -0,0 +1,39 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("Filtration.LootExplosionStudio")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("Microsoft")]
+[assembly: AssemblyProduct("Filtration.LootExplosionStudio")]
+[assembly: AssemblyCopyright("Copyright © Microsoft 2015")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("b33dec95-6eec-4e14-81d5-3d8ce0db77d1")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers 
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]
+
+[assembly: InternalsVisibleTo("Filtration.LootExplosionStudio.Tests")]
+[assembly: InternalsVisibleTo("DynamicProxyGenAssembly2")]

Filtration.LootExplosionStudio/Services/ItemFilterBlockFinderService.cs

@@ -0,0 +1,37 @@
+using System.Linq;
+using Filtration.ObjectModel;
+using Filtration.ObjectModel.BlockItemBaseTypes;
+using Filtration.ObjectModel.LootExplosionStudio;
+
+namespace Filtration.LootExplosionStudio.Services
+{
+    internal interface IItemFilterBlockFinderService
+    {
+        ItemFilterBlock FindBlockForLootItem(LootItem lootItem, ItemFilterScript script);
+    }
+
+    internal class ItemFilterBlockFinderService : IItemFilterBlockFinderService
+    {
+        public ItemFilterBlock FindBlockForLootItem(LootItem lootItem, ItemFilterScript script)
+        {
+            return script.ItemFilterBlocks.FirstOrDefault(block => BlockMatchesLootItem(lootItem, block));
+        }
+
+        private static bool BlockMatchesLootItem(LootItem lootItem, ItemFilterBlock block)
+        {
+            if (!block.BlockItems.OfType<StringListBlockItem>().All(blockItem => blockItem.MatchesLootItem(lootItem)))
+            {
+                return false;
+            }
+
+            if (
+                !block.BlockItems.OfType<NumericFilterPredicateBlockItem>()
+                    .All(blockItem => blockItem.MatchesLootItem(lootItem)))
+            {
+                return false;
+            }
+
+            return true;
+        }
+    }
+}

Filtration.LootExplosionStudio/Services/LootItemAppearanceService.cs

@@ -0,0 +1,80 @@
+using System.Linq;
+using System.Windows.Media;
+using Filtration.ObjectModel;
+using Filtration.ObjectModel.BlockItemTypes;
+using Filtration.ObjectModel.Enums;
+using Filtration.ObjectModel.LootExplosionStudio;
+
+namespace Filtration.LootExplosionStudio.Services
+{
+    internal interface ILootItemAppearanceService
+    {
+        void ProcessLootItemAgainstFilterScript(LootItem lootItem, ItemFilterScript script);
+    }
+
+    internal class LootItemAppearanceService : ILootItemAppearanceService
+    {
+        private readonly IItemFilterBlockFinderService _blockFinderService;
+
+        public LootItemAppearanceService(IItemFilterBlockFinderService blockFinderService)
+        {
+            _blockFinderService = blockFinderService;
+        }
+
+        public void ProcessLootItemAgainstFilterScript(LootItem lootItem, ItemFilterScript script)
+        {
+            var matchedBlock = _blockFinderService.FindBlockForLootItem(lootItem, script);
+            if (matchedBlock == null)
+            {
+                lootItem.TextColor = GetDefaultTextColorForRarity(lootItem.Rarity);
+                lootItem.BackgroundColor = DefaultLootItemAppearanceConstants.BackgroundColor;
+                lootItem.BorderColor = DefaultLootItemAppearanceConstants.BorderColor;
+                lootItem.FontSize = 35;
+                return;
+            }
+
+            lootItem.TextColor = matchedBlock.HasBlockItemOfType<TextColorBlockItem>()
+                ? matchedBlock.BlockItems.OfType<TextColorBlockItem>().First().Color
+                : GetDefaultTextColorForRarity(lootItem.Rarity);
+
+            lootItem.BackgroundColor = matchedBlock.HasBlockItemOfType<BackgroundColorBlockItem>()
+                ? matchedBlock.BlockItems.OfType<BackgroundColorBlockItem>().First().Color
+                : DefaultLootItemAppearanceConstants.BackgroundColor;
+
+            lootItem.BorderColor = matchedBlock.HasBlockItemOfType<BorderColorBlockItem>()
+                ? matchedBlock.BlockItems.OfType<BorderColorBlockItem>().First().Color
+                : DefaultLootItemAppearanceConstants.BorderColor;
+
+            lootItem.FontSize = matchedBlock.HasBlockItemOfType<FontSizeBlockItem>()
+                ? matchedBlock.BlockItems.OfType<FontSizeBlockItem>().First().Value
+                : 35;
+        }
+
+        private Color GetDefaultTextColorForRarity(ItemRarity rarity)
+        {
+            switch (rarity)
+            {
+                case ItemRarity.Normal:
+                {
+                    return DefaultLootItemAppearanceConstants.NormalTextColor;
+                }
+                case ItemRarity.Magic:
+                {
+                    return DefaultLootItemAppearanceConstants.MagicTextColor;
+                }
+                case ItemRarity.Rare:
+                {
+                    return DefaultLootItemAppearanceConstants.RareTextColor;
+                }
+                case ItemRarity.Unique:
+                {
+                    return DefaultLootItemAppearanceConstants.UniqueTextColor;
+                }
+                default:
+                {
+                    return DefaultLootItemAppearanceConstants.NormalTextColor;
+                }
+            }
+        }
+    }
+}

Filtration.LootExplosionStudio/Services/LootItemCollectionItemFilterCombinerService.cs

@@ -0,0 +1,30 @@
+using Filtration.ObjectModel;
+using Filtration.ObjectModel.LootExplosionStudio;
+
+namespace Filtration.LootExplosionStudio.Services
+{
+    internal interface ILootItemCollectionItemFilterCombinerService
+    {
+        void CombineLootItemCollectionWithItemFilterScript(LootItemCollection lootItemCollection,
+            ItemFilterScript script);
+    }
+
+    internal class LootItemCollectionItemFilterCombinerService : ILootItemCollectionItemFilterCombinerService
+    {
+        private readonly ILootItemAppearanceService _lootItemAppearanceService;
+
+        public LootItemCollectionItemFilterCombinerService(ILootItemAppearanceService lootItemAppearanceService)
+        {
+            _lootItemAppearanceService = lootItemAppearanceService;
+        }
+
+        public void CombineLootItemCollectionWithItemFilterScript(LootItemCollection lootItemCollection,
+            ItemFilterScript script)
+        {
+            foreach (var lootItem in lootItemCollection)
+            {
+                _lootItemAppearanceService.ProcessLootItemAgainstFilterScript(lootItem, script);
+            }
+        }
+    }
+}

Filtration.LootExplosionStudio/WindsorInstallers/ServicesInstaller.cs

@@ -0,0 +1,27 @@
+using Castle.MicroKernel.Registration;
+using Castle.MicroKernel.SubSystems.Configuration;
+using Castle.Windsor;
+using Filtration.LootExplosionStudio.Services;
+
+namespace Filtration.LootExplosionStudio.WindsorInstallers
+{
+    class ServicesInstaller : IWindsorInstaller
+    {
+        public void Install(IWindsorContainer container, IConfigurationStore store)
+        {
+            container.Register(
+                Component.For<IItemFilterBlockFinderService>()
+                    .ImplementedBy<ItemFilterBlockFinderService>()
+                    .LifeStyle.Singleton);
+
+            container.Register(
+                Component.For<ILootItemAppearanceService>()
+                    .ImplementedBy<LootItemAppearanceService>()
+                    .LifeStyle.Singleton);
+            container.Register(
+                Component.For<ILootItemCollectionItemFilterCombinerService>()
+                    .ImplementedBy<LootItemCollectionItemFilterCombinerService>()
+                    .LifeStyle.Singleton);
+        }
+    }
+}

Filtration.LootExplosionStudio/packages.config

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<packages>
+  <package id="Castle.Core" version="3.3.0" targetFramework="net451" />
+  <package id="Castle.Windsor" version="3.3.0" targetFramework="net451" />
+</packages>

Filtration.ObjectModel.Tests/BlockItemBaseTypes/TestBaseTypeBlockItem.cs

@@ -0,0 +1,48 @@
+using System;
+using System.Windows.Media;
+using Filtration.ObjectModel.BlockItemBaseTypes;
+using Filtration.ObjectModel.BlockItemTypes;
+using Filtration.ObjectModel.LootExplosionStudio;
+using NUnit.Framework;
+
+namespace Filtration.ObjectModel.Tests.BlockItemBaseTypes
+{
+    [TestFixture]
+    public class TestBaseTypeBlockItem
+    {
+        [Test]
+        public void MatchesBlockItem_BlankLootItem_ReturnsFalse()
+        {
+            // Arrange
+            
+            var blockItem = new BaseTypeBlockItem();
+            var testInputLootItem = new LootItem();
+
+            // Act
+            var result = blockItem.MatchesLootItem(testInputLootItem);
+
+            // Assert
+            Assert.IsFalse(result);
+        }
+
+        [Test]
+        public void MatchesBlockItem_StringMatch_ReturnsTrue()
+        {
+            // Arrange
+            var testInputBaseType = "Test Base Type";
+
+            var blockItem = new BaseTypeBlockItem();
+            blockItem.Items.Add("Testblah");
+            blockItem.Items.Add(testInputBaseType);
+            blockItem.Items.Add("Another Base Type");
+
+            var testInputLootItem = new LootItem { BaseType = testInputBaseType};
+
+            // Act
+            var result = blockItem.MatchesLootItem(testInputLootItem);
+
+            // Assert
+            Assert.IsTrue(result);
+        }
+    }
+}

Filtration.ObjectModel.Tests/BlockItemBaseTypes/TestClassBlockItem.cs

@@ -0,0 +1,50 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Filtration.ObjectModel.BlockItemTypes;
+using Filtration.ObjectModel.LootExplosionStudio;
+using NUnit.Framework;
+
+namespace Filtration.ObjectModel.Tests.BlockItemBaseTypes
+{
+    [TestFixture]
+    public class TestClassBlockItem
+    {
+        [Test]
+        public void MatchesBlockItem_BlankLootItem_ReturnsFalse()
+        {
+            // Arrange
+
+            var blockItem = new ClassBlockItem();
+            var testInputLootItem = new LootItem();
+
+            // Act
+            var result = blockItem.MatchesLootItem(testInputLootItem);
+
+            // Assert
+            Assert.IsFalse(result);
+        }
+
+        [Test]
+        public void MatchesBlockItem_StringMatch_ReturnsTrue()
+        {
+            // Arrange
+            var testInputClass = "Test Class";
+
+            var blockItem = new ClassBlockItem();
+            blockItem.Items.Add("Testblah");
+            blockItem.Items.Add(testInputClass);
+            blockItem.Items.Add("Another Base Type");
+
+            var testInputLootItem = new LootItem { Class = testInputClass };
+
+            // Act
+            var result = blockItem.MatchesLootItem(testInputLootItem);
+
+            // Assert
+            Assert.IsTrue(result);
+        }
+    }
+}

Filtration.ObjectModel.Tests/BlockItemBaseTypes/TestItemLevelBlockItem.cs

@@ -0,0 +1,101 @@
+using Filtration.ObjectModel.BlockItemTypes;
+using Filtration.ObjectModel.Enums;
+using Filtration.ObjectModel.LootExplosionStudio;
+using NUnit.Framework;
+
+namespace Filtration.ObjectModel.Tests.BlockItemBaseTypes
+{
+    [TestFixture]
+    public class TestItemLevelBlockItem
+    {
+        [Test]
+        public void MatchesBlockItem_NoMatch_ReturnsFalse()
+        {
+            // Arrange
+
+            var blockItem = new ItemLevelBlockItem(FilterPredicateOperator.GreaterThan, 10);
+            var lootItem = new LootItem {ItemLevel = 5};
+
+            // Act
+            var result = blockItem.MatchesLootItem(lootItem);
+
+            // Assert
+            Assert.IsFalse(result);
+        }
+        
+        [Test]
+        public void MatchesBlockItem_EqualsMatch_ReturnsTrue()
+        {
+            // Arrange
+
+            var blockItem = new ItemLevelBlockItem(FilterPredicateOperator.Equal, 10);
+            var lootItem = new LootItem { ItemLevel = 10 };
+
+            // Act
+            var result = blockItem.MatchesLootItem(lootItem);
+
+            // Assert
+            Assert.IsTrue(result);
+        }
+
+        [Test]
+        public void MatchesBlockItem_GreaterThanMatch_ReturnsTrue()
+        {
+            // Arrange
+
+            var blockItem = new ItemLevelBlockItem(FilterPredicateOperator.GreaterThan, 10);
+            var lootItem = new LootItem { ItemLevel = 50 };
+
+            // Act
+            var result = blockItem.MatchesLootItem(lootItem);
+
+            // Assert
+            Assert.IsTrue(result);
+        }
+
+        [Test]
+        public void MatchesBlockItem_GreaterThanOrEqualMatch_ReturnsTrue()
+        {
+            // Arrange
+
+            var blockItem = new ItemLevelBlockItem(FilterPredicateOperator.GreaterThanOrEqual, 10);
+            var lootItem = new LootItem { ItemLevel = 50 };
+
+            // Act
+            var result = blockItem.MatchesLootItem(lootItem);
+
+            // Assert
+            Assert.IsTrue(result);
+        }
+
+        [Test]
+        public void MatchesBlockItem_LessThan_ReturnsTrue()
+        {
+            // Arrange
+
+            var blockItem = new ItemLevelBlockItem(FilterPredicateOperator.LessThan, 10);
+            var lootItem = new LootItem { ItemLevel = 1 };
+
+            // Act
+            var result = blockItem.MatchesLootItem(lootItem);
+
+            // Assert
+            Assert.IsTrue(result);
+        }
+
+        [Test]
+        public void MatchesBlockItem_LessThanOrEqual_ReturnsTrue()
+        {
+            // Arrange
+
+            var blockItem = new ItemLevelBlockItem(FilterPredicateOperator.LessThanOrEqual, 10);
+            var lootItem = new LootItem { ItemLevel = 1 };
+
+            // Act
+            var result = blockItem.MatchesLootItem(lootItem);
+
+            // Assert
+            Assert.IsTrue(result);
+        }
+    }
+}

Filtration.ObjectModel.Tests/BlockItemBaseTypes/TestSocketGroupBlockItem.cs

@@ -0,0 +1,92 @@
+using System.Collections.Generic;
+using System.Net.Sockets;
+using Filtration.ObjectModel.BlockItemTypes;
+using Filtration.ObjectModel.Enums;
+using Filtration.ObjectModel.LootExplosionStudio;
+using NUnit.Framework;
+
+namespace Filtration.ObjectModel.Tests.BlockItemBaseTypes
+{
+    [TestFixture]
+    public class TestSocketGroupBlockItem
+    {
+        [Test]
+        public void MatchesBlockItem_BlankLootItem_ReturnsFalse()
+        {
+            // Arrange
+
+            var blockItem = new SocketGroupBlockItem();
+            var testInputLootItem = new LootItem();
+
+            // Act
+            var result = blockItem.MatchesLootItem(testInputLootItem);
+
+            // Assert
+            Assert.IsFalse(result);
+        }
+
+        [Test]
+        public void MatchesBlockItem_SocketsMatch_ReturnsTrue()
+        {
+            // Arrange
+            var testInputSocketGroups = new List<SocketGroup>();
+            var testInputSocketGroup1 = new SocketGroup();
+            var testInputSocketGroup2 = new SocketGroup();
+            testInputSocketGroup1.Sockets = new List<SocketColor> {SocketColor.Blue, SocketColor.Red};
+            testInputSocketGroup2.Sockets = new List<SocketColor>
+            {
+                SocketColor.Blue,
+                SocketColor.Blue,
+                SocketColor.Blue,
+                SocketColor.Red
+            };
+
+            testInputSocketGroups.Add(testInputSocketGroup1);
+            testInputSocketGroups.Add(testInputSocketGroup2);
+
+            var blockItem = new SocketGroupBlockItem();
+            blockItem.Items.Add("RRG");
+            blockItem.Items.Add("BRB");
+
+            var testInputLootItem = new LootItem {SocketGroups = testInputSocketGroups};
+
+            // Act
+            var result = blockItem.MatchesLootItem(testInputLootItem);
+
+            // Assert
+            Assert.IsTrue(result);
+        }
+        
+        [Test]
+        public void MatchesBlockItem_SocketsAlmostMatch_ReturnsFalse()
+        {
+            // Arrange
+            var testInputSocketGroups = new List<SocketGroup>();
+            var testInputSocketGroup1 = new SocketGroup();
+            var testInputSocketGroup2 = new SocketGroup();
+            testInputSocketGroup1.Sockets = new List<SocketColor> { SocketColor.Blue, SocketColor.Red };
+            testInputSocketGroup2.Sockets = new List<SocketColor>
+            {
+                SocketColor.Blue,
+                SocketColor.Blue,
+                SocketColor.Blue,
+                SocketColor.Red,
+                SocketColor.Green
+            };
+
+            testInputSocketGroups.Add(testInputSocketGroup1);
+            testInputSocketGroups.Add(testInputSocketGroup2);
+
+            var blockItem = new SocketGroupBlockItem();
+            blockItem.Items.Add("BGBRWB");
+
+            var testInputLootItem = new LootItem { SocketGroups = testInputSocketGroups };
+
+            // Act
+            var result = blockItem.MatchesLootItem(testInputLootItem);
+
+            // Assert
+            Assert.IsFalse(result);
+        }
+    }
+}

Filtration.ObjectModel.Tests/Filtration.ObjectModel.Tests.csproj

@@ -46,6 +46,10 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="BlockItemBaseTypes\TestBaseTypeBlockItem.cs" />
+    <Compile Include="BlockItemBaseTypes\TestClassBlockItem.cs" />
+    <Compile Include="BlockItemBaseTypes\TestItemLevelBlockItem.cs" />
+    <Compile Include="BlockItemBaseTypes\TestSocketGroupBlockItem.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="TestItemFilterBlock.cs" />
     <Compile Include="TestItemFilterBlockGroup.cs" />

Filtration.ObjectModel/BlockItemBaseTypes/ActionBlockItem.cs

@@ -1,6 +1,7 @@
 using System.Windows.Media;
 using Filtration.ObjectModel.Enums;
 using Filtration.ObjectModel.Extensions;
+using Filtration.ObjectModel.LootExplosionStudio;
 
 namespace Filtration.ObjectModel.BlockItemBaseTypes
 {

Filtration.ObjectModel/BlockItemBaseTypes/ColorBlockItem.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Windows.Media;
+using Filtration.ObjectModel.LootExplosionStudio;
 using Filtration.ObjectModel.ThemeEditor;
 
 namespace Filtration.ObjectModel.BlockItemBaseTypes

Filtration.ObjectModel/BlockItemBaseTypes/DualIntegerBlockItem.cs

@@ -1,4 +1,5 @@
 using System.Windows.Media;
+using Filtration.ObjectModel.LootExplosionStudio;
 
 namespace Filtration.ObjectModel.BlockItemBaseTypes
 {

Filtration.ObjectModel/BlockItemBaseTypes/IntegerBlockItem.cs

@@ -1,4 +1,5 @@
 using System.Windows.Media;
+using Filtration.ObjectModel.LootExplosionStudio;
 
 namespace Filtration.ObjectModel.BlockItemBaseTypes
 {

Filtration.ObjectModel/BlockItemBaseTypes/NumericFilterPredicateBlockItem.cs

@@ -1,6 +1,7 @@
 using System;
 using Filtration.ObjectModel.Enums;
 using Filtration.ObjectModel.Extensions;
+using Filtration.ObjectModel.LootExplosionStudio;
 
 namespace Filtration.ObjectModel.BlockItemBaseTypes
 {
@@ -47,5 +48,45 @@ namespace Filtration.ObjectModel.BlockItemBaseTypes
             OnPropertyChanged("FilterPredicate");
             OnPropertyChanged("SummaryText");
         }
+
+
+
+        public abstract int GetLootItemProperty(LootItem lootItem);
+
+        public virtual bool MatchesLootItem(LootItem lootItem)
+        {
+            var lootItemProperty = GetLootItemProperty(lootItem);
+            var predicateOperand = FilterPredicate.PredicateOperand;
+
+            switch (FilterPredicate.PredicateOperator)
+            {
+                case FilterPredicateOperator.Equal:
+                {
+                    return lootItemProperty == predicateOperand;
+                }
+                case FilterPredicateOperator.GreaterThan:
+                {
+                    return lootItemProperty > predicateOperand;
+                }
+                case FilterPredicateOperator.GreaterThanOrEqual:
+                {
+                    return lootItemProperty >= predicateOperand;
+                }
+                case FilterPredicateOperator.LessThan:
+                {
+                    return lootItemProperty < predicateOperand;
+                }
+                case FilterPredicateOperator.LessThanOrEqual:
+                {
+                    return lootItemProperty <= predicateOperand;
+                }
+                case FilterPredicateOperator.NotEqual:
+                {
+                    return lootItemProperty != predicateOperand;
+                }
+                default:
+                    return false;
+            }
+        }
     }
 }

Filtration.ObjectModel/BlockItemBaseTypes/StringListBlockItem.cs

@@ -2,6 +2,7 @@
 using System.Collections.ObjectModel;
 using System.Collections.Specialized;
 using System.Linq;
+using Filtration.ObjectModel.LootExplosionStudio;
 
 namespace Filtration.ObjectModel.BlockItemBaseTypes
 {
@@ -36,5 +37,12 @@ namespace Filtration.ObjectModel.BlockItemBaseTypes
             OnPropertyChanged("Items");
             OnPropertyChanged("SummaryText");
         }
+
+        public abstract string GetLootItemProperty(LootItem lootItem);
+
+        public virtual bool MatchesLootItem(LootItem lootItem)
+        {
+            return Items.Any(i => i == GetLootItemProperty(lootItem));
+        }
     }
 }

Filtration.ObjectModel/BlockItemTypes/BaseTypeBlockItem.cs

@@ -1,6 +1,7 @@
 using System.Linq;
 using System.Windows.Media;
 using Filtration.ObjectModel.BlockItemBaseTypes;
+using Filtration.ObjectModel.LootExplosionStudio;
 
 namespace Filtration.ObjectModel.BlockItemTypes
 {
@@ -56,5 +57,10 @@ namespace Filtration.ObjectModel.BlockItemTypes
         {
             get { return 11; }
         }
+
+        public override string GetLootItemProperty(LootItem lootItem)
+        {
+            return lootItem.BaseType;
+        }
     }
 }

Filtration.ObjectModel/BlockItemTypes/ClassBlockItem.cs

@@ -1,6 +1,7 @@
 using System.Linq;
 using System.Windows.Media;
 using Filtration.ObjectModel.BlockItemBaseTypes;
+using Filtration.ObjectModel.LootExplosionStudio;
 
 namespace Filtration.ObjectModel.BlockItemTypes
 {
@@ -50,5 +51,10 @@ namespace Filtration.ObjectModel.BlockItemTypes
         {
             get { return 10; }
         }
+
+        public override string GetLootItemProperty(LootItem lootItem)
+        {
+            return lootItem.Class;
+        }
     }
 }

Filtration.ObjectModel/BlockItemTypes/DropLevelBlockItem.cs

@@ -1,6 +1,7 @@
 using System.Windows.Media;
 using Filtration.ObjectModel.BlockItemBaseTypes;
 using Filtration.ObjectModel.Enums;
+using Filtration.ObjectModel.LootExplosionStudio;
 
 namespace Filtration.ObjectModel.BlockItemTypes
 {
@@ -68,5 +69,10 @@ namespace Filtration.ObjectModel.BlockItemTypes
                 return 100;
             }
         }
+
+        public override int GetLootItemProperty(LootItem lootItem)
+        {
+            return lootItem.DropLevel;
+        }
     }
 }

Filtration.ObjectModel/BlockItemTypes/HeightBlockItem.cs

@@ -1,6 +1,7 @@
 using System.Windows.Media;
 using Filtration.ObjectModel.BlockItemBaseTypes;
 using Filtration.ObjectModel.Enums;
+using Filtration.ObjectModel.LootExplosionStudio;
 
 namespace Filtration.ObjectModel.BlockItemTypes
 {
@@ -65,5 +66,10 @@ namespace Filtration.ObjectModel.BlockItemTypes
                 return 6;
             }
         }
+
+        public override int GetLootItemProperty(LootItem lootItem)
+        {
+            return lootItem.Height;
+        }
     }
 }

Filtration.ObjectModel/BlockItemTypes/ItemLevelBlockItem.cs

@@ -1,6 +1,7 @@
 using System.Windows.Media;
 using Filtration.ObjectModel.BlockItemBaseTypes;
 using Filtration.ObjectModel.Enums;
+using Filtration.ObjectModel.LootExplosionStudio;
 
 namespace Filtration.ObjectModel.BlockItemTypes
 {
@@ -67,5 +68,10 @@ namespace Filtration.ObjectModel.BlockItemTypes
                 return 100;
             }
         }
+
+        public override int GetLootItemProperty(LootItem lootItem)
+        {
+            return lootItem.ItemLevel;
+        }
     }
 }

Filtration.ObjectModel/BlockItemTypes/LinkedSocketsBlockItem.cs

@@ -1,6 +1,8 @@
-using System.Windows.Media;
+using System.Linq;
+using System.Windows.Media;
 using Filtration.ObjectModel.BlockItemBaseTypes;
 using Filtration.ObjectModel.Enums;
+using Filtration.ObjectModel.LootExplosionStudio;
 
 namespace Filtration.ObjectModel.BlockItemTypes
 {
@@ -68,5 +70,10 @@ namespace Filtration.ObjectModel.BlockItemTypes
                 return 6;
             }
         }
+
+        public override int GetLootItemProperty(LootItem lootItem)
+        {
+            return lootItem.SocketGroups.Where(c => c.Sockets.Count > 1).Sum(socketGroup => socketGroup.Sockets.Count);
+        }
     }
 }

Filtration.ObjectModel/BlockItemTypes/QualityBlockItem.cs

@@ -1,6 +1,7 @@
 using System.Windows.Media;
 using Filtration.ObjectModel.BlockItemBaseTypes;
 using Filtration.ObjectModel.Enums;
+using Filtration.ObjectModel.LootExplosionStudio;
 
 namespace Filtration.ObjectModel.BlockItemTypes
 {
@@ -68,5 +69,10 @@ namespace Filtration.ObjectModel.BlockItemTypes
                 return 20;
             }
         }
+
+        public override int GetLootItemProperty(LootItem lootItem)
+        {
+            return lootItem.Quality;
+        }
     }
 }

Filtration.ObjectModel/BlockItemTypes/RarityBlockItem.cs

@@ -2,6 +2,7 @@
 using Filtration.ObjectModel.BlockItemBaseTypes;
 using Filtration.ObjectModel.Enums;
 using Filtration.ObjectModel.Extensions;
+using Filtration.ObjectModel.LootExplosionStudio;
 
 namespace Filtration.ObjectModel.BlockItemTypes
 {
@@ -85,5 +86,10 @@ namespace Filtration.ObjectModel.BlockItemTypes
                 return (int)ItemRarity.Unique;
             }
         }
+
+        public override int GetLootItemProperty(LootItem lootItem)
+        {
+            return (int)lootItem.Rarity;
+        }
     }
 }

Filtration.ObjectModel/BlockItemTypes/SocketGroupBlockItem.cs

@@ -1,6 +1,10 @@
-using System.Linq;
+using System;
+using System.Collections.Generic;
+using System.Linq;
 using System.Windows.Media;
 using Filtration.ObjectModel.BlockItemBaseTypes;
+using Filtration.ObjectModel.Enums;
+using Filtration.ObjectModel.LootExplosionStudio;
 
 namespace Filtration.ObjectModel.BlockItemTypes
 {
@@ -47,5 +51,68 @@ namespace Filtration.ObjectModel.BlockItemTypes
         {
             get { return 9; }
         }
+
+        public override string GetLootItemProperty(LootItem lootItem)
+        {
+            return lootItem.SocketGroups.ToString();
+        }
+
+        public override bool MatchesLootItem(LootItem lootItem)
+        {
+            foreach (var socketGroupString in Items)
+            {
+                var socketColorList = SocketGroupStringToSocketColors(socketGroupString);
+                if (
+                    lootItem.SocketGroups.Any(
+                        g =>
+                            g.Sockets.Count(s => s == SocketColor.Red) >=
+                            socketColorList.Count(l => l == SocketColor.Red) &&
+                            g.Sockets.Count(s => s == SocketColor.Green) >=
+                            socketColorList.Count(l => l == SocketColor.Green) &&
+                            g.Sockets.Count(s => s == SocketColor.Blue) >=
+                            socketColorList.Count(l => l == SocketColor.Blue) &&
+                            g.Sockets.Count(s => s == SocketColor.White) >=
+                            socketColorList.Count(l => l == SocketColor.White)))
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        private List<SocketColor> SocketGroupStringToSocketColors(string socketGroupString)
+        {
+            var socketColorList = new List<SocketColor>();
+
+            foreach (var c in socketGroupString.ToCharArray())
+            {
+                switch (c)
+                {
+                    case 'R':
+                    {
+                        socketColorList.Add(SocketColor.Red);
+                        break;
+                    }
+                    case 'G':
+                    {
+                        socketColorList.Add(SocketColor.Green);
+                        break;
+                    }
+                    case 'B':
+                    {
+                        socketColorList.Add(SocketColor.Blue);
+                        break;
+                    }
+                    case 'W':
+                    {
+                        socketColorList.Add(SocketColor.White);
+                        break;
+                    }
+                }
+            }
+
+            return socketColorList;
+        }
     }
 }

Filtration.ObjectModel/BlockItemTypes/SocketsBlockItem.cs

@@ -1,6 +1,8 @@
-using System.Windows.Media;
+using System.Linq;
+using System.Windows.Media;
 using Filtration.ObjectModel.BlockItemBaseTypes;
 using Filtration.ObjectModel.Enums;
+using Filtration.ObjectModel.LootExplosionStudio;
 
 namespace Filtration.ObjectModel.BlockItemTypes
 {
@@ -68,5 +70,10 @@ namespace Filtration.ObjectModel.BlockItemTypes
                 return 6;
             }
         }
+
+        public override int GetLootItemProperty(LootItem lootItem)
+        {
+            return lootItem.SocketGroups.Sum(c => c.Sockets.Count());
+        }
     }
 }

Filtration.ObjectModel/BlockItemTypes/WidthBlockItem.cs

@@ -1,6 +1,7 @@
 using System.Windows.Media;
 using Filtration.ObjectModel.BlockItemBaseTypes;
 using Filtration.ObjectModel.Enums;
+using Filtration.ObjectModel.LootExplosionStudio;
 
 namespace Filtration.ObjectModel.BlockItemTypes
 {
@@ -68,5 +69,10 @@ namespace Filtration.ObjectModel.BlockItemTypes
                 return 2;
             }
         }
+
+        public override int GetLootItemProperty(LootItem lootItem)
+        {
+            return lootItem.Width;
+        }
     }
 }

Filtration.ObjectModel/Filtration.ObjectModel.csproj

@@ -41,7 +41,7 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="BlockItemBaseTypes\ActionBlockItem.cs" />
-    <Compile Include="BlockItemBaseTypes\BlockItembase.cs" />
+    <Compile Include="BlockItemBaseTypes\BlockItemBase.cs" />
     <Compile Include="BlockItemBaseTypes\ColorBlockItem.cs" />
     <Compile Include="BlockItemBaseTypes\DualIntegerBlockItem.cs" />
     <Compile Include="BlockItemBaseTypes\IntegerBlockItem.cs" />
@@ -77,6 +77,10 @@
     <Compile Include="ItemFilterBlockGroup.cs" />
     <Compile Include="ItemFilterScript.cs" />
     <Compile Include="ItemFilterSection.cs" />
+    <Compile Include="LootExplosionStudio\DefaultLootItemAppearanceConstants.cs" />
+    <Compile Include="LootExplosionStudio\LootItem.cs" />
+    <Compile Include="LootExplosionStudio\LootItemCollection.cs" />
+    <Compile Include="LootExplosionStudio\SocketGroup.cs" />
     <Compile Include="NumericFilterPredicate.cs" />
     <Compile Include="Properties\Annotations.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />

Filtration.ObjectModel/LootExplosionStudio/DefaultLootItemAppearanceConstants.cs

@@ -0,0 +1,16 @@
+using System.Windows.Media;
+
+namespace Filtration.ObjectModel.LootExplosionStudio
+{
+    public static class DefaultLootItemAppearanceConstants
+    {
+        public readonly static Color NormalTextColor = new Color { A = 255, R = 200, G = 200, B = 200 };
+        public readonly static Color MagicTextColor = new Color { A = 255, R = 136, G = 136, B = 255 };
+        public readonly static Color RareTextColor = new Color { A = 255, R = 255, G = 255, B = 119 };
+        public readonly static Color UniqueTextColor = new Color { A = 255, R = 175, G = 96, B = 37 };
+        public readonly static Color QuestItemTextColor = new Color { A = 255, R = 74, G = 230, B = 58 };
+        public static readonly Color BackgroundColor = new Color {A = 255, R = 0, G = 0, B = 0};
+        public static readonly Color BorderColor = new Color { A = 255, R = 0, G = 0, B = 0 };
+        public static readonly int FontSize = 35;
+    }
+}

Filtration.ObjectModel/LootExplosionStudio/LootItem.cs

@@ -0,0 +1,25 @@
+using System.Collections.Generic;
+using System.Windows.Media;
+using Filtration.ObjectModel.Enums;
+
+namespace Filtration.ObjectModel.LootExplosionStudio
+{
+    public class LootItem
+    {
+        public string Name { get; set; }
+        public int ItemLevel { get; set; }
+        public int DropLevel { get; set; }
+        public int Quality { get; set; }
+        public ItemRarity Rarity { get; set; }
+        public string Class { get; set; }
+        public string BaseType { get; set; }
+        public List<SocketGroup> SocketGroups { get; set; }
+        public int Width { get; set; }
+        public int Height { get; set; }
+        
+        public Color TextColor { get; set; }
+        public Color BackgroundColor { get; set; }
+        public Color BorderColor { get; set; }
+        public int FontSize { get; set; }
+    }
+}

Filtration.ObjectModel/LootExplosionStudio/LootItemCollection.cs

@@ -0,0 +1,9 @@
+using System.Collections.ObjectModel;
+
+namespace Filtration.ObjectModel.LootExplosionStudio
+{
+    public class LootItemCollection : Collection<LootItem>
+    {
+
+    }
+}

Filtration.ObjectModel/LootExplosionStudio/SocketGroup.cs

@@ -0,0 +1,10 @@
+using System.Collections.Generic;
+using Filtration.ObjectModel.Enums;
+
+namespace Filtration.ObjectModel.LootExplosionStudio
+{
+    public class SocketGroup
+    {
+        public List<SocketColor> Sockets { get; set; }
+    }
+}

Filtration.sln

@@ -21,6 +21,10 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Filtration.Common", "Filtra
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Filtration.Common.Tests", "Filtration.Common.Tests\Filtration.Common.Tests.csproj", "{1E42A658-45C4-4DD9-83C5-2A10728DBDFA}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Filtration.LootExplosionStudio", "Filtration.LootExplosionStudio\Filtration.LootExplosionStudio.csproj", "{C8009B11-14D0-4421-94F0-9EF4603CB363}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Filtration.LootExplosionStudio.Tests", "Filtration.LootExplosionStudio.Tests\Filtration.LootExplosionStudio.Tests.csproj", "{56D0887E-B10D-4F9C-A88E-09CF8E8E06E3}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -63,6 +67,14 @@ Global
 		{1E42A658-45C4-4DD9-83C5-2A10728DBDFA}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{1E42A658-45C4-4DD9-83C5-2A10728DBDFA}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{1E42A658-45C4-4DD9-83C5-2A10728DBDFA}.Release|Any CPU.Build.0 = Release|Any CPU
+		{C8009B11-14D0-4421-94F0-9EF4603CB363}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{C8009B11-14D0-4421-94F0-9EF4603CB363}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{C8009B11-14D0-4421-94F0-9EF4603CB363}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{C8009B11-14D0-4421-94F0-9EF4603CB363}.Release|Any CPU.Build.0 = Release|Any CPU
+		{56D0887E-B10D-4F9C-A88E-09CF8E8E06E3}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{56D0887E-B10D-4F9C-A88E-09CF8E8E06E3}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{56D0887E-B10D-4F9C-A88E-09CF8E8E06E3}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{56D0887E-B10D-4F9C-A88E-09CF8E8E06E3}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

Filtration/Properties/AssemblyInfo.cs

@@ -50,7 +50,7 @@ using System.Windows;
 // You can specify all the values or you can default the Build and Revision Numbers 
 // by using the '*' as shown below:
 // [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("0.6.*")]
+[assembly: AssemblyVersion("0.7.*")]
 
 [assembly: InternalsVisibleTo("Filtration.Tests")]
 [assembly: InternalsVisibleTo("DynamicProxyGenAssembly2")]