Building a WPF Sudoku Game: Part 5 - The AI Battle: Loading and Comparing AI Plug-ins (zz)

string[]plugins=Directory.GetFiles("Solvers//","*.dll");
foreach(stringpinplugins)
{
LoadSolvers(p);
}

ObservableCollection<ISudokuSolver>Solvers=
newObservableCollection<ISudokuSolver>();

<?xmlversion="1.0"encoding="utf-8"?>
<configuration>
<runtime>
<assemblyBindingxmlns="urn:schemas-microsoft-com:asm.v1">
<probingprivatePath="Solvers"/>
</assemblyBinding>
</runtime>
</configuration>

AppDomainSetupads=newAppDomainSetup();
ads.ApplicationBase=AppDomain.CurrentDomain.BaseDirectory;
ads.PrivateBinPath=System.IO.Path.GetDirectoryName(System.IO.Path.GetFullPath(path));
PermissionSetps=newPermissionSet(null);
ps.AddPermission(newSecurityPermission(SecurityPermissionFlag.Execution));
SolverDomain=AppDomain.CreateDomain("NewAD",null,ads,ps);

Type[]ts=asm.GetTypes();
foreach(Typetints)
{
if(Array.IndexOf(t.GetInterfaces(),typeof(ISudokuSolver))!=-1)
{
Typecontainer=typeof(SudokuSolverContainer);
SudokuSolverContainerssc=SolverDomain.CreateInstanceAndUnwrap(
container.Assembly.FullName,container.FullName)
asSudokuSolverContainer;
ssc.Init(t);
Solvers.Add(ssc);
}
}

<StackPanelx:Name="InfoPanel"
DataContext="{BindingElementName=SolverList,Path=SelectedItem}">
<TextBlockForeground="Black"Text="SolverInfo:"FontWeight="Bold"FontSize="12"/>
<TextBlockFontSize="8"Text=""/>
<TextBlockForeground="Black"Text="{BindingPath=Name}"/>
<TextBlockForeground="Black"Text="{BindingPath=Author}"/>
<TextBlockFontSize="8"Text=""/>
<TextBlockForeground="Black"Text="{BindingPath=Description}"
HorizontalAlignment="Stretch"TextWrapping="WrapWithOverflow"/>
</StackPanel>

publicstaticreadonlyDependencyPropertyBarHeightProperty=
DependencyProperty.RegisterAttached("BarHeight",typeof(double),
typeof(DependencyObject),newPropertyMetadata(0.0));

publicstaticdoubleGetBarHeight(DependencyObjectd)
{
return(double)d.GetValue(BarHeightProperty);
}

publicstaticvoidSetBarHeight(DependencyObjectd,doubleh)
{
d.SetValue(BarHeightProperty,h);
}

publicclassSolverResult:DependencyObject
{
TimeSpantimeTaken;

publicTimeSpanTimeTaken
{
get
{
returntimeTaken;
}
set
{
timeTaken=value;
}
}

ISudokuSolversolver;

publicISudokuSolverSolver
{
get
{
returnsolver;
}
set
{
solver=value;
}
}

boolfailed;

publicboolFailed
{
get
{
returnfailed;
}
set
{
failed=value;
}
}
}

protectedoverridevoidOnItemsChanged(
System.Collections.Specialized.NotifyCollectionChangedEventArgse)
{
base.OnItemsChanged(e);
longmaxVal=0;
foreach(SolverResultsinItems)
{
if(!s.Failed&&s.TimeTaken.Ticks>maxVal)maxVal=s.TimeTaken.Ticks;
}

foreach(SolverResultsinItems)
{
if(s.Failed)
{
GraphControl.SetBarHeight(s,ActualHeight-25);
}
else
{
doubleh=(double)s.TimeTaken.Ticks/
(double)maxVal*(ActualHeight-25);
if(h>10)
{
GraphControl.SetBarHeight(s,h);
}
else
{
GraphControl.SetBarHeight(s,10);
}
}
GraphControl.SetIndex(s,Items.IndexOf(s));
}
}

<DataTemplatex:Key="BarTemplate">
<Gridx:Name="Bar"Margin="3,3,3,0"Width="50"VerticalAlignment="Bottom"
Height="{BindingPath=BarHeight}"Background="Red">
<TextBlockx:Name="BarText"VerticalAlignment="Center"
Foreground="White"HorizontalAlignment="Center"
Text="{BindingPath=TimeTaken}">
<TextBlock.LayoutTransform>
<RotateTransformAngle="90"/>
</TextBlock.LayoutTransform>
</TextBlock>
</Grid>
<DataTemplate.Triggers>
<DataTriggerBinding="{BindingPath=Failed}"Value="True">
<SetterTargetName="Bar"Property="Opacity"Value="0.5"/>
<SetterTargetName="BarText"Property="Text"Value="Failed"/>
</DataTrigger>
</DataTemplate.Triggers>
</DataTemplate>

[ValueConversion(typeof(int),typeof(Color))]
publicclassBarColorConverter:IValueConverter
{
staticColor[]BarColors={
Colors.SteelBlue,
Colors.Green,
Colors.Firebrick,
Colors.DarkSlateGray,
Colors.Orange,
Colors.Khaki
};

publicobjectConvert(objectvalue,TypetargetType,objectparameter,

CultureInfoculture)
{
intv=(int)value;
returnBarColors[v%BarColors.Length];
}

publicobjectConvertBack(objectvalue,TypetargetType,objectparameter,

CultureInfoculture)
{
Colorv=(Color)value;
returnArray.IndexOf<Color>(BarColors,v);
}
}

<Grid.Background>
<SolidColorBrush
Color="{BindingPath=Index,Converter={StaticResourceBarColorConverter}}"/>
</Grid.Background>

[ValueConversion(typeof(Color),typeof(Color))]
publicclassColorLightnessConverter:IValueConverter
{
publicobjectConvert(objectvalue,TypetargetType,
objectparameter,CultureInfoculture)
{
if(value==null)returnnull;
intparam=int.Parse(parameter.ToString());
Colorsrc=(Color)value;
Colorret=newColor();
ret.A=src.A;
ret.R=(byte)Math.Max(Math.Min(src.R+param,255),0);
ret.G=(byte)Math.Max(Math.Min(src.G+param,255),0);
ret.B=(byte)Math.Max(Math.Min(src.B+param,255),0);
returnret;
}

publicobjectConvertBack(objectvalue,TypetargetType,
objectparameter,CultureInfoculture)
{
if(value==null)returnnull;
intparam=int.Parse(parameter.ToString());
Colorsrc=(Color)value;
Colorret=newColor();
ret.A=src.A;
ret.R=(byte)Math.Max(Math.Min(src.R-param,255),0);
ret.G=(byte)Math.Max(Math.Min(src.G-param,255),0);
ret.B=(byte)Math.Max(Math.Min(src.B-param,255),0);
returnret;
}
}

Tag="{BindingPath=Index,Converter={StaticResourceBarColorConverter}}"

<RectangleRadiusX="3"RadiusY="3"StrokeThickness="2"VerticalAlignment="Stretch"
HorizontalAlignment="Stretch">
<Rectangle.Stroke>
<SolidColorBrushColor="{BindingElementName=Bar,Path=Tag,
Converter={StaticResourceColorLightnessConverter},ConverterParameter=-64}"/>
</Rectangle.Stroke>
<Rectangle.Fill>
<LinearGradientBrushSpreadMethod="Repeat"MappingMode="Absolute"
StartPoint="0,0"EndPoint="1,1">
<LinearGradientBrush.Transform>
<ScaleTransformScaleX="20"ScaleY="20"/>
</LinearGradientBrush.Transform>
<LinearGradientBrush.GradientStops>
<GradientStop
Color="{BindingElementName=Bar,Path=Tag,
Converter={StaticResourceColorLightnessConverter},
ConverterParameter=-32}"Offset="0"/>
<GradientStop
Color="{BindingElementName=Bar,Path=Tag,
Converter={StaticResourceColorLightnessConverter},
ConverterParameter=-32}"Offset="0.499"/>
<GradientStopColor="{BindingElementName=Bar,Path=Tag}"Offset="0.501"/>
<GradientStopColor="{BindingElementName=Bar,Path=Tag}"Offset="1"/>
</LinearGradientBrush.GradientStops>
</LinearGradientBrush>
</Rectangle.Fill>
</Rectangle>

<ListBox.ItemContainerStyle>
<StyleTargetType="{x:TypeListBoxItem}">
<SetterProperty="VerticalContentAlignment"Value="Bottom"/>
<Style.Triggers>
<TriggerProperty="IsVisible"Value="true">
<Trigger.EnterActions>
<BeginStoryboard>
<Storyboard>
<DoubleAnimationFrom="0"To="1"
Storyboard.TargetProperty="Opacity"Duration="0:0:0.5"/>
</Storyboard>
</BeginStoryboard>
</Trigger.EnterActions>
</Trigger>
</Style.Triggers>
</Style>
</ListBox.ItemContainerStyle>

voidBenchmarkClick(objectsender,RoutedEventArgse)
{
SolverResults=newSolverResult();
s.Solver=SolverList.SelectedItemasISudokuSolver;
int?[,]arr=Board.GameBoard.ToArray();
BenchButton.IsEnabled=false;
longtick=DateTime.Now.Ticks;
s.Failed=!s.Solver.Solve(refarr);
s.TimeTaken=TimeSpan.FromTicks((DateTime.Now.Ticks-tick));
Graph.Items.Add(s);
BenchButton.IsEnabled=true;
}

BackgroundWorkersolverWorker;

voidBenchmarkClick(objectsender,RoutedEventArgse)
{
SolverResults=newSolverResult();
s.Solver=SolverList.SelectedItemasISudokuSolver;
int?[,]arr=Board.GameBoard.ToArray();
BenchButton.IsEnabled=false;
InfoPanel.Visibility=Visibility.Hidden;
WaitPanel.Visibility=Visibility.Visible;
longtick=DateTime.Now.Ticks;
solverWorker=newBackgroundWorker();
solverWorker.DoWork+=new
DoWorkEventHandler(delegate(objectdwsender,DoWorkEventArgsdwe)
{
s.Failed=!s.Solver.Solve(refarr);
s.TimeTaken=TimeSpan.FromTicks((DateTime.Now.Ticks-tick));
});
solverWorker.RunWorkerCompleted+=newRunWorkerCompletedEventHandler(
delegate(objectrwcsender,RunWorkerCompletedEventArgsrwce)
{
Graph.Items.Add(s);
InfoPanel.Visibility=Visibility.Visible;
WaitPanel.Visibility=Visibility.Hidden;
BenchButton.IsEnabled=true;
});
solverWorker.RunWorkerAsync();
}

<GridIsHitTestVisible="False"IsEnabled="False"x:Name="MessageLayer"
Opacity="0"HorizontalAlignment="Stretch"VerticalAlignment="Stretch"
Background="#B0000000">
<Grid.Style>
<Style>
<Style.Triggers>
<TriggerProperty="Grid.IsEnabled"Value="True">
<Trigger.EnterActions>
<BeginStoryboard>
<Storyboard>
<DoubleAnimationTo="1"Storyboard.TargetProperty="Opacity"
Duration="0:0:0.25"/>
<BooleanAnimationUsingKeyFrames
Storyboard.TargetProperty="IsHitTestVisible"
BeginTime="0:0:0.25">
<DiscreteBooleanKeyFrameKeyTime="0"Value="True"/>
</BooleanAnimationUsingKeyFrames>
</Storyboard>
</BeginStoryboard>
</Trigger.EnterActions>
<Trigger.ExitActions>
<BeginStoryboard>
<Storyboard>
<DoubleAnimationTo="0"Storyboard.TargetProperty="Opacity"
Duration="0:0:0.25"/>
<BooleanAnimationUsingKeyFrames
Storyboard.TargetProperty="IsHitTestVisible"
BeginTime="0:0:0.25">
<DiscreteBooleanKeyFrameKeyTime="0"Value="False"/>
</BooleanAnimationUsingKeyFrames>
</Storyboard>
</BeginStoryboard>
</Trigger.ExitActions>
</Trigger>
</Style.Triggers>
</Style>
</Grid.Style>
</Grid>

voidShowMessage(stringm)
{
MessageText.Text=m;
MessageExpander.Visibility=Visibility.Visible;
WaitExpander.Visibility=Visibility.Hidden;
MessageLayer.IsEnabled=true;
}

voidShowWait()
{
MessageExpander.Visibility=Visibility.Hidden;
WaitExpander.Visibility=Visibility.Visible;
MessageLayer.IsEnabled=true;
}

voidMessageClosed(objectsender,RoutedEventArgse)
{
MessageLayer.IsEnabled=false;
}