static public void SendItems(NetworkUser networkUser)
{
Data.RefreshInfo(networkUser.localUser.userProfile.fileName);
if (Data.modEnabled)
{
Dictionary <int, int> itemsPurchased = new Dictionary <int, int>();
if (Data.mode == DataEarntConsumable.mode)
{
itemsPurchased = DataEarntConsumable.itemsPurchased[Data.profile[Data.mode]];
}
else if (Data.mode == DataEarntPersistent.mode)
{
itemsPurchased = DataEarntPersistent.itemsPurchased[Data.profile[Data.mode]];
}
else if (Data.mode == DataFree.mode)
{
itemsPurchased = DataFree.itemsPurchased[Data.profile[Data.mode]];
}
else if (Data.mode == DataRandom.mode)
{
itemsPurchased = DataRandom.GenerateRandomItemList();
}
foreach (int itemID in itemsPurchased.Keys)
{
ItemPurchased itemPurchased = new ItemPurchased {
_itemID = itemID, _itemCount = itemsPurchased[itemID], _connectionID = networkUser.netId.Value
};
itemPurchased.Send(R2API.Networking.NetworkDestination.Server);
}
SpawnItems spawnItems = new SpawnItems {
_mode = Data.mode, _connectionID = networkUser.netId.Value
};
spawnItems.Send(R2API.Networking.NetworkDestination.Server);
}
}
internal static void Find_AllSearchable(DataRandom testInstance)
{
foreach (string item in DataRandom.SupportedProperties)
{
testInstance.Find(item).Assert().IsNot(null);
}
}
internal static void DataRandom_MaintainsValues(DataRandom testInstance)
{
foreach (PropertyInfo prop in typeof(DataRandom).GetProperties())
{
prop.GetValue(testInstance).Assert().Is(prop.GetValue(testInstance));
}
}
/// <summary>Creates a new instance of <paramref name="type"/>.</summary>
/// <param name="type">Type to generate.</param>
/// <param name="randomizer">Handles callback behavior for child values.</param>
/// <param name="smartData">Predefined random data.</param>
/// <returns>The created instance.</returns>
private static object CreateNew(Type type, RandomizerChainer randomizer, DataRandom smartData)
{
/*
* Order of preference:
* 1) Default constructor.
* 2) Public constructor.
* 3) Public factory.
* 4) Internal factory.
* 5) Internal constructor.
* 6) Stub.
*/
ConstructorInfo defaultConstructor = type.GetConstructor(Type.EmptyTypes);
if (type == typeof(object))
{
IFaked fake = randomizer.Stub <IFaked>().Dummy;
fake.FakeMeta.Identifier = randomizer.Create <int>();
return(fake);
}
else if (defaultConstructor != null)
{
return(defaultConstructor.Invoke(null));
}
else if (FindConstructors(type, BindingFlags.Public, randomizer).Any())
{
return(CreateFrom(randomizer, smartData, (c, d) => c.Invoke(d),
FindConstructors(type, BindingFlags.Public, randomizer)));
}
else if (FindFactories(type, BindingFlags.Public, randomizer).Any())
{
return(CreateFrom(randomizer, smartData, (c, d) => c.Invoke(null, d),
FindFactories(type, BindingFlags.Public, randomizer)));
}
else if (FindFactories(type, BindingFlags.NonPublic, randomizer).Any())
{
return(CreateFrom(randomizer, smartData, (c, d) => c.Invoke(null, d),
FindFactories(type, BindingFlags.NonPublic, randomizer)));
}
else if (FindConstructors(type, BindingFlags.NonPublic, randomizer).Any())
{
return(CreateFrom(randomizer, smartData, (c, d) => c.Invoke(d),
FindConstructors(type, BindingFlags.NonPublic, randomizer)));
}
else if (!type.IsSealed)
{
return(randomizer.Stub(type).Dummy);
}
else
{
return(null);
}
}
/// <summary>Creates a random instance of the given type.</summary>
/// <param name="type">Type to generate.</param>
/// <param name="randomizer">Handles callback behavior for child values.</param>
/// <returns>Created instance.</returns>
private static object Create(Type type, RandomizerChainer randomizer)
{
Type newType = FindTypeToCreate(type, randomizer);
if (newType != type)
{
return(randomizer.Create(newType));
}
DataRandom smartData = randomizer.Gen.NextData();
object data = CreateNew(type, randomizer, smartData);
if (data == null)
{
return(data);
}
Type dataType = data.GetType();
foreach (FieldInfo field in dataType.GetFields(BindingFlags.Instance | BindingFlags.Public)
.Where(f => !f.IsInitOnly && !f.IsLiteral))
{
string smartValue = (field.FieldType == typeof(string))
? smartData.Find(field.Name)
: null;
field.SetValue(data, smartValue ?? randomizer.Create(field.FieldType, data));
}
foreach (PropertyInfo property in dataType.GetProperties(BindingFlags.Instance | BindingFlags.Public)
.Where(p => p.CanWrite)
.Where(p => p.GetSetMethod() != null))
{
string smartValue = (property.PropertyType == typeof(string))
? smartData.Find(property.Name)
: null;
property.SetValue(data, smartValue ?? randomizer.Create(property.PropertyType, data));
}
return(data);
}
static public void DrawUI()
{
foreach (int itemID in UIDrawer.itemTexts.Keys)
{
UIDrawer.itemTexts[itemID][0].text = Data.GetItemPrice(itemID).ToString();
for (int imageIndex = 0; imageIndex < 2; imageIndex++)
{
UIDrawer.itemImages[itemID][imageIndex + 2].gameObject.SetActive(false);
}
if (DataEarntPersistent.userPointsBackup < Data.GetItemPrice(itemID))
{
UIDrawer.itemTexts[itemID][0].color = UIConfig.disabledColor;
for (int imageIndex = 0; imageIndex < 2; imageIndex++)
{
UIDrawer.itemImages[itemID][imageIndex].color = UIConfig.disabledColor;
}
}
}
UIDrawer.pointText.text = "CREDITS: " + DataRandom.GetPoints() + " ¢";
}
/// <summary>Creates a <typeparamref name="T"/> instance.</summary>
/// <typeparam name="T">Creation method type.</typeparam>
/// <param name="randomizer">Handles callback behavior for child values.</param>
/// <param name="smartData">Predefined random data.</param>
/// <param name="invoker">How to create the type from the creation method.</param>
/// <param name="creators">Possible creation methods.</param>
/// <returns>The created instance.</returns>
private static object CreateFrom <T>(RandomizerChainer randomizer, DataRandom smartData,
Func <T, object[], object> invoker, IEnumerable <T> creators) where T : MethodBase
{
T creator = randomizer.Gen.NextItem(creators);
if (creator is MethodInfo method && method.IsGenericMethodDefinition)
{
creator = (T)(object)method.MakeGenericMethod(method
.GetGenericArguments()
.Select(a => GenericCreateHint.CreateArg(a, randomizer))
.ToArray());
}
return(invoker.Invoke(creator, creator.GetParameters()
.Select(p =>
{
string smartValue = (p.ParameterType == typeof(string))
? smartData.Find(p.Name)
: null;
return smartValue ?? randomizer.Create(p.ParameterType, randomizer.Parent);
})
.ToArray()));
}
internal static void Find_NoResultNull(DataRandom testInstance, string name)
{
testInstance.Find(name).Assert().Is(null);
}
internal static void Find_IgnoresSpecialChars(DataRandom testInstance)
{
testInstance.Find("_" + DataRandom.SupportedProperties.First()).Assert().IsNot(null);
}
internal static void DataRandom_DataVaries(DataRandom testInstance)
{
Tools.Mutator.Variant(testInstance).Assert().IsNot(testInstance);
}