/// <summary>
/// The Selected has changed.
/// </summary>
/// <param name="control"></param>
/// <param name="selectedIndex"></param>
public void OnTextChanged(Control control, string text)
{
// first attempt casting the control as LabelTextBoxControl
LabelTextBoxControl sender = control as LabelTextBoxControl;
// if the sender and Options objects both exist
if (NullHelper.Exists(sender, Options))
{
// if this is the ResolutionControl
if (sender.Name == ResolutionControl.Name)
{
// Set the Resolution
Options.Resolution = NumericHelper.ParseInteger(text, 0, -1);
}
}
// now try LabelTextBoxBrowserControl
LabelTextBoxBrowserControl sender2 = control as LabelTextBoxBrowserControl;
// if the sender2 and Options objects both exist
if (NullHelper.Exists(sender2, Options))
{
// verify we have the correct control
if (sender2.Name == DirectoryControl.Name)
{
// Set the Directory
Options.Directory = text;
}
}
// Enable or disable the StartButton
UIControl();
}
/// <summary>
/// This event is fired BEFORE the collection is initialized.
/// An example of this is the replacements (plural) node.
/// </summary>
/// <param name="xmlNode"></param>
/// <returns>True if cancelled else false if not.</returns>
public bool Parsing(XmlNode xmlNode)
{
// initial value
bool cancel = false;
try
{
// set the commentID
int commentID = NumericHelper.ParseInteger(xmlNode.ParentNode.ChildNodes[0].FormattedNodeValue, 0, -1);
// if this is the Comment being sought
if (commentID != this.CommentID)
{
// Set the value for the cancel to true
cancel = true;
}
}
catch (Exception error)
{
// for debugging only
string err = error.ToString();
}
// return value
return(cancel);
}
/// <summary>
/// This method is used to parse Response objects.
/// </summary>
public Response ParseResponse(ref Response response, XmlNode xmlNode)
{
// if the response object exists and the xmlNode exists
if ((response != null) && (xmlNode != null))
{
// get the full name of this node
string fullName = xmlNode.GetFullName();
// Check the name of this node to see if it is mapped to a property
switch (fullName)
{
case "ResponseDoc.response.entitylineNumber":
// Set the value for response.EntitylineNumber
response.EntitylineNumber = NumericHelper.ParseInteger(xmlNode.FormattedNodeValue, 0, -1);
// required
break;
case "ResponseDoc.response.entityMark":
// Set the value for response.EntityMark
response.EntityMark = xmlNode.FormattedNodeValue;
// required
break;
case "ResponseDoc.response.entityUid":
// Set the value for response.EntityUID
response.EntityUID = xmlNode.FormattedNodeValue;
// required
break;
case "ResponseDoc.response.statusCode":
// Set the value for response.StatusCode
response.StatusCode = xmlNode.FormattedNodeValue;
// required
break;
}
// if there are ChildNodes
if (xmlNode.HasChildNodes)
{
// iterate the child nodes
foreach (XmlNode childNode in xmlNode.ChildNodes)
{
// append to this Response
response = ParseResponse(ref response, childNode);
}
}
}
// return value
return(response);
}
/// <summary>
/// This method is used to parse Note objects.
/// </summary>
public Note ParseNote(ref Note note, XmlNode xmlNode)
{
// if the note object exists and the xmlNode exists
if ((note != null) && (xmlNode != null))
{
// get the full name of this node
string fullName = xmlNode.GetFullName();
// Check the name of this node to see if it is mapped to a property
switch (fullName)
{
case "Notes.Note.Description":
// Set the value for note.Description
note.Description = xmlNode.FormattedNodeValue;
// required
break;
case "Notes.Note.Id":
// Set the value for note.Id
note.Id = NumericHelper.ParseInteger(xmlNode.FormattedNodeValue, 0, -1);
// required
break;
case "Notes.Note.Priority":
// Set the value for note.Priority
note.Priority = EnumHelper.GetEnumValue <NoteBoard.Model.PriorityEnum>(xmlNode.FormattedNodeValue, NoteBoard.Model.PriorityEnum.Normal);
// required
break;
case "Notes.Note.Title":
// Set the value for note.Title
note.Title = xmlNode.FormattedNodeValue;
// required
break;
}
// if there are ChildNodes
if (xmlNode.HasChildNodes)
{
// iterate the child nodes
foreach (XmlNode childNode in xmlNode.ChildNodes)
{
// append to this Note
note = ParseNote(ref note, childNode);
}
}
}
// return value
return(note);
}
/// <summary>
/// This class is used to Shuffle a list of type 'T'.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="list"></param>
public static List <T> Shuffle <T>(this IList <T> list)
{
// List
List <T> shuffledList = new List <T>();
// Use the RNGCryptoServiceProvider to create random zeros or 1
RNGCryptoServiceProvider crypto = new RNGCryptoServiceProvider();
// Create the byte array that serves asa
byte[] container = new byte[1];
// if the list exists
if (list != null)
{
// we can't use the collection count it changes
int listCount = list.Count;
// now we have to 'Randomly' pull items and add them to the end results
for (int x = 0; x < listCount; x++)
{
// Fill the topOrBottom byteArray
crypto.GetBytes(container);
// Get the value of topOrBottom
object randomByte = container.GetValue(0);
// if the randomByte exists
if (NullHelper.Exists(randomByte))
{
// local
int randomValue = NumericHelper.ParseInteger(randomByte.ToString(), 0, -1);
// set the randomIndex to the modulas of the the listCount
int randomIndex = randomValue % list.Count;
// verify the index is in range (should always be true)
if ((randomIndex >= 0) && (randomIndex < list.Count))
{
// Add the card from the top half of the list
shuffledList.Add(list[randomIndex]);
}
// Remove the item from the sourceList now that we have it
list.RemoveAt(randomIndex);
}
}
}
// return value
return(shuffledList);
}
/// <summary>
/// This method is used to parse StoredProcedureParameter objects.
/// </summary>
public StoredProcedureParameter ParseStoredProcedureParameter(ref StoredProcedureParameter storedProcedureParameter, XmlNode xmlNode)
{
// if the storedProcedureParameter object exists and the xmlNode exists
if ((storedProcedureParameter != null) && (xmlNode != null))
{
// get the full name of this node
string fullName = xmlNode.GetFullName();
// Check the name of this node to see if it is mapped to a property
switch (fullName)
{
case "Database.StoredProcedures.StoredProcedure.Parameters.StoredProcedureParameter.DataType":
// Set the value for storedProcedureParameter.DataType
storedProcedureParameter.DataType = EnumHelper.GetEnumValue <DataManager.DataTypeEnum>(xmlNode.FormattedNodeValue, DataManager.DataTypeEnum.NotSupported);
// required
break;
case "Database.StoredProcedures.StoredProcedure.Parameters.StoredProcedureParameter.Length":
// Set the value for storedProcedureParameter.Length
storedProcedureParameter.Length = NumericHelper.ParseInteger(xmlNode.FormattedNodeValue, 0, -1);
// required
break;
case "Database.StoredProcedures.StoredProcedure.Parameters.StoredProcedureParameter.ParameterName":
// Set the value for storedProcedureParameter.ParameterName
storedProcedureParameter.ParameterName = xmlNode.FormattedNodeValue;
// required
break;
}
// if there are ChildNodes
if (xmlNode.HasChildNodes)
{
// iterate the child nodes
foreach (XmlNode childNode in xmlNode.ChildNodes)
{
// append to this StoredProcedureParameter
storedProcedureParameter = ParseStoredProcedureParameter(ref storedProcedureParameter, childNode);
}
}
}
// return value
return(storedProcedureParameter);
}
/// <summary>
/// This method is used to parse IgnoreFolderException objects.
/// </summary>
public IgnoreFolderException ParseIgnoreFolderException(ref IgnoreFolderException ignoreFolderException, XmlNode xmlNode)
{
// if the ignoreFolderException object exists and the xmlNode exists
if ((ignoreFolderException != null) && (xmlNode != null))
{
// get the full name of this node
string fullName = xmlNode.GetFullName();
// Check the name of this node to see if it is mapped to a property
switch (fullName)
{
case "Shipment.Options.DoNotCopyContentFolders.Folder.Exceptions.Exception.ExceptionType":
// Set the value for ignoreFolderException.ExceptionTypeValue
ignoreFolderException.ExceptionTypeValue = NumericHelper.ParseInteger(xmlNode.FormattedNodeValue, 0, -1);
// required
break;
case "Shipment.Options.DoNotCopyContentFolders.Folder.Exceptions.Exception.Name":
// Set the value for ignoreFolderException.Name
ignoreFolderException.Name = xmlNode.FormattedNodeValue;
// required
break;
case "Shipment.Options.DoNotCopyContentFolders.Folder.Exceptions.Exception.Text":
// Set the value for ignoreFolderException.Text
ignoreFolderException.Text = xmlNode.FormattedNodeValue;
// required
break;
}
// if there are ChildNodes
if (xmlNode.HasChildNodes)
{
// iterate the child nodes
foreach (XmlNode childNode in xmlNode.ChildNodes)
{
// append to this IgnoreFolderException
ignoreFolderException = ParseIgnoreFolderException(ref ignoreFolderException, childNode);
}
}
}
// return value
return(ignoreFolderException);
}
/// <summary>
/// This method returns the Bet Amount
/// </summary>
internal double GetBetAmount()
{
// initial value
double betAmount = 0;
// Remove any dollar signs or commas if present
string betAmountText = this.BetAmountTextBox.Text.Replace("$", "").Replace(",", "");
// set the return value
betAmount = NumericHelper.ParseInteger(betAmountText, 0, -1);
// return value
return(betAmount);
}
/// <summary>
/// This event registers with the chat server
/// </summary>
public void RegisterWithServer()
{
SubscriberCallback callback = new SubscriberCallback(SubscriberName);
callback.Callback = Listen;
callback.Name = SubscriberName;
// Get a message back
SubscriberMessage message = SubscriberService.Subscribe(callback);
// if message.Text exists and equals Subscribed
if ((NullHelper.Exists(message)) && (message.HasText) && (TextHelper.IsEqual(message.Text, "Subscribed")))
{
// Set to true
Connected = true;
// Set the Id the Server assigned
this.Id = message.ToId;
}
// Convert the Subscribers to Names
this.Names = SubscriberService.GetSubscriberNames();
// get the count
int count = NumericHelper.ParseInteger(message.Data.ToString(), 0, -1);
// if there are two people online or more
if (count > 1)
{
// send a message to everyone else this user has joined
SubscriberMessage newMessage = new SubscriberMessage();
// set the text
newMessage.FromId = Id;
newMessage.FromName = SubscriberName;
newMessage.Text = SubscriberName + " has joined the conversation.";
newMessage.ToId = Guid.Empty;
newMessage.ToName = "Room";
newMessage.IsSystemMessage = true;
// Send the message
SubscriberService.BroadcastMessage(newMessage);
// 6.5.2020: Get the Messages as you connect now
this.Messages = SubscriberService.GetBroadcastMessages(this.Id, DisplayMessagesCount);
}
// Update
Refresh();
}
/// <summary>
/// This method Parse Numbers
/// </summary>
public static void ParseNumbers(string text, ref int number1, ref int number2, ref int number3, ref int number4)
{
// locals
int count = 0;
// only use a space as a delimiter character
char[] delimiterChars = { ' ' };
// if the words exists
List <Word> words = WordParser.GetWords(text, delimiterChars);
// If the words collection exists and has one or more items
if (ListHelper.HasOneOrMoreItems(words))
{
// Iterate the collection of Word objects
foreach (Word word in words)
{
// if this word is a number
if (NumericHelper.IsNumeric(word.Text))
{
// Increment the value for count
count++;
// if this is the firstNumber
if (count == 1)
{
// set number1
number1 = NumericHelper.ParseInteger(word.Text, -1000, -1001);
}
else if (count == 2)
{
// set number2
number2 = NumericHelper.ParseInteger(word.Text, -1000, -1001);
}
else if (count == 3)
{
// set number3
number3 = NumericHelper.ParseInteger(word.Text, -1000, -1001);
}
else if (count == 4)
{
// set number4
number4 = NumericHelper.ParseInteger(word.Text, -1000, -1001);
}
}
}
}
}
/// <summary>
/// This method returns the Game Manager
/// </summary>
private GameManager CaptureGameManager()
{
// initial value
GameManager gameManager = null;
// If the Table object exists
if (this.HasTable)
{
// Create the return value
gameManager = new GameManager(NumericHelper.ParseInteger(Properties.Resources.TimesToShuffle, 0, -1), this.Table);
// Capture the Seated Players
gameManager.Players = this.SelectPlayersControl.CaptureSeatedPlayers();
// Capture the House Rules
gameManager.HouseRules = this.OptionsControl.CaptureHouseRules();
gameManager.HouseRules.SaveSettingsOnThisComputer = this.SaveSettingsRadioButton.Checked;
}
// return value
return(gameManager);
}
/// <summary>
/// This method is used to parse CodeComment objects.
/// </summary>
public CodeComment ParseCodeComment(ref CodeComment codeComment, XmlNode xmlNode)
{
// if the codeComment object exists and the xmlNode exists
if ((codeComment != null) && (xmlNode != null))
{
// get the full name of this node
string fullName = xmlNode.GetFullName();
// Check the name of this node to see if it is mapped to a property
switch (fullName)
{
case "CommentDictionary.CommentItem.Comment":
// Set the value for codeComment.Comment
codeComment.Comment = xmlNode.FormattedNodeValue;
// required
break;
case "CommentDictionary.CommentItem.HasReplacements":
// Set the value for codeComment.Comment
codeComment.HasReplacements = BooleanHelper.ParseBoolean(xmlNode.FormattedNodeValue, false, false);
// required
break;
case "CommentDictionary.CommentItem.ID":
// Set the value for codeComment.Name
codeComment.ID = NumericHelper.ParseInteger(xmlNode.FormattedNodeValue, 0, -1);
// required
break;
case "CommentDictionary.CommentItem.Name":
// Set the value for codeComment.Name
codeComment.Name = xmlNode.FormattedNodeValue;
// required
break;
case "CommentDictionary.CommentItem.Pattern":
// Set the value for codeComment.Pattern
codeComment.Pattern = xmlNode.FormattedNodeValue;
// required
break;
case "CommentDictionary.CommentItem.TargetPattern":
// Set the value for codeComment.TargetPattern
codeComment.TargetPattern = xmlNode.FormattedNodeValue;
// required
break;
case "CommentDictionary.CommentItem.TargetPattern2":
// Set the value for codeComment.TargetPattern2
codeComment.TargetPattern2 = xmlNode.FormattedNodeValue;
// required
break;
case "CommentDictionary.CommentItem.Type":
// Set the value for codeComment.CommentType
// codeComment.CommentType = // this field must be parsed manually.
// required
break;
}
// if there are ChildNodes
if (xmlNode.HasChildNodes)
{
// iterate the child nodes
foreach (XmlNode childNode in xmlNode.ChildNodes)
{
// append to this CodeComment
codeComment = ParseCodeComment(ref codeComment, childNode);
}
}
}
// return value
return(codeComment);
}
/// <summary>
/// This method Set Update Parameters
/// </summary>
public static void SetUpdateParameters(string updateText, ref PixelQuery pixelQuery)
{
// if the updateText exists and the pixelQuery object exists
if ((TextHelper.Exists(updateText)) && (NullHelper.Exists(pixelQuery)))
{
// if the updateText starts with the word set (else this is not a proper BQL Update query).
if (updateText.StartsWith("set"))
{
// only use a space as a delimiter character
char[] delimiterChars = { ' ' };
// Get a list of words from this text
List <Word> words = WordParser.GetWords(updateText);
// If the words collection exists and has one or more items
if (ListHelper.HasOneOrMoreItems(words))
{
// if there are six words.
// Example: Set Color 100 150 200 40 - (Red = 100, Green = 150, Blue = 200, Alpha = 40)
if (words.Count == 6)
{
// Set to red
pixelQuery.Red = NumericHelper.ParseInteger(words[2].Text, -1, -2);
pixelQuery.Green = NumericHelper.ParseInteger(words[3].Text, -1, -2);
pixelQuery.Blue = NumericHelper.ParseInteger(words[4].Text, -1, -2);
pixelQuery.Alpha = NumericHelper.ParseInteger(words[5].Text, -1, -2);
// verify everything is valid
if ((pixelQuery.Red >= 0) && (pixelQuery.Green >= 0) && (pixelQuery.Red >= 0) && (pixelQuery.Alpha >= 0))
{
// Set the Color
pixelQuery.Color = Color.FromArgb(pixelQuery.Alpha, pixelQuery.Red, pixelQuery.Green, pixelQuery.Blue);
}
}
// if there are 5 words
// Example: Set Color 100 150 200 - (Red = 100, Green = 150, Blue = 200, Alpha = 255 default value)
else if (words.Count == 5)
{
// Set to red
pixelQuery.Red = NumericHelper.ParseInteger(words[2].Text, -1, -2);
pixelQuery.Green = NumericHelper.ParseInteger(words[3].Text, -1, -2);
pixelQuery.Blue = NumericHelper.ParseInteger(words[4].Text, -1, -2);
pixelQuery.Alpha = 255;
// verify everything is valid
if ((pixelQuery.Red >= 0) && (pixelQuery.Green >= 0) && (pixelQuery.Red >= 0) && (pixelQuery.Alpha >= 0))
{
// Set the Color
pixelQuery.Color = Color.FromArgb(pixelQuery.Alpha, pixelQuery.Red, pixelQuery.Green, pixelQuery.Blue);
}
// Set the Color
pixelQuery.Color = Color.FromArgb(pixelQuery.Alpha, pixelQuery.Red, pixelQuery.Green, pixelQuery.Blue);
}
// if there are 3 words
// Example: Set Color Orchid (the color must be a named color)
else if (words.Count == 3)
{
// Set the Color
pixelQuery.Color = Color.FromName(words[2].Text);
pixelQuery.Alpha = 255;
}
}
}
}
}
/// <summary>
/// This method is used to parse DataField objects.
/// </summary>
public DataField ParseDataField(ref DataField dataField, XmlNode xmlNode)
{
// if the dataField object exists and the xmlNode exists
if ((dataField != null) && (xmlNode != null))
{
// get the full name of this node
string fullName = xmlNode.GetFullName();
// Check the name of this node to see if it is mapped to a property
switch (fullName)
{
case "Database.Tables.DataTable.Fields.DataField.DataType":
// Set the value for dataField.DataType
dataField.DataType = EnumHelper.GetEnumValue <DataJuggler.Net.DataManager.DataTypeEnum>(xmlNode.FormattedNodeValue, DataJuggler.Net.DataManager.DataTypeEnum.NotSupported);
// required
break;
case "Database.Tables.DataTable.Fields.DataField.DBDataType":
// Set the value for dataField.DBDataType
dataField.DBDataType = xmlNode.FormattedNodeValue;
// required
break;
case "Database.Tables.DataTable.Fields.DataField.DBFieldName":
// Set the value for dataField.DBFieldName
dataField.DBFieldName = xmlNode.FormattedNodeValue;
// required
break;
case "Database.Tables.DataTable.Fields.DataField.DecimalPlaces":
// Set the value for dataField.DecimalPlaces
dataField.DecimalPlaces = NumericHelper.ParseInteger(xmlNode.FormattedNodeValue, 0, -1);
// required
break;
case "Database.Tables.DataTable.Fields.DataField.DefaultValue":
// Set the value for dataField.DefaultValue
dataField.DefaultValue = xmlNode.FormattedNodeValue;
// required
break;
case "Database.Tables.DataTable.Fields.DataField.EnumDataTypeName":
// Set the value for dataField.EnumDataTypeName
dataField.EnumDataTypeName = xmlNode.FormattedNodeValue;
// required
break;
case "Database.Tables.DataTable.Fields.DataField.FieldName":
// Set the value for dataField.FieldName
dataField.FieldName = xmlNode.FormattedNodeValue;
// required
break;
case "Database.Tables.DataTable.Fields.DataField.HasDefault":
// Set the value for dataField.HasDefault
dataField.HasDefault = BooleanHelper.ParseBoolean(xmlNode.FormattedNodeValue, false, false);
// required
break;
case "Database.Tables.DataTable.Fields.DataField.IsAutoIncrement":
// Set the value for dataField.IsAutoIncrement
dataField.IsAutoIncrement = BooleanHelper.ParseBoolean(xmlNode.FormattedNodeValue, false, false);
// required
break;
case "Database.Tables.DataTable.Fields.DataField.IsEnumeration":
// Set the value for dataField.IsEnumeration
dataField.IsEnumeration = BooleanHelper.ParseBoolean(xmlNode.FormattedNodeValue, false, false);
// required
break;
case "Database.Tables.DataTable.Fields.DataField.IsNullable":
// Set the value for dataField.IsNullable
dataField.IsNullable = BooleanHelper.ParseBoolean(xmlNode.FormattedNodeValue, false, false);
// required
break;
case "Database.Tables.DataTable.Fields.DataField.IsReadOnly":
// Set the value for dataField.IsReadOnly
dataField.IsReadOnly = BooleanHelper.ParseBoolean(xmlNode.FormattedNodeValue, false, false);
// required
break;
case "Database.Tables.DataTable.Fields.DataField.Precision":
// Set the value for dataField.Precision
dataField.Precision = NumericHelper.ParseInteger(xmlNode.FormattedNodeValue, 0, -1);
// required
break;
case "Database.Tables.DataTable.Fields.DataField.PrimaryKey":
// Set the value for dataField.PrimaryKey
dataField.PrimaryKey = BooleanHelper.ParseBoolean(xmlNode.FormattedNodeValue, false, false);
// required
break;
case "Database.Tables.DataTable.Fields.DataField.Required":
// Set the value for dataField.Required
dataField.Required = BooleanHelper.ParseBoolean(xmlNode.FormattedNodeValue, false, false);
// required
break;
case "Database.Tables.DataTable.Fields.DataField.Scale":
// Set the value for dataField.Scale
dataField.Scale = NumericHelper.ParseInteger(xmlNode.FormattedNodeValue, 0, -1);
// required
break;
case "Database.Tables.DataTable.Fields.DataField.Size":
// Set the value for dataField.Size
dataField.Size = NumericHelper.ParseInteger(xmlNode.FormattedNodeValue, 0, -1);
// required
break;
}
// if there are ChildNodes
if (xmlNode.HasChildNodes)
{
// iterate the child nodes
foreach (XmlNode childNode in xmlNode.ChildNodes)
{
// append to this DataField
dataField = ParseDataField(ref dataField, childNode);
}
}
}
// return value
return(dataField);
}
/// <summary>
/// This method returns the Number
/// </summary>
public int PullNumber()
{
// initial value
int pullNumber = -3;
try
{
// locals
bool firstNonZeroPulled = false;
int temp = 0;
// if the Shufflers exist
if (this.HasShufflers)
{
// Create a string builder
StringBuilder sb = new StringBuilder();
// Iterate the collection of RandomShuffler objects
foreach (RandomShuffler shuffler in Shufflers)
{
// Pull the next value
temp = shuffler.PullNextItem();
// if we already have the first non zero
if (firstNonZeroPulled)
{
// Add this item
sb.Append(temp);
}
else
{
// If the value for temp is greater than zero
if (temp > 0)
{
// Set to true
firstNonZeroPulled = true;
// Add this item
sb.Append(temp);
}
else
{
// do nothing for preceding zeros
}
}
}
// Get a temporary string to hold the number
string tempString = sb.ToString();
// Now set the return value
pullNumber = NumericHelper.ParseInteger(tempString, -1, -2);
// if this is not the defaultValue or the errorValue
if (pullNumber >= 0)
{
// Increment the value for pullNumber because the needed range is 1 - 1,000,000 and this code returns 0 - 999,999
pullNumber++;
}
// if the number is out of range
if ((pullNumber < this.MinValue) || (pullNumber > this.MaxValue))
{
// if raise error is supposed to happen
if (this.NumberOutOfRangeOption == NumberOutOfRangeOptionEnum.RaiseError)
{
// Raise the error
throw new Exception("The number generated " + pullNumber + " is out of range.");
}
else if (this.NumberOutOfRangeOption == NumberOutOfRangeOptionEnum.Repull)
{
// Increment the value for this
this.RepullNumber++;
// Do not try more than 10 times in case bad min and max values were set
if (this.RepullNumber < 11)
{
// Call this method recursively
pullNumber = PullNumber();
}
}
else if (this.NumberOutOfRangeOption == NumberOutOfRangeOptionEnum.ReturnModulus)
{
// if the MaxValue is set
if (this.MaxValue > 0)
{
// Get the modulus
pullNumber = (pullNumber % this.MaxValue) + 1;
}
}
}
}
}
catch (Exception error)
{
// Set to a bad value to indicate an error
pullNumber = -4;
// Write to the error console
DebugHelper.WriteDebugError("PullNumber", "LargeNumberShuffler", error);
}
// return value
return(pullNumber);
}
/// <summary>
/// This method is used to parse DataIndex objects.
/// </summary>
public DataIndex ParseDataIndex(ref DataIndex dataIndex, XmlNode xmlNode)
{
// if the dataIndex object exists and the xmlNode exists
if ((dataIndex != null) && (xmlNode != null))
{
// get the full name of this node
string fullName = xmlNode.GetFullName();
// Check the name of this node to see if it is mapped to a property
switch (fullName)
{
case "Database.Tables.DataTable.Indexes.DataIndex.AllowPageLocks":
// Set the value for dataIndex.AllowPageLocks
dataIndex.AllowPageLocks = BooleanHelper.ParseBoolean(xmlNode.FormattedNodeValue, false, false);
// required
break;
case "Database.Tables.DataTable.Indexes.DataIndex.AllowRowLocks":
// Set the value for dataIndex.AllowRowLocks
dataIndex.AllowRowLocks = BooleanHelper.ParseBoolean(xmlNode.FormattedNodeValue, false, false);
// required
break;
case "Database.Tables.DataTable.Indexes.DataIndex.Clustered":
// Set the value for dataIndex.Clustered
dataIndex.Clustered = BooleanHelper.ParseBoolean(xmlNode.FormattedNodeValue, false, false);
// required
break;
case "Database.Tables.DataTable.Indexes.DataIndex.DataSpaceID":
// Set the value for dataIndex.DataSpaceID
dataIndex.DataSpaceID = NumericHelper.ParseInteger(xmlNode.FormattedNodeValue, 0, -1);
// required
break;
case "Database.Tables.DataTable.Indexes.DataIndex.FillFactor":
// Set the value for dataIndex.FillFactor
dataIndex.FillFactor = NumericHelper.ParseInteger(xmlNode.FormattedNodeValue, 0, -1);
// required
break;
case "Database.Tables.DataTable.Indexes.DataIndex.FilterDefinition":
// Set the value for dataIndex.FilterDefinition
dataIndex.FilterDefinition = xmlNode.FormattedNodeValue;
// required
break;
case "Database.Tables.DataTable.Indexes.DataIndex.HasFilter":
// Set the value for dataIndex.HasFilter
dataIndex.HasFilter = BooleanHelper.ParseBoolean(xmlNode.FormattedNodeValue, false, false);
// required
break;
case "Database.Tables.DataTable.Indexes.DataIndex.IgnoreDuplicateKey":
// Set the value for dataIndex.IgnoreDuplicateKey
dataIndex.IgnoreDuplicateKey = BooleanHelper.ParseBoolean(xmlNode.FormattedNodeValue, false, false);
// required
break;
case "Database.Tables.DataTable.Indexes.DataIndex.IndexID":
// Set the value for dataIndex.IndexID
dataIndex.IndexID = NumericHelper.ParseInteger(xmlNode.FormattedNodeValue, 0, -1);
// required
break;
case "Database.Tables.DataTable.Indexes.DataIndex.IndexType":
// Set the value for dataIndex.IndexType
dataIndex.IndexType = EnumHelper.GetEnumValue <DataJuggler.Net.Enumerations.IndexTypeEnum>(xmlNode.FormattedNodeValue, DataJuggler.Net.Enumerations.IndexTypeEnum.Unknown);
// required
break;
case "Database.Tables.DataTable.Indexes.DataIndex.IsDisabled":
// Set the value for dataIndex.IsDisabled
dataIndex.IsDisabled = BooleanHelper.ParseBoolean(xmlNode.FormattedNodeValue, false, false);
// required
break;
case "Database.Tables.DataTable.Indexes.DataIndex.IsHypothetical":
// Set the value for dataIndex.IsHypothetical
dataIndex.IsHypothetical = BooleanHelper.ParseBoolean(xmlNode.FormattedNodeValue, false, false);
// required
break;
case "Database.Tables.DataTable.Indexes.DataIndex.IsPadded":
// Set the value for dataIndex.IsPadded
dataIndex.IsPadded = BooleanHelper.ParseBoolean(xmlNode.FormattedNodeValue, false, false);
// required
break;
case "Database.Tables.DataTable.Indexes.DataIndex.IsPrimary":
// Set the value for dataIndex.IsPrimary
dataIndex.IsPrimary = BooleanHelper.ParseBoolean(xmlNode.FormattedNodeValue, false, false);
// required
break;
case "Database.Tables.DataTable.Indexes.DataIndex.IsUnique":
// Set the value for dataIndex.IsUnique
dataIndex.IsUnique = BooleanHelper.ParseBoolean(xmlNode.FormattedNodeValue, false, false);
// required
break;
case "Database.Tables.DataTable.Indexes.DataIndex.IsUniqueConstraint":
// Set the value for dataIndex.IsUniqueConstraint
dataIndex.IsUniqueConstraint = BooleanHelper.ParseBoolean(xmlNode.FormattedNodeValue, false, false);
// required
break;
case "Database.Tables.DataTable.Indexes.DataIndex.Name":
// Set the value for dataIndex.Name
dataIndex.Name = xmlNode.FormattedNodeValue;
// required
break;
case "Database.Tables.DataTable.Indexes.DataIndex.ObjectID":
// Set the value for dataIndex.ObjectID
dataIndex.ObjectID = NumericHelper.ParseInteger(xmlNode.FormattedNodeValue, 0, -1);
// required
break;
case "Database.Tables.DataTable.Indexes.DataIndex.TypeDescription":
// Set the value for dataIndex.TypeDescription
dataIndex.TypeDescription = xmlNode.FormattedNodeValue;
// required
break;
}
// if there are ChildNodes
if (xmlNode.HasChildNodes)
{
// iterate the child nodes
foreach (XmlNode childNode in xmlNode.ChildNodes)
{
// append to this DataIndex
dataIndex = ParseDataIndex(ref dataIndex, childNode);
}
}
}
// return value
return(dataIndex);
}
/// <summary>
/// This method returns the GameManager. It first attempts to load the values from the settings
/// and if not found the default GameManager.Options and GameManager.Players are created.
/// </summary>
private GameManager LoadGameManager()
{
// initial value
GameManager gameManager = null;
// local so the Settings file only has to be loaded once
SecureUserData security = new SecureUserData();
// this is used during development so everything default is restored, this has to be taken out or commented out
// security.LastSavedDate = new DateTime(1900, 1, 1);
// save (this needs to be taken out or commented out also)
// security.Save();
// We must load our five PlayerControls
List <BlackJackPlayerControl> playerControls = GetPlayerControls();
// if the security object has a LastSavedDate we can load a GameManager from it
if (security.HasLastSavedDate)
{
// convert the settings to a gameManager object
gameManager = SecureUserDataFactory.Export(security, playerControls, this);
}
else
{
// Create a new instance of a 'GameManager' object.
gameManager = new GameManager(NumericHelper.ParseInteger(Properties.Resources.TimesToShuffle, 0, -1), this);
// Now we must load the Options and Players from the Settings
gameManager.HouseRules = Options.CreateDefault();
// Load the players from the Settings or create them
gameManager.Players = CreateDefaultPlayers(gameManager.HouseRules);
}
//// Create a new instance of an 'OptionsForm' object.
OptionsForm optionsForm = new OptionsForm(this);
// Setup the form
optionsForm.Setup(gameManager);
//// Show the dialog
optionsForm.ShowDialog();
// if the user did not cancel
if (!optionsForm.UserCancelled)
{
// set the return value
this.GameManager = optionsForm.GameManager;
}
else
{
// if the GameManager does not exist
if (!this.HasGameManager)
{
// Close this app
Environment.Exit(0);
}
}
// return value
return(gameManager);
}
/// <summary>
/// This class is used to Shuffle a list of type 'T'.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="list"></param>
public static List <T> Shuffle <T>(this IList <T> list)
{
// List
List <T> shuffledList = new List <T>();
// locals
int randomIndex = -1;
int cycles = 1;
// create
RandomNumberGenerator crypto = RandomNumberGenerator.Create();
// Create the byte array that serves asa
byte[] container = new byte[1];
// if the list exists
if ((list != null) && (list.Count > 0))
{
// we can't use the collection count it changes
int listCount = list.Count;
// set the cycles
cycles = (listCount / 255) + 1;
// now we have to 'Randomly' pull items and add them to the end results
for (int x = 0; x < listCount; x++)
{
// reset
randomIndex = -1;
// Fill the topOrBottom byteArray
crypto.GetBytes(container);
// iterate the cycles
for (int c = 0; c < cycles; c++)
{
// Get the value of topOrBottom
object randomByte = container.GetValue(0);
// if the randomByte exists
if (NullHelper.Exists(randomByte))
{
// get a randomValue
int randomValue = NumericHelper.ParseInteger(randomByte.ToString(), -1, -1);
// set the randomIndex to the modulas of the the listCount
randomIndex += randomValue;
}
}
// ensure in range
randomIndex = (randomIndex % list.Count);
// verify the index is in range
if ((randomIndex < list.Count) && (randomIndex >= 0))
{
// Add this integer
shuffledList.Add(list[randomIndex]);
// if the index is in rage
if ((list.Count > 0) && (list.Count > randomIndex))
{
// Remove the item from the sourceList now that we have it
list.RemoveAt(randomIndex);
}
}
}
}
// return value
return(shuffledList);
}
/// <summary>
/// This method is used to load a GameManager object from the values from this object
/// so that the controls be can be loaded when the program starts
/// </summary>
/// <returns></returns>
public static GameManager Export(SecureUserData security, List <BlackJackPlayerControl> playerControls, MainForm table)
{
// initial value
GameManager gameManager = null;
// local
BlackJackPlayerControl playerControl = null;
// If the security object exists
if (NullHelper.Exists(security, playerControls, table))
{
// Create a new instance of a 'GameManager' object.
gameManager = new GameManager(NumericHelper.ParseInteger(Properties.Resources.TimesToShuffle, 0, -1), table);
// create a houseRules object
Options houseRules = new Options();
// set the properties from this form
houseRules.AllowDoubleDown = security.AllowDoubleDown;
houseRules.AllowDoubleOnSplit = security.AllowDoubleOnSplit;
houseRules.AllowDoubleOnTenOrElevenOnly = security.AllowDoubleOnTenOrElevenOnly;
houseRules.AllowInsurance = security.AllowInsurance;
houseRules.AllowResplitAces = security.AllowResplitAces;
houseRules.AllowSplit = security.AllowSplit;
houseRules.AllowSplitAces = security.AllowSplitAces;
houseRules.AllowSurrender = security.AllowSurrender;
houseRules.ComputerPlayersUnlimitedRebuys = security.ComputerPlayersUnlimitedRebuys;
houseRules.DealerMustHitSoft17 = security.DealerMustHitSoft17;
houseRules.DefaultBankRoll = security.DefaultBankRoll;
houseRules.DefaultComputerBankRoll = security.DefaultComputerBankRoll;
houseRules.GameSpeed = security.GameSpeed;
houseRules.HumanPlayerUnlimitedRebuys = security.HumanPlayerUnlimitedRebuys;
houseRules.NumberDecks = security.NumberDecks;
houseRules.Penetration = security.Penetration;
houseRules.SaveSettingsOnThisComputer = security.SaveSettingsOnThisComputer;
houseRules.TableMaximum = security.TableMaximum;
houseRules.TableMinimum = security.TableMinimum;
// Create a list of players
List <Player> players = new List <Player>();
// if Player1's Name is set that is consider playing
if (TextHelper.Exists(security.Player1Name))
{
// Find the PlayerControl
playerControl = FindPlayerControl(playerControls, SeatNumberEnum.Seat1);
// if the control was found
if (NullHelper.Exists(playerControl))
{
// create player 1
Player player1 = new Player(security.Player1Name, security.Player1Chips, security.Player1IsComputerPlayer, playerControl);
// Setup the SeatNumber
player1.SeatNumber = SeatNumberEnum.Seat1;
// Is Player1 Sitting Out
player1.SittingOut = security.Player1SittingOut;
// Set the CountingSystem
string countingSystemName = security.Player1CountingSystem;
player1.CardCountingSystem = CardCountingSystemFactory.FindCardCountingSystem(countingSystemName);
// add this player
players.Add(player1);
}
}
// if Player2's Name is set that is consider playing
if (TextHelper.Exists(security.Player2Name))
{
// Find the PlayerControl
playerControl = FindPlayerControl(playerControls, SeatNumberEnum.Seat2);
// if the control was found
if (NullHelper.Exists(playerControl))
{
// create player 2
Player player2 = new Player(security.Player2Name, security.Player2Chips, security.Player2IsComputerPlayer, playerControl);
// Setup the SeatNumber
player2.SeatNumber = SeatNumberEnum.Seat2;
// Is Player2 Sitting Out
player2.SittingOut = security.Player2SittingOut;
// Set the CountingSystem
string countingSystemName = security.Player2CountingSystem;
player2.CardCountingSystem = CardCountingSystemFactory.FindCardCountingSystem(countingSystemName);
// add this player
players.Add(player2);
}
}
// if Player3's Name is set that is consider playing
if (TextHelper.Exists(security.Player3Name))
{
// Find the PlayerControl
playerControl = FindPlayerControl(playerControls, SeatNumberEnum.Seat3);
// if the control was found
if (NullHelper.Exists(playerControl))
{
// create player 3
Player player3 = new Player(security.Player3Name, security.Player3Chips, security.Player3IsComputerPlayer, playerControl);
// Setup the SeatNumber
player3.SeatNumber = SeatNumberEnum.Seat3;
// Is Player3 Sitting Out
player3.SittingOut = security.Player3SittingOut;
// Set the CountingSystem
string countingSystemName = security.Player3CountingSystem;
player3.CardCountingSystem = CardCountingSystemFactory.FindCardCountingSystem(countingSystemName);
// add this player
players.Add(player3);
}
}
// if Player4's Name is set that is consider playing
if (TextHelper.Exists(security.Player4Name))
{
// Find the PlayerControl
playerControl = FindPlayerControl(playerControls, SeatNumberEnum.Seat4);
// if the control was found
if (NullHelper.Exists(playerControl))
{
// create player 4
Player player4 = new Player(security.Player4Name, security.Player4Chips, security.Player4IsComputerPlayer, playerControl);
// Setup the SeatNumber
player4.SeatNumber = SeatNumberEnum.Seat4;
// Is Player4 Sitting Out
player4.SittingOut = security.Player4SittingOut;
// Set the CountingSystem
string countingSystemName = security.Player4CountingSystem;
player4.CardCountingSystem = CardCountingSystemFactory.FindCardCountingSystem(countingSystemName);
// add this player
players.Add(player4);
}
}
// if Player5's Name is set that is consider playing
if (TextHelper.Exists(security.Player5Name))
{
// Find the PlayerControl
playerControl = FindPlayerControl(playerControls, SeatNumberEnum.Seat5);
// if the control was found
if (NullHelper.Exists(playerControl))
{
// create player 5
Player player5 = new Player(security.Player5Name, security.Player5Chips, security.Player5IsComputerPlayer, playerControl);
// Setup the SeatNumber
player5.SeatNumber = SeatNumberEnum.Seat5;
// Is Player5 Sitting Out
player5.SittingOut = security.Player5SittingOut;
// Set the CountingSystem
string countingSystemName = security.Player5CountingSystem;
player5.CardCountingSystem = CardCountingSystemFactory.FindCardCountingSystem(countingSystemName);
// add this player
players.Add(player5);
}
}
// set the HouseRules & players
gameManager.HouseRules = houseRules;
gameManager.Players = players;
// if the HouseRules exist
if (gameManager.HasHouseRules)
{
// create
BlackJackCardValueBase blackJackCardValueBase = new BlackJackCardValueBase();
// Set the times to shuffle
int timesToShuffle = NumericHelper.ParseInteger(Properties.Resources.TimesToShuffle, 0, -1);
// Create the Shuffler
gameManager.Shuffler = new RandomShuffler(houseRules.NumberDecks, blackJackCardValueBase, 0);
}
}
// return value
return(gameManager);
}
/// <summary>
/// This method Start Simulation
/// </summary>
private void StartSimulation()
{
// Create a
RandomDoorCallBack dealer = new RandomDoorCallBack(CanPullNextItem, PullNextItem);
// Create a report
this.Report = new RandomReport(PickADoorSimulator.MinValue, PickADoorSimulator.MaxValue);
// You can't start a second simulation without restarting.
this.StartSimulationButton.Enabled = false;
// Show the initializing label
this.InitializingLabel.Visible = true;
this.Graph.Visible = true;
// Show the Setup
RefreshUI();
// locals
DoorSelectOptionEnum doorSelectOption = GetDoorSelectOption();
PickADoorSimulator simulatorWithoutSwap = null;
PickADoorSimulator simulatorWithSwap = null;
// Get the number of simulations to run
int simulations = NumericHelper.ParseInteger(this.SimulationsControl.Text.Replace(",", ""), 0, -1);
// If the value for simulations is greater than zero
if (simulations > 0)
{
// create the total possibilities to choose from
int possibilities = PickADoorSimulator.MaxValue * 10;
// Create a Shuffler
this.Shuffler = new RandomShuffler(PickADoorSimulator.MinValue, PickADoorSimulator.MaxValue, possibilities, PickADoorSimulator.TimesToShuffle, 1);
// Set the report
this.Shuffler.Report = this.Report;
// Create the two lists
this.SimulationsSwapping = new List <PickADoorSimulator>();
this.SimulationsNotSwapping = new List <PickADoorSimulator>();
// Set the maximum
this.Graph.Maximum = simulations;
// iterate the number of simuations to create them
for (int x = 1; x <= simulations; x++)
{
// Create a simulation for Without Swap
simulatorWithoutSwap = new PickADoorSimulator(doorSelectOption, false, dealer);
// Create a simulation for Swap
simulatorWithSwap = new PickADoorSimulator(doorSelectOption, true, dealer);
// Add each simulation
this.SimulationsNotSwapping.Add(simulatorWithoutSwap);
this.SimulationsSwapping.Add(simulatorWithSwap);
// Set the graph value
this.Graph.Value = x;
// Refresh everything
this.RefreshUI();
}
// Hide the setup
this.InitializingLabel.Visible = false;
this.Graph.Visible = false;
// refresh the UI
RefreshUI();
// for debugging only
// StringBuilder sb = new StringBuilder();
// Now run the simulations
for (int x = 0; x < simulations; x++)
{
// Run the simulations
this.SimulationsNotSwapping[x].RunSimulation();
this.SimulationsSwapping[x].RunSimulation();
// if it was a correct guess
if (this.SimulationsNotSwapping[x].CorrectGuess)
{
// Increment the value for this
this.DoNotSwapCorrect++;
}
else
{
// Increment the value for this
this.DoNotSwapWrong++;
}
// if it was a correct guess
if (this.SimulationsSwapping[x].CorrectGuess)
{
// Increment the value for this
this.SwapCorrect++;
}
else
{
// Increment the value for this
this.SwapWrong++;
}
// Display the results
this.DoNotSwapCorrectValueLabel.Text = String.Format("{0:n0}", DoNotSwapCorrect);
this.DoNotSwapWrongValueLabel.Text = String.Format("{0:n0}", DoNotSwapWrong);
this.SwapCorrectValueLabel.Text = String.Format("{0:n0}", SwapCorrect);
this.SwapWrongValueLabel.Text = String.Format("{0:n0}", SwapWrong);
// refresh the user interface
RefreshUI();
}
// Get the report
if (this.Report.HasOccurrences)
{
// local
int tempCount = 0;
// iterate the occurrences
foreach (NumberOccurrence occurrence in this.Report.Occurrences)
{
// local
int thisNumber = occurrence.Number;
tempCount = occurrence.Count;
// write out the number
Console.WriteLine(thisNumber + ": " + tempCount + " of " + this.Report.TotalItemsPulled);
}
}
}
else
{
// Show the user a message
MessageBoxHelper.ShowMessage("You must enter the number of simulations", "Invalid Input");
}
// Add Finished so we know it is done.
this.Text = this.Text + " - Finished";
}
/// <summary>
/// This method returns the Pixel Criteria
/// </summary>
public static PixelCriteria CreatePixelCriteria(string text, ActionTypeEnum actionType, int lineNumber, PixelCriteria existingCriteria = null)
{
// initial value
PixelCriteria pixelCriteria = null;
// only use a space as a delimiter character
char[] delimiterChars = { ' ' };
// If the text string exists
if (TextHelper.Exists(text))
{
// Set the BackColor
if (actionType == ActionTypeEnum.SetBackColor)
{
// Create a new instance of a 'PixelCriteria' object.
pixelCriteria = new PixelCriteria();
// Get the words
List <Word> words = WordParser.GetWords(text, delimiterChars);
// If the words collection exists and has one or more items
if (ListHelper.HasOneOrMoreItems(words))
{
// if there are 3 words
if (words.Count == 3)
{
// if the third word is null
if (words[2].Text.ToLower() == "null")
{
// Set the value for the property 'RemoveBackColor' to true
pixelCriteria.RemoveBackColor = true;
}
else
{
// Set the BackColor
pixelCriteria.BackColor = Color.FromName(words[2].Text);
}
}
else if (words.Count == 5)
{
// set the value for Red, Green & Blue
int red = NumericHelper.ParseInteger(words[2].Text, -1, -1);
int green = NumericHelper.ParseInteger(words[3].Text, -1, -1);
int blue = NumericHelper.ParseInteger(words[4].Text, -1, -1);
// if all the RGB values are set
if ((red >= 0) && (green >= 0) && (blue >= 0))
{
// Set the BackColor
pixelCriteria.BackColor = Color.FromArgb(red, green, blue);
}
}
}
}
// if this is a draw line
else if (actionType == ActionTypeEnum.DrawLine)
{
// if the existingCriteria
if (NullHelper.IsNull(existingCriteria))
{
// Create a new instance of a 'PixelCriteria' object.
pixelCriteria = new PixelCriteria();
}
else
{
// use the existing criteria so more properties can be set on it
pixelCriteria = existingCriteria;
}
// Set to DrawLine
pixelCriteria.PixelType = PixelTypeEnum.DrawLine;
// if this is the first line
if (lineNumber == 1)
{
// Get the words
List <Word> words = WordParser.GetWords(text, delimiterChars);
// If the words collection exists and has one or more items
if (ListHelper.HasOneOrMoreItems(words))
{
// Get the lastWord
Word lastWord = words[words.Count - 1];
// Set the thickness
pixelCriteria.Thickness = NumericHelper.ParseInteger(lastWord.Text, -1000, -1001);
}
}
else if (lineNumber == 3)
{
// Set the RepeatType and the repeating attributes
pixelCriteria.RepeatType = SetRepeatType(text);
// if the repeat type was found
if (pixelCriteria.RepeatType != RepeatTypeEnum.NoRepeat)
{
// get the text after the repeat
string repeatText = GetRepeatText(text, pixelCriteria.RepeatType);
// get the words
List <Word> words = WordParser.GetWords(repeatText);
// if there are exactly two words
if ((ListHelper.HasOneOrMoreItems(words)) && (words.Count == 2))
{
// set the repititions
pixelCriteria.Repititions = NumericHelper.ParseInteger(words[0].Text, 0, -1);
// set the Distance
pixelCriteria.Distance = NumericHelper.ParseInteger(words[1].Text, 0, -1);
}
}
}
}
else if (lineNumber > 1)
{
// Create a new instance of a 'PixelCriteria' object.
pixelCriteria = new PixelCriteria();
// if this text contains bluegreen
if (text.Contains("x"))
{
// Set the PixelType
pixelCriteria.PixelType = PixelTypeEnum.X;
}
else if (text.Contains("y"))
{
// Set the PixelType
pixelCriteria.PixelType = PixelTypeEnum.Y;
}
else if (text.Contains("bluegreen"))
{
// Set the PixelType
pixelCriteria.PixelType = PixelTypeEnum.BlueGreen;
}
// if this text contains bluegreen
else if (text.Contains("bluered"))
{
// Set the PixelType
pixelCriteria.PixelType = PixelTypeEnum.BlueRed;
}
// if this text contains bluegreen
else if (text.Contains("greenred"))
{
// Set the PixelType
pixelCriteria.PixelType = PixelTypeEnum.GreenRed;
}
else if (text.Contains("red"))
{
// Set the PixelType
pixelCriteria.PixelType = PixelTypeEnum.Red;
}
else if (text.Contains("green"))
{
// Set the PixelType
pixelCriteria.PixelType = PixelTypeEnum.Green;
}
else if (text.Contains("blue"))
{
// Set the PixelType
pixelCriteria.PixelType = PixelTypeEnum.Blue;
}
else if (text.Contains("total"))
{
// Set the PixelType
pixelCriteria.PixelType = PixelTypeEnum.Total;
}
}
}
// return value
return(pixelCriteria);
}