Syntriax/Engine-Pong
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

feat: working networked paddles

Browse Source
This commit is contained in:
Syntriax 2025-05-18 00:49:14 +03:00
parent 54bdcd93b2
commit 214c37e63f
4 changed files with 40 additions and 165 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

52
Shared/Behaviours/PaddleBehaviour.cs
View File

@ -19,25 +19,22 @@ public class PaddleBehaviour(Keys Up, Keys Down, float High, float Low, float Sp
private bool isUpPressed = false;
private bool isDownPressed = false;
private bool isMovingUp = false;
private bool isMovingDown = false;
private IButtonInputs<Keys> inputs = null!;
private INetworkCommunicatorClient networkClient = null!;
private INetworkCommunicatorServer? networkServer = null;
protected override void OnUpdate()
{
if (isUpPressed && isDownPressed)
if (isMovingUp && isMovingDown)
return;
if (isUpPressed)
{
if (isMovingUp)
Transform.Position = Transform.Position + Vector2D.Up * Universe.Time.DeltaTime * Speed;
networkClient.SendToServer(new EntityPaddlePositionPacket(this));
}
else if (isDownPressed)
{
else if (isMovingDown)
Transform.Position = Transform.Position + -Vector2D.Up * Universe.Time.DeltaTime * Speed;
networkClient.SendToServer(new EntityPaddlePositionPacket(this));
}
Transform.Position = new Vector2D(Transform.Position.X, MathF.Max(MathF.Min(Transform.Position.Y, High), Low));
}
@ -46,9 +43,10 @@ public class PaddleBehaviour(Keys Up, Keys Down, float High, float Low, float Sp
{
inputs = Universe.FindRequiredBehaviour<IButtonInputs<Keys>>();
networkClient = Universe.GetRequiredUniverseObject<INetworkCommunicatorClient>();
networkServer = Universe.GetRequiredUniverseObject<INetworkCommunicatorServer>();
networkServer = Universe.GetUniverseObject<INetworkCommunicatorServer>();
networkClient.SubscribeToPackets<EntityPaddlePositionPacket>(ReceiveDataClient);
networkServer.SubscribeToPackets<EntityPaddlePositionPacket>(ReceiveDataServer);
networkServer?.SubscribeToPackets<EntityPaddlePositionPacket>(ReceiveDataServer);
inputs.RegisterOnPress(Up, OnUpPressed);
inputs.RegisterOnRelease(Up, OnUpReleased);
@ -65,17 +63,21 @@ public class PaddleBehaviour(Keys Up, Keys Down, float High, float Low, float Sp
inputs.UnregisterOnRelease(Down, OnDownReleased);
}
private void OnUpPressed(IButtonInputs<Keys> inputs, Keys keys) => isUpPressed = true;
private void OnUpReleased(IButtonInputs<Keys> inputs, Keys keys) => isUpPressed = false;
private void OnDownPressed(IButtonInputs<Keys> inputs, Keys keys) => isDownPressed = true;
private void OnDownReleased(IButtonInputs<Keys> inputs, Keys keys) => isDownPressed = false;
private void OnUpPressed(IButtonInputs<Keys> inputs, Keys keys) { isUpPressed = true; networkClient.SendToServer(new EntityPaddlePositionPacket(this)); }
private void OnUpReleased(IButtonInputs<Keys> inputs, Keys keys) { isUpPressed = false; networkClient.SendToServer(new EntityPaddlePositionPacket(this)); }
private void OnDownPressed(IButtonInputs<Keys> inputs, Keys keys) { isDownPressed = true; networkClient.SendToServer(new EntityPaddlePositionPacket(this)); }
private void OnDownReleased(IButtonInputs<Keys> inputs, Keys keys) { isDownPressed = false; networkClient.SendToServer(new EntityPaddlePositionPacket(this)); }
public void ReceiveDataClient<T>(T data, string _)
{
if (data is not EntityPaddlePositionPacket position)
return;
Transform.Position = position.Position;
if (position.EntityId.CompareTo(Id) != 0)
return;
isMovingUp = position.IsUpPressed;
isMovingDown = position.IsDownPressed;
}
public void ReceiveDataServer<T>(T data, string fromClientId)
@ -83,22 +85,17 @@ public class PaddleBehaviour(Keys Up, Keys Down, float High, float Low, float Sp
if (data is not EntityPaddlePositionPacket position)
return;
Transform.Position = position.Position;
networkServer?.SendToClient("*", position);
}
public void ReceiveDataClient<T>(T data)
{
if (data is not EntityPaddlePositionPacket position)
if (position.EntityId.CompareTo(Id) != 0)
return;
Transform.Position = position.Position;
networkServer?.SendToClient("*", position);
}
public class EntityPaddlePositionPacket : IEntityNetworkPacket
{
public string EntityId = default!;
public Vector2D Position = default!;
public string EntityId { get; set; } = default!;
public bool IsUpPressed { get; set; } = default!;
public bool IsDownPressed { get; set; } = default!;
string IEntityNetworkPacket.EntityId => EntityId;
@ -106,7 +103,8 @@ public class PaddleBehaviour(Keys Up, Keys Down, float High, float Low, float Sp
public EntityPaddlePositionPacket(PaddleBehaviour paddleBehaviour)
{
EntityId = paddleBehaviour.Id;
Position = paddleBehaviour.Transform.Position;
IsUpPressed = paddleBehaviour.isUpPressed;
IsDownPressed = paddleBehaviour.isDownPressed;
}
}
}

39
Shared/GamePong.cs
View File

@ -1,16 +1,18 @@
using System;
using System.Linq;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Pong.Behaviours;
using Apos.Shapes;
using Pong.Behaviours;
using Syntriax.Engine.Core;
using Syntriax.Engine.Physics2D;
using System.Linq;
using Syntriax.Engine.Network;
using Syntriax.Engine.Core.Factory;
using Syntriax.Engine.Network;
using Syntriax.Engine.Physics2D;
namespace Pong;
@ -76,13 +78,12 @@ public class GamePong : Game
universe.Register(platformSpecificUniverseObject);
NetworkManager networkManager = universe.InstantiateUniverseObject<NetworkManager>().SetUniverseObject("Network Manager");
networkManager.NetworkCommunicator = universe.InstantiateUniverseObject<LiteNetLibClient>().SetUniverseObject("Client").Connect("localhost", 8888).SendToServer(new TestMessagePacket("Hola")).SubscribeToPackets<TestMessagePacket>(OnClientPacketReceived);
if (Environment.GetCommandLineArgs().FirstOrDefault(x => x.CompareTo("-server") == 0) is not null)
{
universe.InstantiateUniverseObject<LiteNetLibServer>().SetUniverseObject("Server").Start(8888, 2).SubscribeToPackets<TestMessagePacket>(OnServerPacketReceived);
universe.InstantiateUniverseObject<LiteNetLibServer>().SetUniverseObject("Server").Start(8888, 2);
Window.Title = $"{Window.Title} - Server";
}
universe.InstantiateUniverseObject<LiteNetLibClient>().SetUniverseObject("Client").Connect("localhost", 8888);
universe.InstantiateUniverseObject<PhysicsEngine2D>().SetUniverseObject("Physics Engine 2D");
////////////////////////////////////////////////////////////////////////////////////
@ -108,19 +109,21 @@ public class GamePong : Game
////////////////////////////////////////////////////////////////////////////////////
IUniverseObject leftPaddle = UniverseObjectFactory.Instantiate().SetUniverseObject("Left Paddle");
leftPaddle.Id = "lp";
leftPaddle.BehaviourController.AddBehaviour<Transform2D>().SetTransform(position: new Vector2D(-468f, 0f), scale: new Vector2D(15f, 60f))
.BehaviourController.AddBehaviour<PaddleBehaviour>(Keys.W, Keys.S, 228f, -228f, 400f)
.BehaviourController.AddBehaviour<ShapeBehaviour>(Shape2D.Square)
.BehaviourController.AddBehaviour<RigidBody2D>().IsStatic = true;
PaddleBehaviour leftPaddleBehaviour = BehaviourFactory.Instantiate<PaddleBehaviour>(Keys.W, Keys.S, 228f, -228f, 400f);
leftPaddleBehaviour.Id = "lp";
leftPaddle.BehaviourController.AddBehaviour(leftPaddleBehaviour);
universe.Register(leftPaddle);
IUniverseObject rightPaddle = UniverseObjectFactory.Instantiate().SetUniverseObject("Right Paddle");
rightPaddle.Id = "rp";
rightPaddle.BehaviourController.AddBehaviour<Transform2D>().SetTransform(position: new Vector2D(468f, 0f), scale: new Vector2D(15f, 60f))
.BehaviourController.AddBehaviour<PaddleBehaviour>(Keys.Up, Keys.Down, 228f, -228f, 400f)
.BehaviourController.AddBehaviour<ShapeBehaviour>(Shape2D.Square)
.BehaviourController.AddBehaviour<RigidBody2D>().IsStatic = true;
PaddleBehaviour rightPaddleBehaviour = BehaviourFactory.Instantiate<PaddleBehaviour>(Keys.Up, Keys.Down, 228f, -228f, 400f);
rightPaddleBehaviour.Id = "rp";
rightPaddle.BehaviourController.AddBehaviour(rightPaddleBehaviour);
universe.Register(rightPaddle);
////////////////////////////////////////////////////////////////////////////////////
@ -158,20 +161,6 @@ public class GamePong : Game
.BehaviourController.AddBehaviour<TextScoreBehaviour>(false, spriteFont);
}
private void OnClientPacketReceived(TestMessagePacket packet, string from)
{
Console.WriteLine($"Message received from server: {packet.Message}");
leftText.Text = packet.Message;
}
private void OnServerPacketReceived(TestMessagePacket packet, string from)
{
Console.WriteLine($"Message received from client: {packet.Message}");
rightText.Text = packet.Message;
universe.GetRequiredUniverseObject<INetworkCommunicatorServer>().SendToClient(from, new TestMessagePacket("Reply!"));
}
protected override void Update(GameTime gameTime)
{
if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed || Keyboard.GetState().IsKeyDown(Keys.Escape))

5
Shared/Network/Abstract/INetworkEntity.cs
View File

@ -2,7 +2,4 @@ using Syntriax.Engine.Core;
namespace Syntriax.Engine.Network;
public interface INetworkEntity : IEntity
{
void ReceiveDataClient<T>(T data);
}
public interface INetworkEntity : IEntity;

109
Shared/Network/NetworkManager.cs
View File

@ -1,109 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using Syntriax.Engine.Core;
namespace Syntriax.Engine.Network;
public class NetworkManager : UniverseObject, INetworkManager
{
private INetworkCommunicator networkCommunicator = null!;
private readonly List<(Type packetType, Delegate callback)> delegates = [];
public INetworkCommunicator NetworkCommunicator
{
get => networkCommunicator;
set
{
if (networkCommunicator == value)
return;
var previousCommunicator = networkCommunicator;
networkCommunicator = value;
if (previousCommunicator is not null) UnsubscribeDelegates(networkCommunicator);
if (networkCommunicator is not null) SubscribeDelegates(networkCommunicator);
}
}
private readonly Dictionary<string, INetworkEntity> _networkEntities = [];
public IReadOnlyDictionary<string, INetworkEntity> NetworkEntities => _networkEntities;
private readonly BehaviourCollector<INetworkEntity> _networkEntityCollector = new();
public IBehaviourCollector<INetworkEntity> NetworkEntityCollector => _networkEntityCollector;
public NetworkManager()
{
CacheDelegates();
_networkEntityCollector.OnCollected += OnCollected;
_networkEntityCollector.OnRemoved += OnRemoved;
}
private void CacheDelegates()
{
// Find network packets implementing EntityDataPacket<>
IEnumerable<Type> packetTypes = AppDomain.CurrentDomain.GetAssemblies().SelectMany(a => a.GetTypes())
.Where(t => typeof(IEntityNetworkPacket).IsAssignableFrom(t) && !t.IsInterface && !t.IsAbstract && !t.IsGenericType);
MethodInfo onPacketArrivedMethod = GetType()
.GetMethod(nameof(OnPacketReceived), BindingFlags.NonPublic | BindingFlags.Instance)!;
foreach (Type packetType in packetTypes)
{
MethodInfo genericOnPacketArrivedMethod = onPacketArrivedMethod.MakeGenericMethod(packetType);
Type genericDelegateType = typeof(Action<,>).MakeGenericType(packetType, typeof(string));
Delegate genericPacketReceivedDelegate = Delegate.CreateDelegate(genericDelegateType, this, genericOnPacketArrivedMethod);
delegates.Add((packetType, genericPacketReceivedDelegate));
}
}
private void SubscribeDelegates(INetworkCommunicator networkCommunicator)
{
MethodInfo subscribeToPacketsMethod = typeof(INetworkCommunicator)
.GetMethod(nameof(INetworkCommunicator.SubscribeToPackets), BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance)!;
foreach ((Type packetType, Delegate callback) in delegates)
{
MethodInfo genericSubscribeMethod = subscribeToPacketsMethod.MakeGenericMethod(packetType);
genericSubscribeMethod.Invoke(networkCommunicator, [callback]);
}
}
private void UnsubscribeDelegates(INetworkCommunicator networkCommunicator)
{
MethodInfo unsubscribeFromPacketsMethod = typeof(INetworkCommunicator)
.GetMethod(nameof(INetworkCommunicator.UnsubscribeFromPackets), BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance)!;
foreach ((Type packetType, Delegate callback) in delegates)
{
MethodInfo genericUnsubscribeMethod = unsubscribeFromPacketsMethod.MakeGenericMethod(packetType);
genericUnsubscribeMethod.Invoke(networkCommunicator, [callback]);
}
}
private void OnPacketReceived<T>(T entityDataPacket, string fromClientId)
{
if (entityDataPacket is IEntityNetworkPacket entityNetworkPacket)
_networkEntities[entityNetworkPacket.EntityId].ReceiveDataClient(entityDataPacket);
}
private void OnCollected(IBehaviourCollector<INetworkEntity> sender, INetworkEntity behaviourCollected)
{
if (!_networkEntities.TryAdd(behaviourCollected.Id, behaviourCollected))
throw new($"Unable to add {behaviourCollected.Id} to {nameof(NetworkManager)}");
}
private void OnRemoved(IBehaviourCollector<INetworkEntity> sender, INetworkEntity behaviourRemoved)
{
_networkEntities.Remove(behaviourRemoved.Id);
}
protected override void OnEnteringUniverse(IUniverse universe) => _networkEntityCollector.Assign(universe);
protected override void OnExitingUniverse(IUniverse universe) => _networkEntityCollector.Unassign();
}