public ClientConnectionHandler(
ITaskScheduler taskScheduler,
IWindsorContainer container,
IObjectSerializer packetSerializer,
IIncomingNetworkEventHandler networkEventProcessor,
ILogger logger,
IEventBus eventBus,
IGamePlatformAccessor gamePlatformAccessor) : base(packetSerializer, networkEventProcessor, logger, eventBus, gamePlatformAccessor)
{
m_TaskScheduler = taskScheduler;
m_Container = container;
m_Logger = logger;
eventBus.Subscribe <ENetNetworkEvent>(this, OnNetworkEvent);
}
public ServerConnectionHandler(
IObjectSerializer packetSerializer,
IIncomingNetworkEventHandler networkEventProcessor,
ILogger logger,
IEventBus eventBus,
ISnapshotCache snapshotCache,
IGamePlatformAccessor gamePlatformAccessor,
IMapManager mapManager) : base(packetSerializer, networkEventProcessor, logger, eventBus, gamePlatformAccessor)
{
m_EventBus = eventBus;
m_MapManager = mapManager;
m_Logger = logger;
m_Snapshots = snapshotCache;
ClientTimeOut = TimeSpan.FromSeconds(15);
}
protected BaseConnectionHandler(IObjectSerializer packetSerializer, IIncomingNetworkEventHandler networkEventProcessor, ILogger logger, IEventBus eventBus, IGamePlatformAccessor gamePlatformAccessor)
{
eventBus.Subscribe <GameQuitEvent>(this, (s, e) => { Dispose(); });
m_EventBus = eventBus;
m_PacketSerializer = packetSerializer;
m_NetworkEventProcessor = networkEventProcessor;
m_Logger = logger;
int capacity = 1024;
if (gamePlatformAccessor.GamePlatform == GamePlatform.Server)
{
capacity *= ServerConnectionHandler.MaxPlayersUpperLimit;
}
m_OutgoingQueue = new RingBuffer <OutgoingPacket>(capacity);
m_ConnectedPeers = new List <INetworkPeer>();
m_PacketDescriptions = new Dictionary <byte, PacketDescription>();
RegisterPacket((byte)PacketType.Ping, new PacketDescription(
name: nameof(PacketType.Ping),
direction: PacketDirection.Any,
channel: (byte)NetworkChannel.PingPong,
packetFlags: PacketFlags.Reliable)
);
RegisterPacket((byte)PacketType.Pong, new PacketDescription(
name: nameof(PacketType.Pong),
direction: PacketDirection.Any,
channel: (byte)NetworkChannel.PingPong,
packetFlags: PacketFlags.Reliable)
);
RegisterPacket((byte)PacketType.Authenticate, new PacketDescription(
name: nameof(PacketType.Authenticate),
direction: PacketDirection.ClientToServer,
channel: (byte)NetworkChannel.Main,
packetFlags: PacketFlags.Reliable,
needsAuthentication: false)
);
RegisterPacket((byte)PacketType.Authenticated, new PacketDescription(
name: nameof(PacketType.Authenticated),
direction: PacketDirection.ServerToClient,
channel: (byte)NetworkChannel.Main,
packetFlags: PacketFlags.Reliable)
);
RegisterPacket((byte)PacketType.MapChange, new PacketDescription(
name: nameof(PacketType.MapChange),
direction: PacketDirection.ServerToClient,
channel: (byte)NetworkChannel.Main,
packetFlags: PacketFlags.Reliable)
);
RegisterPacket((byte)PacketType.WorldUpdate, new PacketDescription(
name: nameof(PacketType.WorldUpdate),
direction: PacketDirection.ServerToClient,
channel: (byte)NetworkChannel.World,
packetFlags: PacketFlags.Reliable) //Todo: Make this Unsequenced after Snapshots get implemented fully
);
RegisterPacket((byte)PacketType.InputUpdate, new PacketDescription(
name: nameof(PacketType.InputUpdate),
direction: PacketDirection.ClientToServer,
channel: (byte)NetworkChannel.Input,
packetFlags: PacketFlags.Unsequenced)
);
RegisterPacket((byte)PacketType.Terminate, new PacketDescription(
name: nameof(PacketType.Terminate),
direction: PacketDirection.ServerToClient,
channel: (byte)NetworkChannel.Input,
packetFlags: PacketFlags.Reliable)
);
RegisterPacket((byte)PacketType.Rpc, new PacketDescription(
name: nameof(PacketType.Rpc),
direction: PacketDirection.Any,
channel: (byte)NetworkChannel.Rpc,
packetFlags: PacketFlags.Reliable)
);
}
