private static async Task SendAndReceiveEvents()
{
var eventBatch = new[]
{
new EventData(Encoding.UTF8.GetBytes("First event data")),
new EventData(Encoding.UTF8.GetBytes("Second event data")),
new EventData(Encoding.UTF8.GetBytes("Third event data"))
};
var index = 0;
var receivedEvents = new List <EventData>();
//Before sending any event, start the receiver
await receiver.ReceiveAsync(1, TimeSpan.Zero);
Console.Write("Ready to send a batch of " + eventBatch.Count().ToString() + " events... ");
await sender.SendAsync(eventBatch);
Console.Write("Sent\n");
Console.Write("Receiving events... ");
while ((receivedEvents.Count < eventBatch.Length) && (++index < 3))
{
receivedEvents.AddRange(await receiver.ReceiveAsync(eventBatch.Length + 10, TimeSpan.FromMilliseconds(25)));
}
index = 0;
//Check if at least one event was received in order to start validation
if (receivedEvents.Count == 0)
{
throw new Exception(String.Format("Error, No events received."));
}
Console.Write(receivedEvents.Count() + " events received.\n");
Console.WriteLine("Beginning validation...");
foreach (var receivedEvent in receivedEvents)
{
var receivedEventMessage = Encoding.UTF8.GetString(receivedEvent.Body.ToArray());
var sentEventMessage = Encoding.UTF8.GetString(eventBatch[index].Body.ToArray());
if (receivedEventMessage == sentEventMessage)
{
Console.WriteLine("\tEvent '" + receivedEventMessage + "' correctly validated.");
}
else
{
throw new Exception(String.Format("Error, Event: '" + receivedEventMessage + "' was not expected."));
}
index++;
}
if (index < eventBatch.Count())
{
throw new Exception(String.Format("Error, expecting " + eventBatch.Count().ToString() + " events, but only got " + index.ToString() + "."));
}
Console.WriteLine("done");
}
public override async Task Execute()
{
startLocation = Entity.Transform.Position;
startRotation = Entity.Transform.Rotation;
//grab a reference to the falling sphere's rigidbody
var rigidBody = Entity.Get <RigidbodyComponent>();
var triggerKey = TriggerEntity.Get <Trigger>().TriggerEvent;
var receiver = new EventReceiver <bool>(triggerKey);
while (!CancellationToken.IsCancellationRequested)
{
var state = await receiver.ReceiveAsync();
if (state)
{
//switch to dynamic and awake the rigid body
rigidBody.RigidBodyType = RigidBodyTypes.Dynamic;
rigidBody.Activate(true); //need to awake to object
}
else
{
//when out revert to kinematic and old starting position
rigidBody.RigidBodyType = RigidBodyTypes.Kinematic;
//reset position
Entity.Transform.Position = startLocation;
Entity.Transform.Rotation = startRotation;
Entity.Transform.UpdateWorldMatrix();
Entity.Get <PhysicsComponent>().UpdatePhysicsTransformation();
}
}
}
public override async Task Execute()
{
startLocation = Entity.Transform.Position;
startRotation = Entity.Transform.Rotation;
//grab a reference to the falling sphere's rigidbody
var rigidBody = Entity.Get<RigidbodyComponent>();
var triggerKey = TriggerEntity.Get<Trigger>().TriggerEvent;
var receiver = new EventReceiver<bool>(triggerKey);
while (!CancellationToken.IsCancellationRequested)
{
var state = await receiver.ReceiveAsync();
if (state)
{
//switch to dynamic and awake the rigid body
rigidBody.RigidBodyType = RigidBodyTypes.Dynamic;
rigidBody.Activate(true); //need to awake to object
}
else
{
//when out revert to kinematic and old starting position
rigidBody.RigidBodyType = RigidBodyTypes.Kinematic;
//reset position
Entity.Transform.Position = startLocation;
Entity.Transform.Rotation = startRotation;
Entity.Transform.UpdateWorldMatrix();
Entity.Get<PhysicsComponent>().UpdatePhysicsTransformation();
}
}
}
public void SameFrameReceiveAsync()
{
var test = new EventSystemTest();
var frameCounter = 0;
test.AddTask(async() =>
{
while (test.IsRunning)
{
frameCounter++;
await test.NextFrame();
}
}, 100);
test.AddTask(async() =>
{
var key = new EventKey();
var recv = new EventReceiver(key);
key.Broadcast();
var currentFrame = frameCounter;
await recv.ReceiveAsync();
Assert.Equal(currentFrame, frameCounter);
test.Exit();
});
test.Run();
}
public static MicroThread AddOnEventTask <T>(
this ScriptSystem scriptSystem,
EventReceiver <T> receiver,
Func <T, Task> action,
long priority = 0L)
{
if (scriptSystem == null)
{
throw new ArgumentNullException(nameof(scriptSystem));
}
if (receiver == null)
{
throw new ArgumentNullException(nameof(receiver));
}
if (action == null)
{
throw new ArgumentNullException(nameof(action));
}
return(scriptSystem.AddTask(DoEvent, priority));
//C# 7 Local function could also use a variable Func<Task> DoEvent = async () => { ... };
async Task DoEvent()
{
while (scriptSystem.Game.IsRunning)
{
await action(await receiver.ReceiveAsync());
}
}
}
public override async Task Execute()
{
var receiver = new EventReceiver(SphereKiller.GameOver);
await receiver.ReceiveAsync();
var ui = Entity.GetOrCreate <UIComponent>();
ui.Page = UIPage;
}
public void ReceiveAsyncValidatesTheMaximumCount(int maximumMessageCount)
{
var transportReceiver = new ObservableTransportReceiverMock();
var receiver = new EventReceiver(transportReceiver, "dummy", "0", new EventReceiverOptions());
var cancellation = new CancellationTokenSource();
var expectedWaitTime = TimeSpan.FromDays(1);
Assert.That(async() => await receiver.ReceiveAsync(maximumMessageCount, expectedWaitTime, cancellation.Token), Throws.InstanceOf <ArgumentException>());
}
public void ReceiveAsyncValidatesTheMaximumWaitTime(int timeSpanDelta)
{
var transportReceiver = new ObservableTransportReceiverMock();
var receiver = new EventReceiver(transportReceiver, "dummy", "0", new EventReceiverOptions());
var cancellation = new CancellationTokenSource();
var expectedWaitTime = TimeSpan.FromMilliseconds(timeSpanDelta);
Assert.That(async() => await receiver.ReceiveAsync(32, expectedWaitTime, cancellation.Token), Throws.InstanceOf <ArgumentException>());
}
public override async Task Execute()
{
var brickHit = new EventReceiver <Shock>(BrickShock.BrickHit);
while (Game.IsRunning)
{
var result = await brickHit.ReceiveAsync();
TreatShock(result);
}
}
public override async Task Execute()
{
graph = new ElectricCurrentGraph(Entity);
Entity.Add(new ElectricConductionScript());
while (Game.IsRunning)
{
await rebuildGraph.ReceiveAsync();
graph = new ElectricCurrentGraph(Entity);
}
}
private static async Task SendAndReceiveEvents()
{
var eventBatch = new[]
{
new EventData(Encoding.UTF8.GetBytes("First event data")),
new EventData(Encoding.UTF8.GetBytes("Second event data")),
new EventData(Encoding.UTF8.GetBytes("Third event data"))
};
var index = 0;
var receivedEvents = new List <EventData>();
//Before sending any event, start the receiver
await receiver.ReceiveAsync(1, TimeSpan.Zero);
Console.Write("Ready to send a batch of " + eventBatch.Count().ToString() + " events... ");
await sender.SendAsync(eventBatch);
Console.Write("Sent\n");
Console.Write("Receiving events... ");
while ((receivedEvents.Count < eventBatch.Length) && (++index < 3))
{
receivedEvents.AddRange(await receiver.ReceiveAsync(eventBatch.Length + 10, TimeSpan.FromMilliseconds(25)));
}
if (receivedEvents.Count == 0)
{
throw new Exception(String.Format("Error, No events received."));
}
Console.Write(receivedEvents.Count() + " events received.\n");
if (receivedEvents.Count() < eventBatch.Count())
{
throw new Exception(String.Format($"Error, expecting {eventBatch.Count()} events, but only got {receivedEvents.Count().ToString()}."));
}
Console.WriteLine("done");
}
public override async Task Execute()
{
while (Game.IsRunning)
{
var trigger = await listener.ReceiveAsync();
if (trigger != EventName)
{
continue;
}
EventReceived();
}
}
public override async Task Execute()
{
// Find our JumpyJetRenderer to start/stop parallax background
var renderer = (JumpyJetRenderer)((SceneCameraRenderer)SceneSystem.GraphicsCompositor.Game).Child;
while (Game.IsRunning)
{
await gameOverListener.ReceiveAsync();
renderer.StopScrolling();
await gameResetListener.ReceiveAsync();
renderer.StartScrolling();
}
}
public async Task ReceiveAsyncInvokesTheTransportReceiver()
{
var options = new EventReceiverOptions {
DefaultMaximumReceiveWaitTime = TimeSpan.FromMilliseconds(8)
};
var transportReceiver = new ObservableTransportReceiverMock();
var receiver = new EventReceiver(transportReceiver, "dummy", "0", options);
var cancellation = new CancellationTokenSource();
var expectedMessageCount = 45;
await receiver.ReceiveAsync(expectedMessageCount, null, cancellation.Token);
(var actualMessageCount, var actualWaitTime) = transportReceiver.ReceiveCalledWithParameters;
Assert.That(actualMessageCount, Is.EqualTo(expectedMessageCount), "The message counts should match.");
Assert.That(actualWaitTime, Is.EqualTo(options.DefaultMaximumReceiveWaitTime), "The wait time should match.");
}
public override async Task Execute()
{
// Find our JumpyJetRenderer to start/stop parallax background
var renderer = (JumpyJetRenderer)((SceneCameraRenderer)SceneSystem.GraphicsCompositor.Game).Child;
var pauseListener = new EventReceiver(GlobalEvents.CharacterDied);
var startListener = new EventReceiver(GlobalEvents.Clear);
while (Game.IsRunning)
{
// we don't care for the reason - either way we stop the background
await pauseListener.ReceiveAsync();
renderer.StopScrolling();
startListener.Reset(); // remove any start events that happened before pause
await startListener.ReceiveAsync();
renderer.StartScrolling();
pauseListener.Reset(); // remove any pause events that happened before the start
}
}
public override async Task Execute()
{
while (Game.IsRunning)
{
var target = await weaponFiredEvent.ReceiveAsync();
if (target.DidFire)
{
SpawnEvent("MuzzleFlash", Entity, Matrix.Identity);
}
if (target.DidHit)
{
SpawnEvent("BulletImpact", null, Matrix.RotationQuaternion(Quaternion.BetweenDirections(Vector3.UnitY, target.HitResult.Normal)) * Matrix.Translation(target.HitResult.Point));
}
if (target.HitResult.Collider is RigidbodyComponent rigidBody)
{
var rand = new Random();
SpawnEvent("DamagedTrail", rigidBody.Entity, Matrix.Translation(new Vector3((float)rand.NextDouble() - 0.5f, (float)rand.NextDouble() - 0.5f, (float)rand.NextDouble() - 0.5f)));
}
}
}
public void DifferentThreadBroadcast()
{
var game = new EventSystemTest();
var counter = 0;
var broadcaster = new EventKey();
var readyCount = 0;
game.AddTask(async() =>
{
var recv = new EventReceiver(broadcaster, EventReceiverOptions.Buffered);
Interlocked.Increment(ref readyCount);
for (;;)
{
await recv.ReceiveAsync();
Interlocked.Increment(ref counter);
}
});
game.AddTask(async() =>
{
var recv = new EventReceiver(broadcaster, EventReceiverOptions.Buffered);
Interlocked.Increment(ref readyCount);
for (;;)
{
await recv.ReceiveAsync();
Interlocked.Increment(ref counter);
}
});
game.AddTask(async() =>
{
var recv = new EventReceiver(broadcaster, EventReceiverOptions.Buffered);
Interlocked.Increment(ref readyCount);
for (;;)
{
await recv.ReceiveAsync();
Interlocked.Increment(ref counter);
}
});
var t1W = new AutoResetEvent(false);
var t2W = new AutoResetEvent(false);
var waitHandles = new WaitHandle[]
{
t1W,
t2W
};
Exception threadException = null;
new Thread(() =>
{
try
{
while (!game.IsRunning && readyCount < 3)
{
Thread.Sleep(200);
}
var frameCounter = 0;
while (true)
{
Thread.Sleep(50);
frameCounter++;
broadcaster.Broadcast();
if (frameCounter < 200)
{
continue;
}
t1W.Set();
return;
}
}
catch (Exception e)
{
threadException = e;
}
}).Start();
new Thread(() =>
{
try
{
while (!game.IsRunning && readyCount < 3)
{
Thread.Sleep(200);
}
var frameCounter = 0;
while (true)
{
Thread.Sleep(50);
frameCounter++;
broadcaster.Broadcast();
if (frameCounter < 200)
{
continue;
}
t2W.Set();
return;
}
}
catch (Exception e)
{
threadException = e;
}
}).Start();
new Thread(() =>
{
try
{
//wait until both threads have broadcasted 200 times each
if (!WaitHandle.WaitAll(waitHandles, TimeSpan.FromMinutes(2)))
{
throw new Exception("DifferentThreadBroadcast test timedout.");
}
Thread.Sleep(2000);
game.Exit();
}
catch (Exception e)
{
threadException = e;
}
}).Start();
game.Run();
Assert.Null(threadException);
Assert.Equal(1200, counter);
}
public void DifferentThreadBroadcast()
{
var game = new EventSystemTest();
var counter = 0;
var broadcaster = new EventKey();
game.AddTask(async() =>
{
var recv = new EventReceiver(broadcaster, EventReceiverOptions.Buffered);
for (;;)
{
await recv.ReceiveAsync();
counter++;
}
});
game.AddTask(async() =>
{
var recv = new EventReceiver(broadcaster, EventReceiverOptions.Buffered);
for (;;)
{
await recv.ReceiveAsync();
counter++;
}
});
game.AddTask(async() =>
{
var recv = new EventReceiver(broadcaster, EventReceiverOptions.Buffered);
for (;;)
{
await recv.ReceiveAsync();
counter++;
}
});
var t1W = new AutoResetEvent(false);
var t2W = new AutoResetEvent(false);
Exception threadException = null;
new Thread(async() =>
{
try
{
while (!game.IsRunning)
{
await Task.Delay(100);
}
var frameCounter = 0;
while (true)
{
await Task.Delay(20);
frameCounter++;
broadcaster.Broadcast();
if (frameCounter != 200)
{
continue;
}
t1W.Set();
return;
}
}
catch (Exception e)
{
threadException = e;
}
}).Start();
new Thread(async() =>
{
try
{
while (!game.IsRunning)
{
await Task.Delay(100);
}
var frameCounter = 0;
while (true)
{
await Task.Delay(20);
frameCounter++;
broadcaster.Broadcast();
if (frameCounter != 200)
{
continue;
}
t2W.Set();
return;
}
}
catch (Exception e)
{
threadException = e;
}
}).Start();
new Thread(async() =>
{
try
{
var waitHandles = new WaitHandle[]
{
t1W,
t2W
};
WaitHandle.WaitAll(waitHandles);
await Task.Delay(2000);
game.Exit();
}
catch (Exception e)
{
threadException = e;
}
}).Start();
game.Run();
Assert.IsNull(threadException);
Assert.AreEqual(1200, counter);
}
public void SameFrameReceiveAsync()
{
var test = new EventSystemTest();
var frameCounter = 0;
test.AddTask(async () =>
{
while (test.IsRunning)
{
frameCounter++;
await test.NextFrame();
}
}, 100);
test.AddTask(async () =>
{
var key = new EventKey();
var recv = new EventReceiver(key);
key.Broadcast();
var currentFrame = frameCounter;
await recv.ReceiveAsync();
Assert.AreEqual(currentFrame, frameCounter);
test.Exit();
});
test.Run();
}
public void DifferentThreadBroadcast()
{
var game = new EventSystemTest();
var counter = 0;
var broadcaster = new EventKey();
var readyCount = 0;
game.AddTask(async () =>
{
var recv = new EventReceiver(broadcaster, EventReceiverOptions.Buffered);
Interlocked.Increment(ref readyCount);
for (;;)
{
await recv.ReceiveAsync();
Interlocked.Increment(ref counter);
}
});
game.AddTask(async () =>
{
var recv = new EventReceiver(broadcaster, EventReceiverOptions.Buffered);
Interlocked.Increment(ref readyCount);
for (;;)
{
await recv.ReceiveAsync();
Interlocked.Increment(ref counter);
}
});
game.AddTask(async () =>
{
var recv = new EventReceiver(broadcaster, EventReceiverOptions.Buffered);
Interlocked.Increment(ref readyCount);
for (;;)
{
await recv.ReceiveAsync();
Interlocked.Increment(ref counter);
}
});
var t1W = new AutoResetEvent(false);
var t2W = new AutoResetEvent(false);
var waitHandles = new WaitHandle[]
{
t1W,
t2W
};
Exception threadException = null;
new Thread(() =>
{
try
{
while (!game.IsRunning && readyCount < 3)
{
Thread.Sleep(200);
}
var frameCounter = 0;
while (true)
{
Thread.Sleep(50);
frameCounter++;
broadcaster.Broadcast();
if (frameCounter < 200) continue;
t1W.Set();
return;
}
}
catch (Exception e)
{
threadException = e;
}
}).Start();
new Thread(() =>
{
try
{
while (!game.IsRunning && readyCount < 3)
{
Thread.Sleep(200);
}
var frameCounter = 0;
while (true)
{
Thread.Sleep(50);
frameCounter++;
broadcaster.Broadcast();
if (frameCounter < 200) continue;
t2W.Set();
return;
}
}
catch (Exception e)
{
threadException = e;
}
}).Start();
new Thread(() =>
{
try
{
//wait until both threads have broadcasted 200 times each
if (!WaitHandle.WaitAll(waitHandles, TimeSpan.FromMinutes(2)))
{
throw new Exception("DifferentThreadBroadcast test timedout.");
}
Thread.Sleep(2000);
game.Exit();
}
catch (Exception e)
{
threadException = e;
}
}).Start();
game.Run();
Assert.IsNull(threadException);
Assert.AreEqual(1200, counter);
}
public override async Task Execute()
{
await Task.Yield(); // don't execute initialization on call
Start();
// Wait for scripts to get initialized????
await Script.NextFrame();
await newGameEvent.ReceiveAsync();
while (true)
{
await Script.NextFrame();
DebugText.Print($"Generation: {generation}\nAlive: {dead.Count(d => !d)}/{ai.Count}\nScore: {score}\nHighscore: {highscore}", new Int2(20, 300));
var profiler = Profiler.Begin(AIProfilingKey);
// get current state
float dist = 0, height = 0;
PipesScript.ProvideAiInformation(ref dist, ref height);
for (int i = 0; i < characterScripts.Length; i++)
{
if (dead[i])
{
continue;
}
var character = characterScripts[i];
if (!character.isRunning || character.isDying)
{
dead[i] = true;
// disable collisions to save some processing time
characterPhysics[i].CanCollideWith = (CollisionFilterGroupFlags)0;
neat.AddWithScore(ai[i], score);
continue;
}
var position = character.Movement.Position.Y;
// we try to find a function that given to positions
// tries to jump so that they come close together
var aiResult = ai[i].Compute(neat.options, new double[] { position, height });
if (aiResult[0] > 0.5)
{
character.Jump();
}
}
score++;
highscore = score > highscore ? score : highscore;
if (dead.All(d => d))
{
GlobalEvents.GameOver.Broadcast();
ResetRound();
}
profiler.End();
}
}
