public void StartServer()
{
DontDestroyOnLoad(gameObject);
_logicTimer = new LogicTimer(OnLogicUpdate);
_playerManager = new ServerPlayerManager(this);
//_packetProcessor = new NetPacketProcessor();
////register auto serializable vector2
//_packetProcessor.RegisterNestedType((w, v) => w.Put(v), r => r.GetVector2());
////register auto serializable PlayerState
//_packetProcessor.RegisterNestedType<PlayerState>();
//_packetProcessor.SubscribeReusable<JoinPacket, NetPeer>(OnJoinReceived);
//_netManager = new NetManager(this)
//{
// AutoRecycle = true
//};
_netManager = G.CSEngineApp.LiteNet._netManager;
_packetProcessor = G.CSEngineApp.LiteNet._packetProcessor;
_packetProcessor.RegisterNestedType((w, v) => w.Put(v), r => r.GetVector2());
_packetProcessor.RegisterNestedType <PlayerState>();
_packetProcessor.SubscribeReusable <JoinPacket, NetPeer>(OnJoinReceived);
_netManager.Start(10515);
_logicTimer.Start();
}
public void Init()
{
_samplePacket = new SamplePacket
{
SomeFloat = 3.42f,
SomeIntArray = new[] { 6, 5, 4 },
SomeString = "Test String",
SomeVector2 = new SomeVector2(4, 5),
SomeVectors = new[] { new SomeVector2(1, 2), new SomeVector2(3, 4) },
SomeEnum = TestEnum.B,
SomeByteArray = new byte[] { 255, 1, 0 },
TestObj = new SampleNetSerializable {
Value = 5
},
TestArray = new [] { new SampleNetSerializable {
Value = 6
}, new SampleNetSerializable {
Value = 15
} },
SampleClassArray = new[] { new SampleClass {
Value = 6
}, new SampleClass {
Value = 15
} }
};
_packetProcessor = new NetPacketProcessor();
_packetProcessor.RegisterNestedType <SampleNetSerializable>();
_packetProcessor.RegisterNestedType(() => new SampleClass());
_packetProcessor.RegisterNestedType(SomeVector2.Serialize, SomeVector2.Deserialize);
}
private void Awake()
{
DontDestroyOnLoad(gameObject);
Random r = new Random();
_cachedServerState = new ServerState();
_cachedShootData = new ShootPacket();
_userName = Environment.MachineName + " " + r.Next(100000);
LogicTimer = new LogicTimer(OnLogicUpdate);
_writer = new NetDataWriter();
_playerManager = new ClientPlayerManager(this);
_shootsPool = new GamePool <ShootEffect>(ShootEffectContructor, 100);
_packetProcessor = new NetPacketProcessor();
_packetProcessor.RegisterNestedType((w, v) => w.Put(v), reader => reader.GetVector2());
_packetProcessor.RegisterNestedType <PlayerState>();
_packetProcessor.SubscribeReusable <PlayerJoinedPacket>(OnPlayerJoined);
_packetProcessor.SubscribeReusable <JoinAcceptPacket>(OnJoinAccept);
_packetProcessor.SubscribeReusable <PlayerLeavedPacket>(OnPlayerLeaved);
_netManager = new NetManager(this)
{
AutoRecycle = true,
IPv6Enabled = IPv6Mode.Disabled
};
_netManager.Start();
}
public void RegisterPacketsListeners()
{
//Registramos el serializador del nuevo tipo creado
netPacketProcessorClient.RegisterNestedType(SeralizeVector3.Serialize, SeralizeVector3.Deserialize);
//Registramos el serializador creado al implementar INetSerializar
netPacketProcessorClient.RegisterNestedType <Cat>(() => new Cat());
//Crea el listener que se activara cuando se reciba un paquete de ese tipo
netPacketProcessorClient.SubscribeReusable <WelcomePacket>((packet) =>
{
Debug.Log("Test packet received");
Debug.Log(packet.NumberValue);
});
netPacketProcessorClient.SubscribeReusable <HpPlayerChanged>((packet) =>
{
Debug.Log("New hp received");
Debug.Log(packet.NewHp);
});
netPacketProcessorClient.SubscribeReusable <PositionPacktet>((packet) =>
{
Debug.Log("New vector3 received");
Debug.Log(packet.position);
});
}
void Awake()
{
m_serverScene = SceneManager.LoadScene("server_scene", Constants.DefaultSceneParams);
m_ServerSimulation = m_serverScene.GetPhysicsScene();
SceneManager.MoveGameObjectToScene(m_ServerSharedPlayer.gameObject, m_serverScene);
m_LogicLoop = new GameLoop(OnNetworkUpdate);
m_Inputs = new RingBuffer <InputMessage>(Constants.SNAPSHOT_RATE);
m_PacketProcessor = new NetPacketProcessor();
m_PacketProcessor.RegisterNestedType <EntityState>();
m_PacketProcessor.RegisterNestedType <InputData>();
m_PacketProcessor.SubscribeNetSerializable <InputMessage, NetPeer>(OnPlayerInput);
m_Manager = new NetManager(this);
m_LogicLoop.Start();
if (m_Manager.Start(5000))
{
print("SERVER NET MANAGER STARTED!");
}
else
{
print("SERVER NET MANAGER FAILED!");
}
}
private void SetupPacketProcessor()
{
packetProcessor = new NetPacketProcessor();
packetProcessor.RegisterNestedType((w, v) => w.Put(v), reader => reader.GetVector2());
packetProcessor.RegisterNestedType <PlayerState>();
packetProcessor.SubscribeReusable <JoinPacket, NetPeer>(OnJoinReceived.Handle);
packetProcessor.RegisterNestedType <ClientPlayer>();
packetProcessor.SubscribeReusable <PlayerSendUpdatePacket, NetPeer>(OnPlayerUpdate.Handle);
packetProcessor.SubscribeReusable <LevelChangePacket, NetPeer>(OnLevelChange.Handle);
}
protected BaseNetManager()
{
NetManager = new NetManager(this)
{
UnsyncedEvents = true, AutoRecycle = true
};
PacketProcessor = new NetPacketProcessor();
PacketProcessor.RegisterNestedType <MediaInfo>();
PacketProcessor.RegisterNestedType <SharedSessionInfo>();
PacketProcessor.RegisterNestedType <UserInfo>();
}
public ServerSerivce()
{
_serverManager = new ServerManager();
_logicTimer = new LogicTimer(OnUpdateLogic);
_packetProcessor = new NetPacketProcessor();
_packetProcessor.RegisterNestedType((w, v) => w.Put(v), r => r.GetVector2());
_packetProcessor.RegisterNestedType <CharacterPacket>();
_packetProcessor.SubscribeReusable <JoinPacket, NetPeer>(OnJoin);
_netManager = new NetManager(this, true);
}
public static void RegisterPackets(NetPacketProcessor processor)
{
processor.RegisterNestedType <Input>();
processor.RegisterNestedType(Vector3Serializer.Serialize, Vector3Serializer.Deserialize);
processor.RegisterNestedType(QuaternionSerializer.Serialize, QuaternionSerializer.Deserialize);
processor.SubscribeReusable <ClientSendPositionPacket>(ClientSendPositionPacket.OnReceive);
processor.SubscribeReusable <InitialTickPacket>(InitialTickPacket.OnReceive);
processor.SubscribeReusable <ClientInputPacket>(ClientInputPacket.OnReceive);
processor.SubscribeReusable <HostAckInputPacket>(HostAckInputPacket.OnReceive);
processor.SubscribeReusable <HostGameStateOnTickPacket>(HostGameStateOnTickPacket.OnReceive);
}
public NetClient()
{
_processor = new NetPacketProcessor();
_processor.RegisterNestedType <PlayersInRoomStruct>();
_processor.RegisterNestedType <PointStruct>();
_processor.SubscribeReusable <ServerPacket, NetPeer>(HandleServerCommand);
_processor.SubscribeReusable <RoomPacket, NetPeer>(HandleRoomCommand);
_processor.SubscribeReusable <PlayerPacket, NetPeer>(HandlePlayerCommand);
_processor.SubscribeReusable <RoomReadyPacket, NetPeer>(HandleRoomReadyPacket);
_processor.SubscribeReusable <GamePacket, NetPeer>(HandleGamePacket);
_processor.SubscribeReusable <TurnPacket, NetPeer>(HandleTurn);
}
void Awake()
{
m_ClientScene = SceneManager.LoadScene("client_scene", Constants.DefaultSceneParams);
m_ClientSimulation = m_ClientScene.GetPhysicsScene();
SceneManager.MoveGameObjectToScene(m_GetPlayer.gameObject, m_ClientScene);
m_LogicLoop = new GameLoop(OnNetworkUpdate);
m_Simulation = new SimulationStep[Constants.SNAPSHOT_RATE];
m_Snapshots = new RingBuffer <Snapshot>(Constants.SNAPSHOT_RATE);
m_Input = new InputMessage(0, 0, new List <InputData>());
m_PacketProcessor = new NetPacketProcessor();
m_PacketProcessor.RegisterNestedType <EntityState>();
m_PacketProcessor.SubscribeNetSerializable <Snapshot>(OnStateMessage);
m_Manager = new NetManager(this);
m_LogicLoop.Start();
if (m_Manager.Start())
{
m_Manager.Connect("127.0.0.1", 5000, "key");
print("CLIENT NET MANAGER STARTED!");
}
else
{
print("CLIENT NET MANAGER FAILED!");
}
m_Poller = GetComponent <InputPoller>();
UI_Handler.instance.TurnOn();
UIControl.instance.TurnOff();
}
public void TestThingMessage()
{
// Test whether the serialization framework supports property inheritance.
// ThingMessage.Create derives from CreateMessage which has an Id property.
var createThingMessage = new ThingMessages.Create(1, new int[] { });
var writer = new NetDataWriter();
NetPacketProcessor processor = new NetPacketProcessor();
processor.RegisterNestedType <DistributedId>();
processor.Write(writer, createThingMessage);
var reader = new NetDataReader(writer.CopyData());
ThingMessages.Create readMessage = null;
processor.Subscribe(
createMessage => readMessage = createMessage,
() => new ThingMessages.Create());
processor.ReadAllPackets(reader);
Assert.IsNotNull(readMessage);
Assert.AreEqual(new DistributedId(1), readMessage.Id);
}
/// <summary>
/// Sets initial states and runs setup on required components.
/// </summary>
private void Start()
{
packetProcessor = new NetPacketProcessor();
packetProcessor.RegisterNestedType((w, v) => w.Put(v), reader => reader.GetVector3());
packetProcessor.RegisterNestedType <TransformPacket>();
Input.gyro.enabled = true;
Input.compensateSensors = true;
writer = new NetDataWriter();
writer.Reset();
writer.Put(discoveryMessage);
NetManagerSetup();
FetchLocalIP();
SendAndResetDiscoveryRequest();
}
public Server()
{
server = new NetManager(this)
{
AutoRecycle = true,
};
clients = new Dictionary <ushort, NebulaConnection>();
PacketProcessor = new NetPacketProcessor();
PacketProcessor.RegisterNestedType <NebulaId>();
PacketProcessor.RegisterNestedType <Float3>();
PacketProcessor.RegisterNestedType <Float4>();
PacketProcessor.RegisterNestedType <NebulaTransform>();
PacketProcessor.RegisterNestedType <NebulaAnimationState>();
PacketProcessor.SubscribeReusable <Movement, NebulaConnection> (OnPlayerMovement);
PacketProcessor.SubscribeReusable <PlayerAnimationUpdate, NebulaConnection> (OnPlayerAnimationUpdate);
PacketProcessor.SubscribeReusable <PlayerSpawned, NebulaConnection> (OnPlayerSpawned);
}
public void Run()
{
//setup netpacketprocessor
_netPacketProcessor.RegisterNestedType <CustomStruct>();
_netPacketProcessor.SubscribeReusable <ArgumentsForLogin, NetPeer>(Method1);
//setup events
EventBasedNetListener clientListener = new EventBasedNetListener();
EventBasedNetListener serverListener = new EventBasedNetListener();
serverListener.ConnectionRequestEvent += request =>
{
request.AcceptIfKey("key");
};
serverListener.NetworkReceiveEvent +=
(peer, reader, channel, method) =>
{
_netPacketProcessor.ReadAllPackets(reader, peer);
};
clientListener.PeerConnectedEvent += peer =>
{
//send after connect
var testList = new List <CustomStruct>
{
new CustomStruct {
X = 1, Y = -1
},
new CustomStruct {
X = 5, Y = -28
},
new CustomStruct {
X = -114, Y = 65535
}
};
_netPacketProcessor.Send(
peer,
new ArgumentsForLogin {
Password = "******", SomeInt = 5, UserId = "someUser", SomeList = testList
},
DeliveryMethod.ReliableOrdered);
};
//start client/server
_client = new NetManager(clientListener);
_server = new NetManager(serverListener);
_client.Start();
_server.Start(9050);
_client.Connect("localhost", 9050, "key");
while (!Console.KeyAvailable)
{
_server.PollEvents();
_client.PollEvents();
Thread.Sleep(10);
}
_client.Stop();
_server.Stop();
}
public NetChannel(DebugNetworkSettings debugNetworkSettings)
{
netManager = new NetManager(this)
{
AutoRecycle = true,
EnableStatistics = true,
UnconnectedMessagesEnabled = true, // For ping/pong
};
netPacketProcessor = new NetPacketProcessor();
netDataWriter = new NetDataWriter();
this.debugNetworkSettings = debugNetworkSettings;
ApplyDebugNetworkSettings();
// Register nested types used in net commands.
netPacketProcessor.RegisterNestedType(
NetExtensions.SerializeVector3, NetExtensions.DeserializeVector3);
netPacketProcessor.RegisterNestedType(
NetExtensions.SerializeQuaternion, NetExtensions.DeserializeQuaternion);
netPacketProcessor.RegisterNestedType <PlayerSetupData>();
netPacketProcessor.RegisterNestedType <PlayerMetadata>();
netPacketProcessor.RegisterNestedType <InitialPlayerState>();
netPacketProcessor.RegisterNestedType <PlayerState>();
netPacketProcessor.RegisterNestedType <NetworkObjectState>();
// The client network manager is started immediately for unconnected pings.
netManager.Start();
}
private void Awake()
{
DontDestroyOnLoad(gameObject);
_logicTimer = new LogicTimer(OnLogicUpdate);
_packetProcessor = new NetPacketProcessor();
_playerManager = new ServerPlayerManager(this);
//register auto serializable vector2
_packetProcessor.RegisterNestedType((w, v) => w.Put(v), r => r.GetVector2());
//register auto serializable PlayerState
_packetProcessor.RegisterNestedType <PlayerState>();
_packetProcessor.SubscribeReusable <JoinPacket, NetPeer>(OnJoinReceived);
_netManager = new NetManager(this)
{
AutoRecycle = true
};
}
void Awake()
{
Packets.RegisterNestedType(SerializationHelpers.SerializeLoadAgent, SerializationHelpers.DeserializeLoadAgent);
Packets.SubscribeReusable <Commands.Info, NetPeer>(OnInfoCommand);
Packets.SubscribeReusable <Commands.LoadResult, NetPeer>(OnLoadResultCommand);
Manager = new NetManager(this);
Manager.UpdateTime = 1;
Manager.Start();
}
// Start is called before the first frame update
void Start()
{
writer = new NetDataWriter();
packetProcessor = new NetPacketProcessor();
packetProcessor.RegisterNestedType((w, v) => w.Put(v), reader => reader.GetVector2());
// Will reuse the same packet class instance instead of creating new ones, so make sure to not store references to it or its contents!
packetProcessor.SubscribeReusable <JoinPacket, NetPeer>(OnJoinReceived);
packetProcessor.SubscribeReusable <PlayerSendUpdatePacket, NetPeer>(OnPlayerUpdate);
// Registering the custom INetSerializable struct in the packet processor
packetProcessor.RegisterNestedType <PlayerState>();
packetProcessor.RegisterNestedType <ClientPlayer>();
server = new NetManager(this)
{
AutoRecycle = true,
};
}
protected NetworkSkirmishManager(Game game, bool isHosting)
: base(game, isHosting)
{
_listener = new EventBasedNetListener();
_manager = new NetManager(_listener);
_writer = new NetDataWriter();
_processor = new NetPacketProcessor();
_processor.RegisterNestedType(SkirmishSlot.Serialize, SkirmishSlot.Deserialize);
}
public ClientService(ActionService actionService, CharacterService characterService, Transform stage)
{
_clientManager = new ClientManager(actionService, characterService, stage);
_cachedServerState = new ServerStatePacket();
_writer = new NetDataWriter();
_packetProcessor = new NetPacketProcessor();
_packetProcessor.RegisterNestedType((writer, v) => writer.Put(v), reader => reader.GetVector2());
_packetProcessor.RegisterNestedType <CharacterPacket>();
_packetProcessor.SubscribeReusable <CharacterJoinedPacket>(OnPlayerJoined);
_packetProcessor.SubscribeReusable <PlayerLeavedPacket>(OnPlayerLeaved);
_packetProcessor.SubscribeReusable <JoinAcceptPacket>(OnJoinAccept);
var rand = new Random();
_userName = $"{Environment.MachineName} {rand.Next(100000)}";
_netManager = new NetManager(this, true);
_netManager.Start();
LogicTimer = new LogicTimer(OnUpdateLogic);
}
public Client()
{
EventBasedNetListener listener = new EventBasedNetListener();
listener.PeerConnectedEvent += OnPeerConnected;
listener.PeerDisconnectedEvent += OnPeerDisconnected;
listener.NetworkReceiveEvent += OnNetworkReceive;
client = new NetManager(listener)
{
AutoRecycle = true,
};
PacketProcessor = new NetPacketProcessor();
PacketProcessor.RegisterNestedType <NebulaId>();
PacketProcessor.RegisterNestedType <Float3>();
PacketProcessor.RegisterNestedType <Float4>();
PacketProcessor.RegisterNestedType <NebulaTransform>();
PacketProcessor.RegisterNestedType <NebulaAnimationState>();
PacketProcessor.SubscribeReusable <PlayerJoinedSession>(OnSessionJoined);
}
public void Connect(string endpoint, int port)
{
if (manager != null)
{
throw new InvalidOperationException();
}
var listener = new EventBasedNetListener();
manager = new NetManager(listener);
manager.Start();
manager.Connect(endpoint, port, nameof(MultiplayerTest));
listener.PeerConnectedEvent += peer => server = peer;
var processor = new NetPacketProcessor();
processor.RegisterNestedType <Order>(() => new Order());
processor.SubscribeReusable <OrderPacket>(packet =>
{
foreach (var order in packet.Orders)
{
OrderReceived?.Invoke(order);
}
});
listener.NetworkReceiveEvent += (fromPeer, dataReader, deliveryMethod) =>
{
var type = (PacketType)dataReader.GetByte();
switch (type)
{
case PacketType.StartGame:
var players = dataReader.GetInt();
GameStarted?.Invoke(players);
break;
case PacketType.Orders:
processor.ReadAllPackets(dataReader);
break;
}
dataReader.Recycle();
};
writer = new NetDataWriter();
thread = new Thread(Run)
{
IsBackground = true
};
thread.Start();
}
void Awake()
{
Packets.RegisterNestedType(SerializationHelpers.SerializeLoadAgent, SerializationHelpers.DeserializeLoadAgent);
Packets.SubscribeReusable <Commands.Load>(OnLoadCommand);
Packets.SubscribeReusable <Commands.Run>(OnRunCommand);
Manager = new NetManager(this);
Manager.UpdateTime = 1;
Manager.Start(Constants.Port);
DontDestroyOnLoad(this);
}
public void RegisterPacketsListeners()
{
//Registramos el serializador del nuevo tipo creado
netPacketProcessorServer.RegisterNestedType(SeralizeVector3.Serialize, SeralizeVector3.Deserialize);
//Registramos el serializador creado al implementar INetSerializar
netPacketProcessorServer.RegisterNestedType <Cat>(() => new Cat());
//Crea el listener que se activara cuando se reciba un paquete de ese tipo
netPacketProcessorServer.SubscribeReusable <HpPlayerDecreasedPacket, NetPeer>((packet, peer) =>
{
//En este caso cada vez que recibamos este paquete,
//reenviaremos la nueva vida a todos los clientes que no sean el que envio este paquete
hp -= packet.DecreasedQuantity;
HpPlayerChanged hpPacket = new HpPlayerChanged()
{
NewHp = hp
};
SendToAllExceptSender(hpPacket, peer, DeliveryMethod.ReliableOrdered);
//podriamos reenviar el propio paquete recibido con
//SendToAllExceptSender(packet, peer, DeliveryMethod.ReliableOrdered);
});
}
public void Connect(string ip, string username)
{
player.username = username;
writer = new NetDataWriter();
packetProcessor = new NetPacketProcessor();
packetProcessor.RegisterNestedType((w, v) => w.Put(v), reader => reader.GetVector2());
packetProcessor.RegisterNestedType <PlayerState>();
packetProcessor.RegisterNestedType <ClientPlayer>();
packetProcessor.SubscribeReusable <JoinAcceptPacket>(OnJoinAccept);
packetProcessor.SubscribeReusable <PlayerReceiveUpdatePacket>(OnReceiveUpdate);
packetProcessor.SubscribeReusable <PlayerJoinedGamePacket>(OnPlayerJoin);
packetProcessor.SubscribeReusable <PlayerLeftGamePacket>(OnPlayerLeave);
client = new NetManager(this)
{
AutoRecycle = true,
};
client.Start();
Debug.Log("Connecting to server");
client.Connect(ip, 12345, "");
}
protected SkirmishManager(Game game, bool isHosting)
{
_game = game;
_listener = new EventBasedNetListener();
_manager = new NetManager(_listener);
_writer = new NetDataWriter();
_processor = new NetPacketProcessor();
_processor.RegisterNestedType(SkirmishSlot.Serialize, SkirmishSlot.Deserialize);
IsHosting = isHosting;
SkirmishGame = new SkirmishGame(isHost: IsHosting);
}
public NetworkConnection()
{
_listener = new EventBasedNetListener();
_manager = new NetManager(_listener)
{
ReuseAddress = true,
IPv6Enabled = IPv6Mode.Disabled, // TODO: temporary
};
if (Debugger.IsAttached)
{
_manager.DisconnectTimeout = 600000;
}
_listener.PeerConnectedEvent += peer => Logger.Trace($"{peer.EndPoint} connected");
_listener.PeerDisconnectedEvent += (peer, info) => Logger.Trace($"{peer.EndPoint} disconnected with reason {info.Reason}");
_listener.ConnectionRequestEvent += request =>
{
Logger.Trace($"Accepting connection from {request.RemoteEndPoint}");
var peer = request.Accept();
Logger.Trace($"Accept result: {peer}");
};
_listener.NetworkReceiveEvent += (NetPeer peer, NetPacketReader reader, DeliveryMethod deliveryMethod) => _processor.ReadAllPackets(reader);
_writer = new NetDataWriter();
_processor = new NetPacketProcessor();
_processor.RegisterNestedType <Order>(WriteOrder, ReadOrder);
_processor.Subscribe <SkirmishOrderPacket>(packet =>
{
if (_receivedPacketsPerFrame.TryGetValue(packet.Frame, out int count))
{
count++;
}
else
{
_receivedPacketsPerFrame.Add(packet.Frame, 1);
}
StorePacket(packet);
},
() => new SkirmishOrderPacket());
}
public NetworkConnection(SkirmishGame game)
{
_numberOfOtherPlayers = game.Slots.Count(s => s.State == SkirmishSlotState.Human) - 1;
_listener = new EventBasedNetListener();
_manager = new NetManager(_listener);
if (Debugger.IsAttached)
{
_manager.DisconnectTimeout = 600000;
}
_listener.PeerConnectedEvent += peer => Logger.Trace($"{peer.EndPoint} connected");
_listener.PeerDisconnectedEvent += (peer, info) => Logger.Trace($"{peer.EndPoint} disconnected with reason {info.Reason}");
_listener.NetworkReceiveEvent += (NetPeer peer, NetPacketReader reader, DeliveryMethod deliveryMethod) => _processor.ReadAllPackets(reader, peer);
_writer = new NetDataWriter();
_processor = new NetPacketProcessor();
_processor.RegisterNestedType <Order>(WriteOrder, ReadOrder);
_processor.Subscribe <SkirmishOrderPacket, NetPeer>(ReceiveOrderPacket, () => new SkirmishOrderPacket());
}
protected SkirmishManager(Game game, bool isHosting)
{
_game = game;
_listener = new EventBasedNetListener();
_manager = new NetManager(_listener)
{
ReuseAddress = true,
IPv6Enabled = IPv6Mode.Disabled, // TODO: temporary
};
_writer = new NetDataWriter();
_processor = new NetPacketProcessor();
_processor.RegisterNestedType(SkirmishSlot.Serialize, SkirmishSlot.Deserialize);
IsHosting = isHosting;
SkirmishGame = new SkirmishGame(isHost: IsHosting);
}
