public NetClientHelper()
{
NetPeerConfiguration config = new NetPeerConfiguration("CozyKxlol");
config.EnableMessageType(NetIncomingMessageType.DiscoveryResponse);
client = new NetClient(config);
client.Start();
}
static void Main(string[] args)
{
SynchronizationContext.SetSynchronizationContext(new SynchronizationContext());
Console.WriteLine("This is the client.");
Players = new List<Player>();
Config = new NetPeerConfiguration("MyGame");
Console.WriteLine("Created client configuration");
Client = new NetClient(Config);
Console.WriteLine("Initialized client socket");
Client.RegisterReceivedCallback(new SendOrPostCallback(ReceiveData));
Client.Start();
Console.WriteLine("Started client.");
Client.Connect("localhost", 7777);
Console.WriteLine("Requesting connection to server");
new Thread(new ThreadStart(delegate
{
string input;
while ((input = Console.ReadLine()) != null)
{
Console.WriteLine("New input.");
string[] prms = input.Split(' ');
switch (prms[0])
{
case "/changename":
break;
}
}
})).Start();
}
public CozyClient(string ClientName)
{
NetPeerConfiguration config = new NetPeerConfiguration(ClientName);
config.EnableMessageType(NetIncomingMessageType.DiscoveryResponse);
InnerClient = new NetClient(config);
InnerClient.RegisterReceivedCallback(RecivePacket);
}
/// <summary>
/// Server constructor, starts the server and connects to all region servers.
/// </summary>
/// <remarks>
/// TODO: Make the config file be able to be in a different location. Load from command line.
/// </remarks>
public MasterServer()
{
//Load this region server's junk from xml
XmlSerializer deserializer = new XmlSerializer(typeof(MasterConfig));
MasterConfig masterconfig = (MasterConfig)deserializer.Deserialize(XmlReader.Create(@"C:\Users\Addie\Programming\Mobius\Mobius.Server.MasterServer\bin\Release\MasterData.xml"));
//Start it with the name MobiusMasterServer, and let connection approvals be enabled
var config = new NetPeerConfiguration(masterconfig.ServerName);
config.Port = masterconfig.ServerPort;
config.MaximumConnections = masterconfig.MaxConnections;
config.EnableMessageType(NetIncomingMessageType.ConnectionApproval);
LidgrenServer = new NetServer(config);
RegionServers = new Dictionary<ushort, NetClient>();
foreach(RegionInfo info in masterconfig.RegionServers)
{
NetClient region = new NetClient(new NetPeerConfiguration(info.ServerName));
region.Start();
region.Connect(info.ServerIp, info.ServerPort);
RegionServers.Add(info.RegionId, region);
}
//Initialize our data structures
Users = new Dictionary<Guid, User>();
UserIdToCharacters = new Dictionary<Guid, List<Character>>();
//Start the server
LidgrenServer.Start();
}
public Client()
{
NetPeerConfiguration config = new NetPeerConfiguration("CozyAnywhere");
config.EnableMessageType(NetIncomingMessageType.DiscoveryResponse);
client = new NetClient(config);
client.RegisterReceivedCallback(RecivePacket);
}
/// <summary>
/// MPCLient constructor with MPThreadStopCondition as a parameter.
/// </summary>
/// <param name="condition">The condition to stop the ProcessMessageThread.</param>
public MPClient(MPSharedCondition condition)
{
StopMessageProcessingThread = condition ?? new MPSharedCondition(false);
ResetConfig();
netClient = new NetClient(config);
pts = new ParameterizedThreadStart(this.ProcessMessage);
}
public static void Main(string[] args)
{
Console.WriteLine("[CLIENT] Testing Lidgren-Network-v3...");
NetPeerConfiguration clientConfig = new NetPeerConfiguration("test");
clientConfig.EnableMessageType(NetIncomingMessageType.DiscoveryResponse);
NetClient client = new NetClient(clientConfig);
client.Start();
SynchronizationContext.SetSynchronizationContext(new SynchronizationContext());
client.RegisterReceivedCallback(new SendOrPostCallback(GotMessage));
Console.WriteLine("IP to connect to: ");
String ip = Console.ReadLine();
client.Connect(new System.Net.IPEndPoint(System.Net.IPAddress.Parse(ip), 12345));
while(true) {
string msg = Console.ReadLine();
NetOutgoingMessage sendMsg = client.CreateMessage();
sendMsg.Write("[CLIENT] " + msg);
client.SendMessage(sendMsg, NetDeliveryMethod.ReliableOrdered);
}
}
public NetworkMultiplayer(bool createServer = false)
: base(GameModes.Network)
{
if(createServer)
GameServer = new GameServer();
//read network on each update
Game.Instance.OnUpdate += ReadNetwork;
//server config
NetPeerConfiguration config = new NetPeerConfiguration("tank");
config.EnableMessageType(NetIncomingMessageType.DiscoveryResponse);
//server creation
Client = new NetClient(config);
Client.Start();
if (!createServer)
{
//check whether the user has a known server
ListMenu serverMenu = new ListMenu("Do you want to connect to a given IP (if yes, enter in console)?", "tank.Code.YESORNOCHOOSENOW", ConnectionMethodSelectionCallback);
Scene.Add(serverMenu);
}
else//we know that a local server must exist
Client.DiscoverLocalPeers(14242);
//register handler for receiving data
OnClientData += IncomingHandler;
//are we client, or are we dancer?
if(!createServer)
Console.WriteLine("client");
}
public Boolean Connect()
{
var result = true;
if (nethandler == null || netaddress == null || netport == 0)
{
result = false;
}
else
{
if (netconn == null)
{
netconfig = new NetPeerConfiguration("AuthServer");
netconn = new Lidgren.Network.NetClient(netconfig);
netconn.RegisterReceivedCallback(new SendOrPostCallback(nethandler), new SynchronizationContext());
}
try {
netconn.Start();
var hail = netconn.CreateMessage("Coming in hot!");
var conn = netconn.Connect(netaddress, netport, hail);
result = true;
} catch {
result = false;
}
}
return(result);
}
public Client(RenderWindow window, ImageManager imageManager)
: base(window, imageManager)
{
this.window = window;
world = new RenderImage(800, 600);
inputManager = new InputManager(this);
ticker = new Ticker();
window.ShowMouseCursor (false);
window.SetFramerateLimit (60);
NetPeerConfiguration netConfiguration = new NetPeerConfiguration("2dThing");
client = new NetClient(netConfiguration);
uMsgBuffer = new UserMessageBuffer();
otherClients = new Dictionary<int, NetworkClient>();
chat = new Chat(this);
LoadRessources();
blockTypeDisplay = new Cube(blockType, imageManager);
blockTypeDisplay.Position = new Vector2f(window.Width - 2*Cube.WIDTH, window.Height - 2* Cube.HEIGHT);
layerDisplay = new LayerDisplay(imageManager);
layerDisplay.Position = blockTypeDisplay.Position - new Vector2f(0, 50);
mouse = new Sprite (imageManager.GetImage("mouse"));
}
private NetworkManager()
{
NetPeerConfiguration config = new NetPeerConfiguration("SpireServer");
config.EnableMessageType(NetIncomingMessageType.DiscoveryResponse);
config.NetworkThreadName = "Spire Client";
client = new NetClient(config);
}
public void SetUpConnection()
{
configuration = new NetPeerConfiguration("PingPong");
configuration.EnableMessageType(NetIncomingMessageType.WarningMessage);
configuration.EnableMessageType(NetIncomingMessageType.VerboseDebugMessage);
configuration.EnableMessageType(NetIncomingMessageType.ErrorMessage);
configuration.EnableMessageType(NetIncomingMessageType.Error);
configuration.EnableMessageType(NetIncomingMessageType.DebugMessage);
configuration.EnableMessageType(NetIncomingMessageType.ConnectionApproval);
configuration.EnableMessageType(NetIncomingMessageType.Data);
switch (networkRole)
{
case GamerNetworkType.Client:
Client = new NetClient(configuration);
Client.Start();
Client.Connect(new IPEndPoint(NetUtility.Resolve(IP), Convert.ToInt32(Port)));
break;
case GamerNetworkType.Server:
configuration.Port = Convert.ToInt32(Port);
Server = new NetServer(configuration);
Server.Start();
break;
default:
throw new ArgumentException("Network type was not set");
}
}
private void SetupClient()
{
NetPeerConfiguration config = new NetPeerConfiguration("dystopia");
Client = new NetClient(config);
Client.Start();
Client.Connect(NetUtility.Resolve(ServerIP, ServerPort));
}
private void Client_Load(object sender, EventArgs e)
{
NetPeerConfiguration config = new NetPeerConfiguration("Testing");
config.EnableMessageType(NetIncomingMessageType.DiscoveryResponse);
client = new NetClient(config);
}
private static NetClient ConnectServer()
{
var config = new NetPeerConfiguration("pic") {EnableUPnP = true};
var thisClient = new NetClient(config);
thisClient.RegisterReceivedCallback(HandleMessage);
return thisClient;
}
public void InitClients(int netClientcount)
{
m_NetClientCount = netClientcount;
Nets = new NetClient[m_NetClientCount];
TextNetMsgS = new string[m_NetClientCount];
m_lastSent = new double[m_NetClientCount];
TextNetMsgSB = new StringBuilder();
System.Net.IPAddress mask = null;
System.Net.IPAddress local = NetUtility.GetMyAddress(out mask);
//
for (int i = 0; i < Nets.Length; i++) {
NetPeerConfiguration config = new NetPeerConfiguration("many");
config.LocalAddress = local;
#if DEBUG
config.SimulatedLoss = 0.02f;
#endif
NetClient Net = new NetClient(config);
Nets[i] = Net;
Net.Start();
//Net.Connect("localhost", 14242);
Net.Connect(new System.Net.IPEndPoint(config.LocalAddress, 14242));
//
Application.DoEvents();
}
}
/// <summary>
///
/// </summary>
/// <param name="numPorts"></param>
/// <param name="timeout"></param>
void StartDiscoveryInternal ( int numPorts, TimeSpan timeout )
{
lock (lockObj) {
if (client!=null) {
Log.Warning("Discovery is already started.");
return;
}
this.timeout = timeout;
var netConfig = new NetPeerConfiguration( Game.GameID );
netConfig.EnableMessageType( NetIncomingMessageType.DiscoveryRequest );
netConfig.EnableMessageType( NetIncomingMessageType.DiscoveryResponse );
client = new NetClient( netConfig );
client.Start();
var svPort = Game.Network.Port;
var ports = Enumerable.Range(svPort, numPorts)
.Where( p => p <= ushort.MaxValue )
.ToArray();
Log.Message("Start discovery on ports: {0}", string.Join(", ", ports) );
foreach (var port in ports) {
client.DiscoverLocalPeers( port );
}
}
}
/// <summary>
/// Joining an existing lobby
/// </summary>
/// <param name="client">Existing client (created in JoinScreen)</param>
public LobbyScreen(NetClient client)
: base("Lobby")
{
host = false;
_characterMenuEntry = new MenuEntry(string.Empty);
SetMenuEntryText();
var playTest = new MenuEntry("Play");
var back = new MenuEntry("Back");
_firstPlayer = new MenuEntry("First Player: Not Connected");
_secondPlayer = new MenuEntry("Second Player: Not Connected");
_thirdPlayer = new MenuEntry("Third Player: Not Connected");
_fourthPlayer = new MenuEntry("Fourth Player: Not Connected");
_characterMenuEntry.Selected += _characterMenuEntry_Selected;
Global.GameInProgress.Exiting += GameInProgress_Exiting;
back.Selected += back_Selected;
playTest.Selected += playTest_Selected;
MenuEntries.Add(_characterMenuEntry);
MenuEntries.Add(_firstPlayer);
MenuEntries.Add(_secondPlayer);
MenuEntries.Add(_thirdPlayer);
MenuEntries.Add(_fourthPlayer);
MenuEntries.Add(playTest);
MenuEntries.Add(back);
_menuEntryArray = new[] { _firstPlayer, _secondPlayer, _thirdPlayer, _fourthPlayer };
Client = client;
}
public void StartClientConnection(string ip, string port)
{
_config = new NetPeerConfiguration(GameConfiguration.NetworkAppIdentifier)
{
#if DEBUG
//PingInterval = 1f, // send ping every 1 second
//SimulatedLoss = 0.5f, // from 0 to 1
SimulatedMinimumLatency = GameConfiguration.SimulatedMinimumLatency,
#endif
};
_config.EnableMessageType(NetIncomingMessageType.ConnectionLatencyUpdated);
_hasStarted = true;
_connected = false;
_disconnected = false;
// Client initialize
_client = new NetClient(_config);
_client.Start();
_messagePool = new Queue<NetIncomingMessage>();
var threadStart = new ThreadStart(MessagePooling);
_messagePooling = new Thread(threadStart);
_messagePooling.Start();
TryToConnect(ip, port);
}
public Client_Model2()
{
_netconfig = new NetPeerConfiguration("SkyNet");
_client = new NetClient(_netconfig);
_assembly = new SuperAssembly("Client");
_listen=new Thread(Listen);
}
public static void StatusChangeHandler(NetClient client, NetBuffer buffer)
{
string status_msg = buffer.ReadString();
NetConnectionStatus status = (NetConnectionStatus)buffer.ReadByte();
if (status == NetConnectionStatus.Connected)
{
Console.WriteLine("Client: Connected");
Console.Write("Client: Starting IOS");
int i;
for (i = 0; i < 10; i++)
{
Console.Write(".");
Thread.Sleep(500);
}
Console.WriteLine("");
//Show the IOS Master form
System.Windows.Forms.Application.EnableVisualStyles();
System.Windows.Forms.Application.SetCompatibleTextRenderingDefault(false);
System.Windows.Forms.Application.Run(new MasterForm());
}
if (status == NetConnectionStatus.Disconnected)
{
Console.WriteLine("Client: Disconnected - " + status_msg);
}
}
public static void Main(string[] args)
{
Console.WriteLine("[CLIENT] Testing Lidgren-Network-v3...");
NetPeerConfiguration clientConfig = new NetPeerConfiguration("test");
clientConfig.EnableMessageType(NetIncomingMessageType.DiscoveryResponse);
NetClient client = new NetClient(clientConfig);
client.Start();
Console.WriteLine("IP to connect to: ");
String ip = Console.ReadLine();
client.Connect("192.168.1.2", 80);
while (true)
{
if (client.ServerConnection != null)
{
string msg = Console.ReadLine();
NetOutgoingMessage sendMsg = client.CreateMessage();
sendMsg.Write(msg);
client.SendMessage(sendMsg, NetDeliveryMethod.ReliableOrdered);
}
}
}
public SpaceClient()
{
config = Constants.GetConfig();
client = new NetClient(config);
ClientStarted = false;
}
public NetworkClient(string Host, int Port)
{
Config = new NetPeerConfiguration("GameServer01");
ClientConnection = new NetClient(Config);
ClientConnection.Start();
ClientConnection.Connect(Host, Port);
}
public static void Connect(IPEndPoint endpoint, MMDevice device, ICodec codec)
{
var config = new NetPeerConfiguration("airgap");
_client = new NetClient(config);
_client.RegisterReceivedCallback(MessageReceived);
_client.Start();
_waveIn = new WasapiLoopbackCapture(device);
_codec = codec;
_sourceFormat = _waveIn.WaveFormat;
_targetFormat = new WaveFormat(_codec.SampleRate, _codec.Channels); // format to convert to
_waveIn.DataAvailable += SendData;
_waveIn.RecordingStopped += (sender, args) => Console.WriteLine("Stopped");
// TODO: RecordingStopped is called when you change the audio device settings, should recover from that
NetOutgoingMessage formatMsg = _client.CreateMessage();
formatMsg.Write(_targetFormat.Channels);
formatMsg.Write(_targetFormat.SampleRate);
formatMsg.Write(codec.Name);
_client.Connect(endpoint, formatMsg);
}
public void fireDataRecieved(NetClient client, NetBuffer buffer)
{
if (DataRecieved != null)
{
DataRecieved(client, buffer);
}
}
public void Connect()
{
client = new NetClient(config);
client.Start();
client.DiscoverLocalPeers(14242);
}
public void fireConnectionRejected(NetClient client, NetBuffer buffer)
{
if (ConnectionRejected != null)
{
ConnectionRejected(client, buffer);
}
}
public WorldClientBase(string protocolVersion)
{
this.protocolVersion = protocolVersion;
// Net configuration
NetPeerConfiguration cfg = new NetPeerConfiguration("Asteria");
cfg.MaximumConnections = 1;
cfg.ReceiveBufferSize = 4095;
cfg.MaximumTransmissionUnit = 4095;
#if DEBUG
try
{
cfg.EnableMessageType(NetIncomingMessageType.VerboseDebugMessage);
}
catch
{
Logger.Output(this, "Running in debug mode but using release Lidgren library version, Lidgren debug messages disabled!");
}
#endif
client = new NetClient(cfg);
client.Start();
// Create objects needed.
sendingQ = new Queue<ClientToServerMessage>(64);
receivingQ = new Queue<NetIncomingMessage>(128);
newDataArrivedEvent = new AutoResetEvent(false);
messages = new Dictionary<MessageType, List<ServerToClientMessage>>();
serializer = new ClientToServerMessageSerializer();
deserializer = new ServerToClientMessageSerializer();
isRunning = true;
}
public void SendUpdates(NetClient client)
{
NetOutgoingMessage om = client.CreateMessage();
om.Write(Helpers.TransferType.ProjectileUpdate);
om.Write(new ProjectileTransferableData(client.UniqueIdentifier,ID,IsValid,Position,Angle));
client.SendMessage(om, NetDeliveryMethod.UnreliableSequenced);
}
static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
s_mainForm = new Form1();
NetConfiguration config = new NetConfiguration("stress");
config.ThrottleBytesPerSecond = 3500;
s_client = new NetClient(config);
// 100 ms simulated roundtrip latency
s_client.SimulatedMinimumLatency = 0.1f;
// ... + 0 to 50 ms
s_client.SimulatedLatencyVariance = 0.05f;
// 10% loss (!)
// s_client.SimulatedLoss = 0.1f;
// 5% duplicated messages (!)
// s_client.SimulatedDuplicates = 0.05f;
s_readBuffer = s_client.CreateBuffer();
s_sentUntil = NetTime.Now;
s_nextDisplay = NetTime.Now;
Application.Idle += new EventHandler(OnAppIdle);
Application.Run(s_mainForm);
s_client.Shutdown("Application exiting");
}
public long Connect(string host, ushort port)
{
var netClient = new Lidgren.Network.NetClient(_peerConfig);
netClient.Start();
_clients.Add(netClient.UniqueIdentifier, netClient);
var conn = netClient.Connect(host, port);
return(netClient.UniqueIdentifier);
}
/// <summary>
/// Queries the current network for all servers running on their default ports, waiting
/// 1 second to aggregate responses.
/// </summary>
/// <returns></returns>
public static Task <DiscoveryResponse[]> DoDiscoveryAsync()
{
return(Task.Run(async() =>
{
var responses = new List <DiscoveryResponse>();
var client = new Lidgren.Network.NetClient(new NetPeerConfiguration("MPTANKS"));
client.Configuration.EnableMessageType(NetIncomingMessageType.DiscoveryRequest);
client.Configuration.EnableMessageType(NetIncomingMessageType.DiscoveryResponse);
client.DiscoverLocalPeers(33132); //DEFAULT PORT
await Task.Delay(1000); // 5 second timeout
NetIncomingMessage msg;
while ((msg = client.ReadMessage()) != null)
{
if (msg.MessageType == NetIncomingMessageType.DiscoveryResponse)
{
try { responses.Add(Read(msg)); } catch { }
}
}
responses.Add(new DiscoveryResponse
{
Address = "HELP",
Port = 555,
AllowsHotJoin = false,
GamemodeDescription = "BEEP",
GamemodeName = "JEEP",
HasPassword = false,
MapName = "MEEP",
MaxPlayers = 44,
Mods = new Modding.ModInfo[]
{
new Modding.ModInfo()
{
ModName = "COREASSETS"
}
},
PlayerCount = 5,
ServerName = "RIP"
});
return responses.ToArray();
}));
}
private void HandleEvent(Lidgren.Network.NetClient netClient)
{
NetIncomingMessage netMessage;
while ((netMessage = netClient.ReadMessage()) != null)
{
switch (netMessage.MessageType)
{
case NetIncomingMessageType.Data:
var receivedData = netMessage.ReadBytes(netMessage.LengthBytes);
OnNetworkReceive(netClient.UniqueIdentifier, receivedData);
break;
case NetIncomingMessageType.StatusChanged:
NetConnectionStatus status = (NetConnectionStatus)netMessage.ReadByte();
if (status == NetConnectionStatus.Connected)
{
//Log.Debug(this, $"Connected {netMessage.SenderConnection.Peer.UniqueIdentifier}");
OnPeerConnected(netClient.UniqueIdentifier);
}
else if (status == NetConnectionStatus.Disconnected)
{
//Log.Debug(this, $"Disconnected {netMessage.SenderConnection.Peer.UniqueIdentifier}");
OnPeerDisconnected(netClient.UniqueIdentifier);
}
break;
case NetIncomingMessageType.VerboseDebugMessage:
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.WarningMessage:
case NetIncomingMessageType.ErrorMessage:
//Log.Debug(this, netMessage.ReadString());
break;
default:
//Log.Debug(this, $"Unhandled message: {netMessage.MessageType}");
break;
}
}
}
/// <summary>
/// Requests the information from a server with a 10 second timeout. If a response is not
/// received, it returns null. Otherwise, it returns the information provided by the server.
/// </summary>
/// <param name="server"></param>
/// <param name="port"></param>
/// <returns></returns>
public static Task <DiscoveryResponse> RequestServerInfo(string server, ushort port)
{
return(Task.Run(() =>
{
var client = new Lidgren.Network.NetClient(new NetPeerConfiguration("MPTANKS"));
client.Configuration.EnableMessageType(NetIncomingMessageType.DiscoveryRequest);
client.Configuration.EnableMessageType(NetIncomingMessageType.DiscoveryResponse);
client.DiscoverKnownPeer(server, port);
var msg = client.WaitMessage(10000);
if (msg == null)
{
return null;
}
if (msg.MessageType == NetIncomingMessageType.DiscoveryResponse)
{
try { return Read(msg); } catch { }
}
return null;
}));
}
public void Reset()
{
netconn = null;
}
