public void IdToSqlCommandBuilder_IdIsNegative_ThrowArgumentNullException()
{
//Arrange
var id = RandomizerHelper.GetRandomNegativeInt();
var query = RandomizerHelper.GetRandomString();
var sqlConnection = new SqlConnection();
//Act + Assert
Assert.Throws <ArgumentNullException>(() => SqlHelper.IdToSqlCommandBuilder(id, query, sqlConnection));
}
public void ModelToSqlCommandBuilder_QueryIsWhiteSpace_ThrowArgumentIsNullException()
{
//Arrange
var model = RandomizerHelper.GetNewRandomEvent();
var query = " ";
var sqlConnection = new SqlConnection();
//Act + Assert
Assert.Throws <ArgumentNullException>(() => SqlHelper.ModelToSqlCommandBuilder <Event>(model, query, sqlConnection));
}
public void ModelToSqlCommandBuilder_SqlConnectionIsNull_ThrowArgumentIsNullException()
{
//Arrange
var model = RandomizerHelper.GetNewRandomEvent();
var query = RandomizerHelper.GetRandomString();
SqlConnection sqlConnection = null;
//Act + Assert
Assert.Throws <ArgumentNullException>(() => SqlHelper.ModelToSqlCommandBuilder <Event>(model, query, sqlConnection));
}
public void IdToSqlCommandBuilder_QueryIsWhiteSpace_ThrowArgumentNullException()
{
//Arrange
var id = RandomizerHelper.GetRandomInt();
var query = " ";
var sqlConnection = new SqlConnection();
//Act + Assert
Assert.Throws <ArgumentNullException>(() => SqlHelper.IdToSqlCommandBuilder(id, query, sqlConnection));
}
public void ModelToSqlCommandBuilder_TicketModelIsNull_ThrowArgumentIsNullException()
{
//Arrange
var model = default(Ticket);
var query = RandomizerHelper.GetRandomString();
var sqlConnection = new SqlConnection();
//Act + Assert
Assert.Throws <ArgumentNullException>(() => SqlHelper.ModelToSqlCommandBuilder <Ticket>(model, query, sqlConnection));
}
public bool BossTypeCheck(bool isBoss, ref Random rnd)
{
if (isBoss)
{
return(RandomizerHelper.ChancePass(Defs.BOSS_CHECK, ref rnd));
}
else
{
return(false);
}
}
private int TryGetSeed()
{
try
{
var seed = Int32.Parse(textboxSeed.Text);
return(seed == -1 ? RandomizerHelper.GetRandomInt() : seed);
}
catch
{
return(RandomizerHelper.GetRandomInt());
}
}
public void SqlReaderToModelBuilder_ValidSqlReader_ReturnCorrectStudentModel()
{
//Arrange
var expected = RandomizerHelper.GetNewRandomStudent();
mockDataReader.Setup(x => x.GetInt32(0)).Returns(expected.Id);
mockDataReader.Setup(x => x.GetString(1)).Returns(expected.Email);
//Act
var actual = SqlHelper.SqlReaderToModelBuilder <Student>(mockDataReader.Object);
//Assert
AssertStudentAreEqual(expected, actual);
}
public void EventSet(ref Random rnd, DataTbls dataTbls)
{
// Post Randomize battle modifiers
var eventCount = RandomizerHelper.eventDistribution[rnd.Next(RandomizerHelper.eventDistribution.Count)];
for (int j = 1; j <= eventCount; j++)
{
if (RandomizerHelper.ChancePass(dataTbls.config.chaos, ref rnd))
{
var randEvent = GetRandomBattleEvent(ref rnd, dataTbls);
BuildEvent(randEvent, j);
}
}
}
public void HealthCheck(ref Random rnd, DataTbls dataTbls)
{
// Check if init HP is lower than init damage (?)
if (basic_init_hp < basic_init_damage)
{
var hold = basic_init_damage;
basic_init_damage = basic_init_hp;
basic_init_hp = hold;
}
// If HP battle, and player hass less than 30 hp, and they pass chaos chance, give em extra health.
if (battle_type == "hp" || battle_type == "hp_time")
{
basic_init_hp += (ushort)(RandomizerHelper.ChancePass(100 - dataTbls.config.chaos, ref rnd) && basic_init_hp < Defs.PLAYER_LOW_HP_CUTOFF ? Defs.PLAYER_LOW_HP_MOD : 0);
}
}
public void SqlReaderToModelBuilder_ValidSqlReader_ReturnCorrectTIcketModel()
{
//Arrange
var expected = RandomizerHelper.GetNewRandomTicket();
mockDataReader.Setup(x => x.GetInt32(0)).Returns(expected.Id);
mockDataReader.Setup(x => x.GetInt32(1)).Returns(expected.EventId);
mockDataReader.Setup(x => x.GetBoolean(2)).Returns(expected.IsUsed);
mockDataReader.Setup(x => x.GetInt32(3)).Returns(expected.StudentId);
//Act
var actual = SqlHelper.SqlReaderToModelBuilder <Ticket>(mockDataReader.Object);
//Assert
AssertTicketAreEqual(expected, actual);
}
public void IdToSqlCommandBuilder_ValidArguments_ReturnValidSqlCommand()
{
//Arrange
var id = RandomizerHelper.GetRandomInt();
var query = RandomizerHelper.GetRandomString();
var sqlConnection = new SqlConnection();
var expected = new SqlCommand(query);
expected.Parameters.Add("@Id", SqlDbType.Int).Value = id;
//Act
var actual = SqlHelper.IdToSqlCommandBuilder(id, query, sqlConnection);
//Assert
AssertSqlCommandAreEqual(expected, actual);
}
public void ModelToSqlCommandBuilder_ValidArguments_ReturnVaidSqlCommandForStudent()
{
//Arrange
var model = RandomizerHelper.GetNewRandomStudent();
var query = RandomizerHelper.GetRandomString();
var sqlConnection = new SqlConnection();
var expected = new SqlCommand(query, sqlConnection);
expected.Parameters.Add("@Id", SqlDbType.Int).Value = model.Id;
expected.Parameters.Add("@Email", SqlDbType.NVarChar).Value = model.Email;
//Act
var actual = SqlHelper.ModelToSqlCommandBuilder <Student>(model, query, sqlConnection);
//Assert
AssertSqlCommandAreEqual(expected, actual);
}
public void ModelToSqlCommandBuilder_StudentPropertiesDefaultValues_ReturnSqlCommandWithDefaultValues()
{
//Arrange
var model = new Student();
var query = RandomizerHelper.GetRandomString();
var sqlConnection = new SqlConnection();
var expected = new SqlCommand(query, sqlConnection);
expected.Parameters.Add("@Id", SqlDbType.Int).Value = default(int);
expected.Parameters.Add("@Email", SqlDbType.NVarChar).Value = default(string);
//Act
var actual = SqlHelper.ModelToSqlCommandBuilder <Student>(model, query, sqlConnection);
//Assert
AssertSqlCommandAreEqual(expected, actual);
}
public void SqlReaderToModelBuilder_ValidSqlReader_ReturnCorrectEventModel()
{
//Arrange
var expected = RandomizerHelper.GetNewRandomEvent();
mockDataReader.Setup(x => x.GetInt32(0)).Returns(expected.Id);
mockDataReader.Setup(x => x.GetString(1)).Returns(expected.Name);
mockDataReader.Setup(x => x.GetString(2)).Returns(expected.Description);
mockDataReader.Setup(x => x.GetDecimal(3)).Returns(expected.Price);
mockDataReader.Setup(x => x.GetDecimal(4)).Returns(expected.StudentPrice);
mockDataReader.Setup(x => x.GetDateTime(5)).Returns(expected.Date);
mockDataReader.Setup(x => x.GetString(6)).Returns(expected.Place);
//Act
var actual = SqlHelper.SqlReaderToModelBuilder <Event>(mockDataReader.Object);
//Assert
AssertEventAreEqual(expected, actual);
}
public void HealthCheck(bool isLoseEscort, ref Random rnd)
{
// Check if init HP is lower than init damage (?)
if (hp < init_damage)
{
var hold = init_damage;
init_damage = hp;
hp = hold;
}
if (isLoseEscort)
{
// Losing from low health escorts sucks. Either add HP, or add Stocks.
if (RandomizerHelper.ChancePass(50, ref rnd))
{
hp += Defs.ALLY_LOW_HP_MOD;
}
stock += Defs.ALLY_LOW_STOCK_MOD;
}
}
public void ModelToSqlCommandBuilder_EventPropertiesAreDefaultValues_ReturnSqlCommandWithDefaultValues()
{
//Arrange
var model = new Event();
var query = RandomizerHelper.GetRandomString();
var sqlConnection = new SqlConnection();
var expected = new SqlCommand(query, sqlConnection);
expected.Parameters.Add("@Id", SqlDbType.Int).Value = default(int);
expected.Parameters.Add("@Name", SqlDbType.NVarChar).Value = default(string);
expected.Parameters.Add("@Description", SqlDbType.NVarChar).Value = default(string);
expected.Parameters.Add("@Price", SqlDbType.Decimal).Value = default(decimal);
expected.Parameters.Add("@StudentPrice", SqlDbType.Decimal).Value = default(decimal);
expected.Parameters.Add("@Date", SqlDbType.DateTime).Value = default(DateTime);
expected.Parameters.Add("@Place", SqlDbType.NVarChar).Value = default(string);
//Act
var actual = SqlHelper.ModelToSqlCommandBuilder <Event>(model, query, sqlConnection);
//Assert
AssertSqlCommandAreEqual(expected, actual);
}
public void ModelToSqlCommandBuilder_ValidArguments_ReturnVaidSqlCommandForEvent()
{
//Arrange
var model = RandomizerHelper.GetNewRandomEvent();
var query = RandomizerHelper.GetRandomString();
var sqlConnection = new SqlConnection();
var expected = new SqlCommand(query, sqlConnection);
expected.Parameters.Add("@Id", SqlDbType.Int).Value = model.Id;
expected.Parameters.Add("@Name", SqlDbType.NVarChar).Value = model.Name;
expected.Parameters.Add("@Description", SqlDbType.NVarChar).Value = model.Description;
expected.Parameters.Add("@Price", SqlDbType.Decimal).Value = model.Price;
expected.Parameters.Add("@StudentPrice", SqlDbType.Decimal).Value = model.StudentPrice;
expected.Parameters.Add("@Date", SqlDbType.DateTime).Value = model.Date;
expected.Parameters.Add("@Place", SqlDbType.NVarChar).Value = model.Place;
//Act
var actual = SqlHelper.ModelToSqlCommandBuilder <Event>(model, query, sqlConnection);
//Assert
AssertSqlCommandAreEqual(expected, actual);
}
public BattleEvent GetRandomBattleEvent(ref Random rand, DataTbls dataTbls)
{
if (dataTbls.eventData.GetCount() == 0)
{
return(dataTbls.battleData.events[rand.Next(dataTbls.battleData.events.Count)]);
}
else
{
var properties = GetType().GetProperties();
IDataTbl pulledEvent = dataTbls.eventData.GetRandomEvent(ref rand);
var randEvent = new BattleEvent();
// Chance to get a random event from label, vs random event from event type. Should help spread things out hopefully.
if (RandomizerHelper.ChancePass(Defs.EVENT_CHECK, ref rand))
{
randEvent.event_type = ((Event)pulledEvent).GetTypeName();
randEvent.event_label = pulledEvent.GetPropertyValueFromName("label");
}
else
{
var event_types = dataTbls.eventData.event_type;
randEvent.event_type = event_types[rand.Next(event_types.Count)];
var labels = dataTbls.eventData.GetLabelsOfType(randEvent.event_type);
randEvent.event_label = labels[rand.Next(labels.Count)];
}
randEvent.event_count = Byte.Parse(GetRandomFieldValue(properties.FirstOrDefault(x => x.Name == "event1_count"), ref rand, dataTbls, true));
randEvent.event_damage = UInt16.Parse(GetRandomFieldValue(properties.FirstOrDefault(x => x.Name == "event1_damage"), ref rand, dataTbls, true));
randEvent.event_start_time = Int32.Parse(GetRandomFieldValue(properties.FirstOrDefault(x => x.Name == "event1_start_time"), ref rand, dataTbls, true));
randEvent.event_range_time = Int32.Parse(GetRandomFieldValue(properties.FirstOrDefault(x => x.Name == "event1_range_time"), ref rand, dataTbls, true));
return(randEvent);
}
}
/// <summary>
/// Generates a list of orders and bundles. TODO this has to be adapted to handle simple items too. While doing so use a configuration for all the settings and feed it to the GUI.
/// </summary>
/// <param name="wordFile">The word file.</param>
/// <param name="baseColors">The colors</param>
/// <param name="baseColorProbabilities"></param>
/// <param name="seed"></param>
/// <param name="minTime"></param>
/// <param name="maxTime"></param>
/// <param name="orderCount"></param>
/// <param name="minItemWeight"></param>
/// <param name="maxItemWeight"></param>
/// <param name="minPositionCount"></param>
/// <param name="maxPositionCount"></param>
/// <param name="minBundleSize"></param>
/// <param name="maxBundleSize"></param>
/// <param name="relativeBundleCount"></param>
/// <returns></returns>
public static OrderList GenerateOrders(
string wordFile,
LetterColors[] baseColors,
IDictionary <LetterColors, double> baseColorProbabilities,
int seed,
double minTime,
double maxTime,
int orderCount,
double minItemWeight,
double maxItemWeight,
int minPositionCount,
int maxPositionCount,
int minBundleSize,
int maxBundleSize,
double relativeBundleCount)
{
// Init random
IRandomizer randomizer = new RandomizerSimple(seed);
// Read the words that serve as the base for the item types
List <string> baseWords = new List <string>();
using (StreamReader sr = new StreamReader(wordFile))
{
string line = "";
while ((line = sr.ReadLine()) != null)
{
baseWords.Add(line.Trim());
}
}
baseWords = baseWords.Distinct().ToList();
List <char> baseLetters = baseWords.SelectMany(w => w.ToCharArray()).Distinct().ToList();
// --> Build all necessary item descriptions
OrderList orderList = new OrderList(ItemType.Letter);
int currentItemDescriptionID = 0;
foreach (var letter in baseLetters)
{
foreach (var color in baseColors)
{
orderList.ItemDescriptions.Add(new ColoredLetterDescription(null)
{
ID = currentItemDescriptionID++, Color = color, Letter = letter, Weight = randomizer.NextDouble(minItemWeight, maxItemWeight)
});
}
}
// --> Generate orders randomly
for (int i = 0; i < orderCount; i++)
{
// Choose a random word from the list
string word = baseWords[randomizer.NextInt(baseWords.Count)];
Order order = new Order()
{
TimeStamp = randomizer.NextDouble(minTime, maxTime)
};
// Add each letter to originalLetters
for (int j = 0; j < word.Length; j++)
{
// Get color based on distribution
double r = randomizer.NextDouble();
// Choose a default one just incase
LetterColors chosenColor = baseColors.First();
// Go through and check the range of each color, pulling random number down to the current range
foreach (var c in baseColors)
{
if (baseColorProbabilities[c] > r)
{
chosenColor = c; break;
}
r -= baseColorProbabilities[c];
}
// Add letter to order
order.AddPosition(
orderList.ItemDescriptions.Single(d => (d as ColoredLetterDescription).Letter == word[j] && (d as ColoredLetterDescription).Color == chosenColor),
randomizer.NextInt(minPositionCount, maxPositionCount + 1));
}
// Add the order
orderList.Orders.Add(order);
}
// Get probability of item-descriptions
Dictionary <ItemDescription, int> itemFrequency = orderList.Orders.SelectMany(o => o.Positions).GroupBy(p => p.Key).ToDictionary(i => i.Key, i => i.Sum(e => e.Value));
double overallCount = itemFrequency.Sum(f => f.Value);
Dictionary <ItemDescription, double> itemProbability = itemFrequency.ToDictionary(k => k.Key, v => (double)itemFrequency[v.Key] / overallCount);
// --> Generate appropriate bundles for this list
int itemsOrdered = (int)(orderList.Orders.Sum(o => o.Positions.Sum(p => p.Value)) * relativeBundleCount); int newItems = 0; int currentBundleID = 0;
for (int itemsStored = 0; itemsStored < itemsOrdered; itemsStored += newItems)
{
// Draw a random item description based on the frequency of the items
ItemDescription newBundleDescription = RandomizerHelper.DrawRandomly <ItemDescription>(itemProbability, randomizer);
int bundleSize = randomizer.NextInt(minBundleSize, maxBundleSize);
double timeStamp = randomizer.NextDouble(minTime, maxTime);
ColoredLetterBundle bundle = new ColoredLetterBundle(null)
{
ID = currentBundleID++, ItemDescription = newBundleDescription, TimeStamp = timeStamp, ItemCount = bundleSize
};
// Add bundle to list
orderList.Bundles.Add(bundle);
// Signal new items
newItems = bundleSize;
}
// Order the orders and bundles
orderList.Sort();
// Return it
return(orderList);
}
