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(); } }