public void CouldAddVariantSeries()
{
var sm = new SortedMap <int, double>();
for (int i = 0; i < 100; i++)
{
sm.Add(i, (i * 100));
}
var vs = new VariantSeries <int, double>(sm);
var doubled = vs + vs;
foreach (var item in doubled)
{
System.Console.WriteLine(item.Key.Get <int>() + ": " + item.Value.Get <double>());
}
Assert.AreEqual(Variant.Create(0), doubled.First.Key);
Assert.AreEqual(Variant.Create(0.0), doubled.First.Value);
Assert.AreEqual(Variant.Create(99), doubled.Last.Key);
Assert.AreEqual(Variant.Create(9900.0 * 2), doubled.Last.Value);
var cursorSeries = doubled.ReadOnly();
Assert.AreEqual(Variant.Create(0), cursorSeries.First.Key);
}
private string GetText()
{
Variant value = Variant.Create();
TextView_c.GetValue(Pointer, value.Pointer);
return(value.AsString());
}
public void CouldCreateAndReadBool()
{
var b = Variant.Create(true);
Assert.AreEqual(TypeEnum.Bool, b.TypeEnum);
Assert.AreEqual(true, b.Get <bool>());
}
private float GetValue()
{
Variant value = Variant.Create();
PowerBarView_c.GetValue(Pointer, value.Pointer);
return(value.AsFloat());
}
public void CouldReadVariantSeries()
{
var sm = new SortedMap <int, string>();
for (int i = 0; i < 100; i++)
{
sm.Add(i, (i * 100).ToString());
}
var vs = new VariantSeries <int, string>(sm);
foreach (var item in vs)
{
System.Console.WriteLine(item.Key.Get <int>() + ": " + item.Value.Get <string>());
}
Assert.AreEqual(Variant.Create(0), vs.First.Key);
Assert.AreEqual(Variant.Create("0"), vs.First.Value);
Assert.AreEqual(Variant.Create(99), vs.Last.Key);
Assert.AreEqual(Variant.Create("9900"), vs.Last.Value);
var cursorSeries = new CursorSeries <int, string>(sm);
Assert.AreEqual(0, cursorSeries.First.Key);
}
private static View CreateMenu(Menu menu, ViewSelector viewSelector)
{
View view = menu.CreateView();
viewSelector.GetListView().AppendItem(StringListViewItem.Create(Variant.Create(view.Handle), menu.Name, 216, 0));
viewSelector.AppendView(view);
return(view);
}
public void ColumnTest()
{
var isFixedSize = TypeHelper <TestRow> .IsFixedSize;
var count = 100000;
var accessor = TypeAccessor.Create(typeof(TestRow));
var rows = new TestRow[count];
for (int i = 0; i < count; i++)
{
rows[i] = new TestRow
{
Col1 = i,
Col2 = i,
Col3 = i,
//Col11 = i,
//Col21 = i,
//Col31 = i
};
}
var memberSet = accessor.GetMembers();
Array[] arrays = new Array[memberSet.Count];
Variant[] variants = new Variant[memberSet.Count];
var memberCount = memberSet.Count;
for (int i = 0; i < memberCount; i++)
{
arrays[i] = Array.CreateInstance(memberSet[i].Type, count);
var arr = arrays[i];
variants[i] = Variant.Create(arr);
}
var names = memberSet.Select(m => m.Name).ToArray();
for (int round = 0; round < 100; round++)
{
var sw = new Stopwatch();
sw.Restart();
for (var r = 0; r < count; r++)
{
for (var c = 0; c < memberCount; c++)
{
var value = accessor[rows[r], names[c]];
//arrays[c].SetValue(value, r);
variants[c][r] = Variant.Create(value); // almost 4x slower
}
}
sw.Stop();
Console.WriteLine($"To columns: {sw.ElapsedMilliseconds} msec");
}
}
public async void RangeOnVariantSeriesWorks()
{
var sm = new SortedMap <DateTime, int>();
for (int i = 0; i < 100; i++)
{
sm.Add(DateTime.Today.AddSeconds(i), i);
}
var vs = new VariantSeries <DateTime, int>(sm);
Assert.IsTrue(!vs.Comparer.Equals(KeyComparer <Variant> .Default));
var rs = vs.After(Variant.Create(DateTime.Today.AddSeconds(50)));
Assert.IsTrue(!rs.Comparer.Equals(KeyComparer <Variant> .Default));
var expected = 0;
for (int i = 50; i < 100; i++)
{
expected += i;
}
var sum = 0;
foreach (var variantKvp in rs)
{
sum += variantKvp.Value.Get <int>();
}
Assert.AreEqual(expected, sum);
var t = Task.Run(async() =>
{
try
{
for (int i = 100; i < 150; i++)
{
sm.Add(DateTime.Today.AddSeconds(i), i);
await Task.Delay(1);
}
sm.Complete();
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
});
var c = rs.GetCursor();
while (await c.MoveNext(CancellationToken.None))
{
sum += c.CurrentValue.Get <int>();
}
}
private unsafe bool GetIsChecked()
{
Variant pOutput = Variant.Create(0);
IntPtr what = CheckBox_c.GetValue(_pointer, pOutput.Pointer);
bool result = Variant.FromPointer(what).AsInt32() == 1;
pOutput.Dispose();
return(result);
}
public void CouldCreateAndReadErrorCode()
{
var variant = Variant.Create(new ErrorCode {
Code = 123456789
});
Assert.AreEqual(TypeEnum.ErrorCode, variant.TypeEnum);
Assert.AreEqual(123456789, variant.Get <ErrorCode>().Code);
var obj = variant.ToObject();
Assert.AreEqual(typeof(ErrorCode), obj.GetType());
}
public void CouldJsonConvertVariantWithCustomObject()
{
var variant = Variant.Create(new TestKnownType {
Int = 123, Str = "str"
});
var json = JsonConvert.SerializeObject(variant);
Console.WriteLine(json);
var variant2 = JsonConvert.DeserializeObject <Variant>(json);
Assert.AreEqual(variant._object, variant2._object);
}
public void CouldJsonConvertVariantArrayOfVariants()
{
var arrayVariant = Variant.Create(new Variant[] { Variant.Create(123), Variant.Create(456.7) });
var json = JsonConvert.SerializeObject(arrayVariant);
Console.WriteLine(json);
var arrayVariant2 = JsonConvert.DeserializeObject <Variant>(json);
Assert.AreEqual(123, arrayVariant2[0].Get <int>());
Assert.AreEqual(123, arrayVariant2[0].Get <int>(0));
Assert.AreEqual(456.7, arrayVariant2[1].Get <double>());
Assert.AreEqual(456.7, arrayVariant2[1].Get <double>(0));
}
public void CouldSerializeTable()
{
var sw = new Stopwatch();
sw.Restart();
var rows = 100;
var columns = 100;
var data = new Variant[rows, columns];
for (int i = 0; i < rows; i++)
{
for (int j = 0; j < columns; j++)
{
data[i, j] = Variant.Create(i * j);
}
}
var table = new Table(data);
sw.Stop();
Console.WriteLine($"Elapsed create: {sw.ElapsedMilliseconds}");
sw.Restart();
sw.Stop();
Console.WriteLine($"Elapsed snapshot: {sw.ElapsedMilliseconds}");
sw.Restart();
MemoryStream tmp;
var len = BinarySerializer.SizeOf(table, out tmp);
Console.WriteLine($"Binary size: {len}");
//var mem = BufferPool<byte>.Rent(len);
//BinarySerializer.Write(table, mem, 0, tmp);
sw.Stop();
Console.WriteLine($"Elapsed serialize: {sw.ElapsedMilliseconds}");
sw.Restart();
//var str = JsonConvert.SerializeObject(table);
//Console.WriteLine(str.Length);
//Console.WriteLine(str);
var delta = table.ToDelta(table);
sw.Stop();
Console.WriteLine($"Elapsed delta: {sw.ElapsedMilliseconds}");
var str2 = JsonConvert.SerializeObject(delta);
Console.WriteLine($"Delta length: {str2.Length} count: {delta.Cells.Count}");
}
public void CouldJsonConvertVariantArrayOfVariantsWithString()
{
var arrayVariant = Variant.Create(new Variant[] { Variant.Create(123), Variant.Create("456.7") });
var arrayVariantNested = Variant.Create(new Variant[] { Variant.Create(arrayVariant), Variant.Create("456.7") });
var json = JsonConvert.SerializeObject(arrayVariant);
var json2 = JsonConvert.SerializeObject(arrayVariantNested);
Console.WriteLine(json);
Console.WriteLine(json2);
var arrayVariant2 = JsonConvert.DeserializeObject <Variant>(json);
Assert.AreEqual(123, arrayVariant2[0].Get <int>());
Assert.AreEqual(123, arrayVariant2[0].Get <int>(0));
Assert.AreEqual("456.7", arrayVariant2[1].Get <string>());
Assert.AreEqual("456.7", arrayVariant2[1].Get <string>(0));
}
public void CouldCreateAndReadWriteArrayVariant()
{
var array = new double[2];
array[0] = 123;
array[1] = 456;
var v = Variant.Create(array);
Assert.AreEqual(TypeEnum.Array, v.TypeEnum);
Assert.AreEqual(TypeEnum.Float64, v.ElementTypeEnum);
Assert.AreEqual(8, v.ElementByteSize);
Assert.AreEqual(2, v.Count);
var boxedArray = (object)array;
var v2 = Variant.Create(boxedArray);
Assert.AreEqual(TypeEnum.Array, v2.TypeEnum);
Assert.AreEqual(TypeEnum.Float64, v2.ElementTypeEnum);
Assert.AreEqual(8, v2.ElementByteSize);
Assert.AreEqual(2, v2.Count);
var span = v2.Span <double>();
Assert.AreEqual(123.0, span[0]);
Assert.AreEqual(456.0, span[1]);
Assert.AreEqual(2, span.Length);
span[0] = 42;
span[1] = 43;
// array values are assigned via span
Assert.AreEqual(42, array[0]);
Assert.AreEqual(43, array[1]);
var x = Variant.Create(44.0);
Assert.AreEqual(TypeEnum.Float64, x.TypeEnum);
v2[0] = x;
v2[1] = Variant.Create(45.0);
Assert.AreEqual(44, array[0]);
Assert.AreEqual(45, array[1]);
}
void testMSIBallErf()
{
try {
ExternalComponentLibrary library = ErfContext.GetInstance().LoadComponentLibrary("MSIBallErf.dll");
if (library == null)
{
Debug.LogError("Could not load MSIBallErf library");
return;
}
} catch (Exception e)
{
Debug.Log(e.Message);
return;
}
//init:
ExternalExpert msiBallEmotionModel = ErfContext.GetInstance().FindExpert("MSIBallEmotionModel");
CharacterModel playerModel = new CharacterModel();
playerModel.RegisterExpert(msiBallEmotionModel);
//collision:
EecEvent timeElapsedEvent = new EecEvent((int)GameEvent.STD_TIME_ELAPSED);
timeElapsedEvent.AddValue("NO_OF_COLLISIONS", Variant.Create(2));
timeElapsedEvent.AddValue("CURRENT_SPEED", Variant.Create(7.0f));
playerModel.HandleEvent(timeElapsedEvent);
//odpowiedz z erf
float fear = playerModel.GetEmotionVector().GetValue(OccEmotions.FEAR).AsFloat();
//przeliczenie na poziom trudnosci
if (fear > 0.0f)
{
Debug.Log("FIRST I WAS AFRAID, I WAS PETRIFIED!");
}
else
{
Debug.Log("I AM FEARLESS! I AM DEATH! I AM FIRE!");
}
}
public void CouldCreateAndReadWriteInlinedVariant()
{
var v = Variant.Create(123.0);
Assert.AreEqual(123.0, v.Get <double>());
Assert.Throws <InvalidCastException>(() =>
{
v.Set(456); // no implicit conversion
});
v.Set(456.0);
Assert.AreEqual(456.0, v.Get <double>());
Assert.AreEqual(1, v.Count);
// correctly parse boxed primitives
var obj = (object)42.0;
var v2 = Variant.Create(obj);
Assert.AreEqual(v2.TypeEnum, TypeEnum.Float64);
Assert.AreEqual(42.0, v2.Get <double>());
Assert.AreEqual(1, v2.Count);
var span = v2.Span <double>();
Assert.AreEqual(42, span[0]);
Assert.AreEqual(1, span.Length);
span[0] = 43;
Assert.AreEqual(43.0, v2.Get <double>());
var x = Variant.Create(44.0);
Assert.AreEqual(44.0, x.Get <double>());
Assert.Throws <InvalidCastException>(() =>
{
v2[0] = Variant.Create(44); // no implicit conversion
});
v2[0] = Variant.Create(44.0);
var v3 = v2[0];
Assert.AreEqual(44.0, v3.Get <double>());
}
public void CouldUseVariantJsonConverter()
{
var variant = Variant.Create(123);
string json = JsonConvert.SerializeObject(variant);
Console.WriteLine(json);
var arrayVariant = Variant.Create(new[] { 123, 456 });
var json2 = JsonConvert.SerializeObject(arrayVariant);
Console.WriteLine(json2);
var variant2 = JsonConvert.DeserializeObject <Variant>(json);
Assert.AreEqual(123, variant2.Get <int>(0));
Assert.AreEqual(123, variant2.Get <int>());
var arrayVariant2 = JsonConvert.DeserializeObject <Variant>(json2);
Assert.AreEqual(123, arrayVariant2.Get <int>(0));
Assert.AreEqual(456, arrayVariant2.Get <int>(1));
}
public void CouldCreateAndReadInlinedVariantInALoop()
{
var count = 100000000;
var sw = new Stopwatch();
for (int round = 0; round < 10; round++)
{
sw.Restart();
var sum = 0.0;
for (int i = 0; i < count; i++)
{
var v = Variant.Create <double>(i);
var d = v.Get <double>();
sum += d;
}
sw.Stop();
if (sum < double.MaxValue)
{
Console.WriteLine($"Elapsed: {sw.ElapsedMilliseconds}, Mops: {count / (sw.ElapsedMilliseconds * 0.001)}");
}
}
}
public void CouldCreateAndReadInlinedVariantInALoop()
{
var count = 50000000;
var sum = 0.0;
for (int round = 0; round < 10; round++)
{
using (Benchmark.Run("Variant", count))
{
sum = 0.0;
for (int i = 0; i < count; i++)
{
var v = Variant.Create <double>(i);
var d = v.Get <double>();
sum += d;
}
if (sum == double.MaxValue)
{
ThrowHelper.ThrowInvalidOperationException();
}
}
}
Benchmark.Dump();
}
private void SetValue(float value)
{
PowerBarView_c.SetValue(Pointer, Variant.Create(value).Pointer, false);
}
public override Variant ToKey2(TKey key)
{
return(Variant.Create(key));
}
public override Variant ToValue2(TValue value)
{
return(Variant.Create(value));
}
void FixedUpdate()
{
float fac;
//transition scale
float curScale = transform.localScale.x;
float newScale = 0.05f * (targetScale - curScale) + curScale;
transform.localScale = new Vector3(newScale, newScale, newScale);
//
if (gameSettings.gameMode == GameMode.EMOTIONAL)
{
//erf
DateTime now = DateTime.Now;
if ((now - lastReportTime).TotalMilliseconds >= interval)//czy należy rozpatrzeć zmianę emocji?
{
lastReportTime = now;
//tutaj wysyłamy emocję
EecEvent timeElapsedEvent = new EecEvent((int)GameEvent.STD_TIME_ELAPSED);
timeElapsedEvent.AddValue("NO_OF_COLLISIONS", Variant.Create(scoreController.buffer.movingScore));
timeElapsedEvent.AddValue("CURRENT_SPEED", Variant.Create(zSpeed));
playerModel.HandleEvent(timeElapsedEvent);
//odpowiedz z erf
float fear = playerModel.GetEmotionVector().GetValue(OccEmotions.FEAR).AsFloat();
//adaptacyjny zakres
if (fear < minFear)
{
minFear = fear;
}
else if (fear > maxFear)
{
maxFear = fear;
}
float fearLength = maxFear - minFear;
float fearRatio = (fear - minFear) / fearLength;
if (fearRatio < 0.1f)
{
setDifficultyEnum(GameDifficulty.HARD);
}
else if (fearRatio < 0.4)
{
setDifficultyEnum(GameDifficulty.MEDIUM);
}
else
{
setDifficultyEnum(GameDifficulty.EASY);
}
Debug.LogFormat("ratio: {0} [{1} - {2} - {3}", fearRatio, minFear, fear, maxFear);
}
}
else
{
//nie zmieniamy poziomu trudności
}
if (Input.GetKeyDown("escape"))//wychodzimy do menu?
{
Application.LoadLevel("MainMenuScene");
}
//obsługa poruszania kulą przez użytkownika
float moveHorizontal = Input.GetAxis("Horizontal");
float moveVertical = Input.GetAxis("Vertical");
Vector3 movement = new Vector3(moveHorizontal / difficulty, 0.0f, zSpeed);
rb.AddForce(movement * speed);
distanceTraveled = transform.localPosition.z;
updateSpeed();
}
public void CouldCreateWriteReadInlinedVariantInALoop()
{
var count = 100000000;
var sw = new Stopwatch();
for (int round = 0; round < 10; round++)
{
sw.Restart();
var sum = 0.0;
var v = Variant.Create <double>(0.0);
for (int i = 0; i < count; i++)
{
v.Set <double>(i);
var d = v.Get <double>();
sum += d;
}
sw.Stop();
if (sum < double.MaxValue)
{
Console.WriteLine($"Variant Elapsed: {sw.ElapsedMilliseconds}, Mops: {count / (sw.ElapsedMilliseconds * 0.001)}");
}
sw.Restart();
for (int i = 0; i < count; i++)
{
v.UnsafeSetInlined <double>(i);
var d = v.UnsafeGetInilned <double>();
sum += d;
}
sw.Stop();
if (sum < double.MaxValue)
{
Console.WriteLine($"Unsafe Variant Elapsed: {sw.ElapsedMilliseconds}, Mops: {count / (sw.ElapsedMilliseconds * 0.001)}");
}
sw.Restart();
for (int i = 0; i < count; i++)
{
var span = v.Span <double>();
span[0] = i;
var d = span[0];
sum += d;
}
sw.Stop();
if (sum < double.MaxValue)
{
Console.WriteLine($"Span (Inline) Variant Elapsed: {sw.ElapsedMilliseconds}, Mops: {count / (sw.ElapsedMilliseconds * 0.001)}");
}
var v2 = Variant.Create <double>(new[] { 0.0 });
sw.Restart();
for (int i = 0; i < count; i++)
{
var span = v2.Span <double>();
span[0] = i;
var d = span[0];
sum += d;
}
sw.Stop();
if (sum < double.MaxValue)
{
Console.WriteLine($"Span (Array) Variant Elapsed: {sw.ElapsedMilliseconds}, Mops: {count / (sw.ElapsedMilliseconds * 0.001)}");
}
sw.Restart();
for (int i = 0; i < count; i++)
{
v2.Set <double>(0, 0.0);
var d = v2.Get <double>(0);
sum += d;
}
sw.Stop();
if (sum < double.MaxValue)
{
Console.WriteLine($"Get/Set(idx) Variant Elapsed: {sw.ElapsedMilliseconds}, Mops: {count / (sw.ElapsedMilliseconds * 0.001)}");
}
sw.Restart();
sum = 0.0;
var array = new[] { 0.0 };
for (int i = 0; i < count; i++)
{
array[0] = i;
var d = array[0];
sum += d;
}
sw.Stop();
if (sum < double.MaxValue && array[0] > 0)
{
Console.WriteLine($"Array Elapsed: {sw.ElapsedMilliseconds}, Mops: {count / (sw.ElapsedMilliseconds * 0.001)}");
}
sw.Restart();
sum = 0.0;
var container = new Container <double>();
for (int i = 0; i < count; i++)
{
container.Value = i;
var d = container.Value;
sum += d;
}
sw.Stop();
if (sum < double.MaxValue && container.Value > 0)
{
Console.WriteLine($"Inlined Property Elapsed: {sw.ElapsedMilliseconds}, Mops: {count / (sw.ElapsedMilliseconds * 0.001)}");
}
sw.Restart();
sum = 0.0;
var dummyContainer = new DummyContainer <double>();
for (int i = 0; i < count; i++)
{
dummyContainer.Value = i;
var d = dummyContainer.Value;
sum += d;
}
sw.Stop();
if (sum < double.MaxValue && dummyContainer.Value > 0)
{
Console.WriteLine($"Noninlined Property Elapsed: {sw.ElapsedMilliseconds}, Mops: {count / (sw.ElapsedMilliseconds * 0.001)}");
}
sw.Restart();
sum = 0.0;
var boxed = new BoxedContainer();
for (int i = 0; i < count; i++)
{
boxed.Value = (double)i;
var d = (double)boxed.Value;
sum += d;
}
sw.Stop();
if (sum < double.MaxValue)
{
Console.WriteLine($"Inlined Boxed Elapsed: {sw.ElapsedMilliseconds}, Mops: {count / (sw.ElapsedMilliseconds * 0.001)}");
}
sw.Restart();
sum = 0.0;
var boxedDummy = new BoxedDummyContainer();
for (int i = 0; i < count; i++)
{
boxedDummy.Value = (double)i;
var d = (double)boxed.Value;
sum += d;
}
sw.Stop();
if (sum < double.MaxValue)
{
Console.WriteLine($"Noninlined Boxed Elapsed: {sw.ElapsedMilliseconds}, Mops: {count / (sw.ElapsedMilliseconds * 0.001)}");
}
Console.WriteLine("---------------------------------");
}
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
if (reader.TokenType == JsonToken.Null)
{
return(Variant.FromObject(null));
}
if (reader.TokenType != JsonToken.StartArray)
{
throw new Exception("Invalid JSON for Variant type");
}
var codeValue = reader.ReadAsInt32();
Debug.Assert(codeValue != null, "codeValue != null");
var typeCode = (TypeEnum)(byte)codeValue;
TypeEnum subTypeCode = TypeEnum.None;
if (typeCode == TypeEnum.Array)
{
var subTypeCodeValue = reader.ReadAsInt32();
Debug.Assert(subTypeCodeValue != null, "subTypeCodeValue != null");
subTypeCode = (TypeEnum)(byte)subTypeCodeValue;
if (subTypeCode == TypeEnum.FixedBinary)
{
throw new NotImplementedException("Need special handling of fixed binary values");
}
}
if (typeCode == TypeEnum.FixedBinary)
{
//var size = reader.ReadAsInt32();
throw new NotImplementedException("Need special handling of fixed binary values");
}
object obj;
if (typeCode == TypeEnum.Object)
{
var objectTypeCodeValue = reader.ReadAsInt32();
Debug.Assert(objectTypeCodeValue != null, "objectTypeCodeValue != null");
var objectTypeCode = (byte)objectTypeCodeValue;
var type = KnownTypeAttribute.GetType(objectTypeCode);
if (!reader.Read())
{
throw new Exception("Cannot read JSON");
}
obj = serializer.Deserialize(reader, type);
}
else if (typeCode != TypeEnum.None)
{
if (!reader.Read())
{
throw new Exception("Cannot read JSON");
}
var type = VariantHelper.GetType(typeCode, subTypeCode);
obj = serializer.Deserialize(reader, type);
}
else
{
obj = Variant.Create(null);
}
if (!reader.Read())
{
throw new Exception("Cannot read JSON");
}
Trace.Assert(reader.TokenType == JsonToken.EndArray);
return(Variant.FromObject(obj));
}
