static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
MainForm = new Form1();
NetPeerConfiguration config = new NetPeerConfiguration("durable");
config.Port = 14242;
config.EnableMessageType(NetIncomingMessageType.ConnectionApproval);
config.EnableMessageType(NetIncomingMessageType.DiscoveryRequest);
config.EnableUPnP = true;
Server = new NetServer(config);
Server.Start();
// attempt upnp port forwarding
Server.UPnP.ForwardPort(14242, "Durable sample test");
m_expectedReliableOrdered = new uint[3];
m_reliableOrderedCorrect = new int[3];
m_reliableOrderedErrors = new int[3];
m_expectedSequenced = new uint[3];
m_sequencedCorrect = new int[3];
m_sequencedErrors = new int[3];
Application.Idle += new EventHandler(AppLoop);
Application.Run(MainForm);
Server.Shutdown("App exiting");
}
public void Close()
{
if (netconn == null)
{
return;
}
netconn.Shutdown("Halting Server.");
}
static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
s_form = new Form1();
NetPeerConfiguration config = new NetPeerConfiguration("filestream");
config.Port = 14242;
s_server = new NetServer(config);
Application.Idle += new EventHandler(AppLoop);
Application.Run(s_form);
s_server.Shutdown("Application exiting");
}
static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
s_mainForm = new Form1();
NetConfiguration config = new NetConfiguration("OoBSample");
config.MaxConnections = 0; // we accept only OoB data
config.Port = 14242;
s_server = new NetServer(config);
s_server.SetMessageTypeEnabled(NetMessageType.OutOfBandData, true);
s_server.Start();
s_readBuffer = s_server.CreateBuffer();
Application.Idle += new EventHandler(OnAppIdle);
Application.Run(s_mainForm);
s_server.Shutdown("Bye");
}
static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
s_mainForm = new Form1();
NetConfiguration config = new NetConfiguration("stress");
config.Port = 14242;
config.MaxConnections = 32;
s_server = new NetServer(config);
s_server.SimulatedMinimumLatency = 0.1f;
s_server.SimulatedLatencyVariance = 0.05f;
// s_server.SimulatedLoss = 0.1f;
// s_server.SimulatedDuplicates = 0.05f;
s_readBuffer = s_server.CreateBuffer();
Application.Idle += new EventHandler(OnAppIdle);
Application.Run(s_mainForm);
s_server.Shutdown("Application exiting");
}
static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
s_mainForm = new Form1();
NetConfiguration config = new NetConfiguration("largepacket");
config.Port = 14242;
config.MaxConnections = 16;
s_server = new NetServer(config);
s_server.SimulatedLoss = 0.03f; // 3 %
s_server.SimulatedMinimumLatency = 0.1f; // 100 ms
s_server.SimulatedLatencyVariance = 0.05f; // 100-150 ms actually
//m_server.SetMessageTypeEnabled(NetMessageType.VerboseDebugMessage, true);
s_server.Start();
s_readBuffer = s_server.CreateBuffer();
Application.Idle += new EventHandler(OnAppIdle);
Application.Run(s_mainForm);
s_server.Shutdown("Application exiting");
}
static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
s_mainForm = new Form1();
s_nextPixelToSend = new Dictionary<NetConnection, uint>();
NetConfiguration config = new NetConfiguration("imageservice");
config.Port = 14242;
config.MaxConnections = 64;
config.ThrottleBytesPerSecond = 25000;
s_server = new NetServer(config);
s_server.SimulatedMinimumLatency = 0.05f;
s_server.SimulatedLoss = m_loss;
s_fpsStart = NetTime.Now;
s_readBuffer = s_server.CreateBuffer();
Application.Idle += new EventHandler(OnAppIdle);
Application.Run(s_mainForm);
s_server.Shutdown("Application exit");
}
public void Run()
{
bool running = true;
Console.WriteLine("Backup Remote");
Console.Write("Master key: ");
string key = "";
ConsoleKeyInfo info;
do
{
info = Console.ReadKey(true);
if (info.Key != ConsoleKey.Backspace && info.Key != ConsoleKey.Enter)
{
key += info.KeyChar;
Console.Write("*");
}
else if (info.Key == ConsoleKey.Backspace && key.Length > 0)
{
key = key.Substring(0, key.Length - 1);
Console.Write("\b \b");
}
}
while (info.Key != ConsoleKey.Enter);
keyHash = GetHash(key);
key = string.Empty;
Console.WriteLine();
Console.Write("Backup directory: ");
backupDir = Console.ReadLine();
if (!Directory.Exists(backupDir))
{
Console.WriteLine("Directory doesn't exist");
return;
}
Console.WriteLine("Initializing...");
Command.Register("close", a => running = false);
Command.Register("manifest", a =>
{
if (a.Length == 0)
{
Console.WriteLine(targetManager.GetManifestJSON());
return;
}
if (a[0] == "save")
{
Console.WriteLine("Forced manifest save");
targetManager.SaveManifest();
}
});
targetManager = new TargetManager(backupDir);
NetPeerConfiguration cfg = new NetPeerConfiguration("BackupUtil");
cfg.Port = 6969;
cfg.EnableMessageType(NetIncomingMessageType.ConnectionApproval);
cfg.EnableMessageType(NetIncomingMessageType.DiscoveryRequest);
SynchronizationContext sync = new SynchronizationContext();
SynchronizationContext.SetSynchronizationContext(sync);
server = new NetServer(cfg);
server.RegisterReceivedCallback(new SendOrPostCallback(MessageReceived), sync);
server.Start();
Console.WriteLine("Initialized");
string line;
while (running)
{
line = Console.ReadLine();
string[] lineArgs = line.Split(' ');
if (!Command.Run(lineArgs[0], lineArgs.Skip(1).ToArray()))
Console.WriteLine("Invalid command");
}
Console.WriteLine("Closing...");
server.Shutdown("bye"); // TODO: figure out why client doesn't receive the message that the server is shut down
}
private static void StartServer()
{
// create a configuration for the server
NetConfiguration config = new NetConfiguration("EES");
config.MaxConnections = 128;
config.Port = 14242;
// create server and start listening for connections
NetServer server = new NetServer(config);
server.SetMessageTypeEnabled(NetMessageType.DebugMessage, false);
server.SetMessageTypeEnabled(NetMessageType.ConnectionApproval, true);
server.Start();
// create a buffer to read data into
NetBuffer buffer = server.CreateBuffer();
// keep running until the user presses a key
Console.WriteLine("Press ESC to quit server");
bool keepRunning = true;
while (keepRunning)
{
NetMessageType type;
NetConnection sender;
// check if any messages has been received
while (server.ReadMessage(buffer, out type, out sender))
{
switch (type)
{
case NetMessageType.DebugMessage:
netevent.fireDebugMessage(buffer.ReadString());
break;
case NetMessageType.ConnectionApproval:
netevent.fireClientApproval(server, buffer, sender);
break;
case NetMessageType.StatusChanged:
netevent.fireStatusChanged(server, buffer, sender);
break;
case NetMessageType.Data:
netevent.fireDataRecieved(server, buffer, sender);
break;
}
}
// User pressed ESC?
while (Console.KeyAvailable)
{
ConsoleKeyInfo info = Console.ReadKey();
if (info.Key == ConsoleKey.Escape)
{
keepRunning = false;
}
else if (info.Key == ConsoleKey.I)
{
//Create line
Console.WriteLine("");
//Get config
Config server_config = Config.Instance;
foreach (DictionaryEntry entry in server_config.Server.client_connections)
{
Console.WriteLine("Client: '" + entry.Value + "' from: " + entry.Key);
}
}
}
Thread.Sleep(1);
}
server.Shutdown("Server exiting");
}
public static void Start()
{
NetPeerConfiguration config = new NetPeerConfiguration("xnaapp");
config.EnableMessageType(NetIncomingMessageType.DiscoveryRequest);
config.Port = 14242;
// create and start server
NetServer server = new NetServer(config);
server.Start();
// schedule initial sending of position updates
double nextSendUpdates = NetTime.Now;
// run until escape is pressed
//while (!Console.KeyAvailable || Console.ReadKey().Key != ConsoleKey.Escape)
while(true)
{
NetIncomingMessage msg;
while ((msg = server.ReadMessage()) != null)
{
switch (msg.MessageType)
{
case NetIncomingMessageType.DiscoveryRequest:
//
// Server received a discovery request from a client; send a discovery response (with no extra data attached)
//
server.SendDiscoveryResponse(null, msg.SenderEndpoint);
break;
case NetIncomingMessageType.VerboseDebugMessage:
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.WarningMessage:
case NetIncomingMessageType.ErrorMessage:
//
// Just print diagnostic messages to console
//
Console.WriteLine(msg.ReadString());
break;
case NetIncomingMessageType.StatusChanged:
NetConnectionStatus status = (NetConnectionStatus)msg.ReadByte();
if (status == NetConnectionStatus.Connected)
{
//
// A new player just connected!
//
Console.WriteLine(NetUtility.ToHexString(msg.SenderConnection.RemoteUniqueIdentifier) + " connected!");
// randomize his position and store in connection tag
msg.SenderConnection.Tag = new int[] {
NetRandom.Instance.Next(10, 100),
NetRandom.Instance.Next(10, 100)
};
}
break;
case NetIncomingMessageType.Data:
//
// The client sent input to the server
//
int xinput = msg.ReadInt32();
int yinput = msg.ReadInt32();
int[] pos = msg.SenderConnection.Tag as int[];
// fancy movement logic goes here; we just append input to position
pos[0] += xinput;
pos[1] += yinput;
break;
}
//
// send position updates 30 times per second
//
double now = NetTime.Now;
if (now > nextSendUpdates)
{
// Yes, it's time to send position updates
// for each player...
foreach (NetConnection player in server.Connections)
{
// ... send information about every other player (actually including self)
foreach (NetConnection otherPlayer in server.Connections)
{
// send position update about 'otherPlayer' to 'player'
NetOutgoingMessage om = server.CreateMessage();
// write who this position is for
om.Write(otherPlayer.RemoteUniqueIdentifier);
if (otherPlayer.Tag == null)
otherPlayer.Tag = new int[2];
int[] pos = otherPlayer.Tag as int[];
om.Write(pos[0]);
om.Write(pos[1]);
// send message
server.SendMessage(om, player, NetDeliveryMethod.Unreliable);
}
}
// schedule next update
nextSendUpdates += (1.0 / 30.0);
}
}
// sleep to allow other processes to run smoothly
Thread.Sleep(1);
}
server.Shutdown("app exiting");
}
/// <summary>
///
/// </summary>
/// <param name="map"></param>
void ServerTaskFunc ( string map, string postCommand )
{
var netConfig = new NetPeerConfiguration(Game.GameID);
netConfig.Port = Game.Network.Port;
netConfig.MaximumConnections = 32;
netConfig.UnreliableSizeBehaviour = NetUnreliableSizeBehaviour.NormalFragmentation;
if (Debugger.IsAttached) {
netConfig.ConnectionTimeout = float.MaxValue;
Log.Message("SV: Debugger is attached: ConnectionTimeout = {0} sec", netConfig.ConnectionTimeout);
}
netConfig.EnableMessageType( NetIncomingMessageType.ConnectionApproval );
netConfig.EnableMessageType( NetIncomingMessageType.DiscoveryRequest );
netConfig.EnableMessageType( NetIncomingMessageType.DiscoveryResponse );
netConfig.EnableMessageType( NetIncomingMessageType.ConnectionLatencyUpdated );
var server = new NetServer( netConfig );
notifications = new Queue<string>();
Log.Message("SV: Start: {0} {1}", map, postCommand);
var snapshotQueue = new SnapshotQueue(32);
var serverFrames = 0L;
//var accumulatedElapsedTime = TimeSpan.FromTicks(0);
//var maxElapsedTime = TimeSpan.FromMilliseconds(1000);
//var previousTicks = (long)0;
//
// configure & start server :
//
try {
server.Start();
//
// start game specific stuff :
//
atoms = new AtomCollection();
LoadContent( map );
atoms.Lock();
//
// invoke post-start command :
//
if (postCommand!=null) {
Game.Invoker.Push( postCommand );
}
// Timer and fixed timestep stuff :
// http://gafferongames.com/game-physics/fix-your-timestep/
var accumulator = TimeSpan.Zero;
var stopwatch = new Stopwatch();
stopwatch.Start();
var currentTime = stopwatch.Elapsed;
var time = stopwatch.Elapsed;
//
// server loop :
//
while ( !killToken.IsCancellationRequested ) {
_retryTick:
var targetDelta = TimeSpan.FromTicks( (long)(10000000 / TargetFrameRate) );
var newTime = stopwatch.Elapsed;
var frameTime = newTime - currentTime;
currentTime = newTime;
accumulator += frameTime;
if ( accumulator < targetDelta ) {
Thread.Sleep(1);
goto _retryTick;
}
while ( accumulator > targetDelta ) {
//var svTime = new GameTime( time, targetDelta );
var svTime = new GameTime( serverFrames, time, targetDelta );
serverFrames++;
//
// Do actual server stuff :
//
UpdateNetworkAndLogic( svTime, server, snapshotQueue );
accumulator -= targetDelta;
time += targetDelta;
}
}
foreach ( var conn in server.Connections ) {
conn.Disconnect("Server disconnected");
}
} catch ( Exception e ) {
Log.PrintException( e, "Server error: {0}", e.Message );
foreach ( var conn in server.Connections ) {
conn.Disconnect(string.Format("Server error: {0}", e.Message));
}
} finally {
//
// kill game specific stuff :
// try...catch???
//
UnloadContent();
//
// shutdown connection :
//
server.Shutdown("Server shutdown");
Log.Message("SV: Shutdown");
notifications = null;
killToken = null;
serverTask = null;
server = null;
pings = null;
}
}
static void Main(string[] args)
{
Console.WriteLine("Akanonda Server");
Console.WriteLine("---------------");
// NetServer START
NetPeerConfiguration netconfig = new NetPeerConfiguration("game");
netconfig.MaximumConnections = settings.MaxConnections;
netconfig.Port = settings.GamePort;
netserver = new NetServer(netconfig);
NetPeerConfiguration config = new NetPeerConfiguration("chat");
config.MaximumConnections = 100;
config.Port = settings.ChatPort;
chatServer = new NetServer(config);
SurvivalTimer = new System.Timers.Timer();
SurvivalTimer.Interval = 1000;
SurvivalTimer.Elapsed += new ElapsedEventHandler(gameSecondTick);
SurvivalTimer.Start();
if (SynchronizationContext.Current == null)
SynchronizationContext.SetSynchronizationContext(new SynchronizationContext());
netserver.RegisterReceivedCallback(new SendOrPostCallback(ReceiveData));
netserver.Start();
StartChat();
game = Game.Instance;
gameSpeedTimer = new System.Timers.Timer(settings.GameSpeed);
gameSpeedTimer.Elapsed += new ElapsedEventHandler(gameSpeedTimer_Elapsed);
gameSpeedTimer.Enabled = true;
Console.Write("Command: ");
while (true)
{
string input = Console.ReadLine();
switch (input)
{
case "start":
break;
case "status":
Console.WriteLine(netserver.ConnectionsCount);
break;
case "exit":
netserver.Shutdown("Exit");
Environment.Exit(0);
break;
case "stop Chat":
StopChat();
Console.WriteLine("Chat stopped");
break;
case "start Chat":
StartChat();
Console.WriteLine("Chat started");
break;
case "kick Player":
Console.WriteLine("Enter Player name:");
string playerToKick = Console.ReadLine();
Player playerToFind = game.PLayerList.Find(item => item.name == playerToKick);
if (playerToFind != null)
{
game.addDeadRemoveLivingPlayer(playerToFind.guid);
}
break;
default:
Console.WriteLine("Command not found.");
break;
}
Console.Write("Command: ");
}
}
static void Main(string[] args)
{
NetPeerConfiguration config = new NetPeerConfiguration("projectorigin");
config.EnableMessageType(NetIncomingMessageType.DiscoveryRequest);
config.Port = 14242;
// Create and start server
NetServer server = new NetServer(config);
server.Start();
Console.WriteLine("Game Server starts");
//Schedule initial sending of position updates
double nextSendUpdates = NetTime.Now;
GameStatus gameStatus = GameStatus.Initial;
int clientDoneCounter = 0;
//Generate a map and wait client to connect
//InternalMap map = GenerateMap();
int mapSeed = 1000;
Random rand = new Random();
mapSeed = rand.Next();
//Run until escape is pressed
while (!Console.KeyAvailable || Console.ReadKey().Key != ConsoleKey.Escape)
{
NetIncomingMessage msg;
while ((msg = server.ReadMessage()) != null)
{
switch (msg.MessageType)
{
case NetIncomingMessageType.DiscoveryRequest:
//
// Server received a discovery request from a client; send a discovery response (with no extra data attached)
//
NetOutgoingMessage com = server.CreateMessage();
//byte[] mapData = Serializer<InternalMap>.SerializeObject(map);
switch (server.ConnectionsCount)
{
case 0:
com.Write((int)PlayerId.Green);
com.Write((int)mapSeed); //Write map seed
break;
case 1:
com.Write((int)PlayerId.Red);
com.Write((int)mapSeed); //Write map seed
gameStatus = GameStatus.Receive;
break;
}
server.SendDiscoveryResponse(com, msg.SenderEndpoint);
Console.WriteLine("Connect to: " + msg.SenderEndpoint);
break;
case NetIncomingMessageType.Data:
if (gameStatus == GameStatus.Receive)
{
//
// The client sent input to the server
//
IncomingMessageType imt = (IncomingMessageType)msg.ReadByte();
if (imt == IncomingMessageType.DataPlayerInfo)
{
int wayPointCounter = msg.ReadInt32();
List<PlayerInfo> wayPoints = new List<PlayerInfo>();
for (int i = 1; i <= wayPointCounter; ++i)
{
Vector3 tempPos;
tempPos.X = msg.ReadFloat();
tempPos.Y = msg.ReadFloat();
tempPos.Z = msg.ReadFloat();
float tempOrientation;
tempOrientation = msg.ReadFloat();
PlayerInfo wayPoint = new PlayerInfo(tempPos, tempOrientation);
wayPoints.Add(wayPoint);
}
playerInfoDict[msg.SenderEndpoint] = wayPoints;
Console.WriteLine("Receive message from" + msg.SenderEndpoint);
clientDoneCounter++;
if (clientDoneCounter == 2)
gameStatus = GameStatus.Sending;
}
}
break;
}
//
// send position updates 30 times per second
//
if (gameStatus == GameStatus.Sending)
{
// Yes, it's time to send position updates
// for each player...
foreach (NetConnection player in server.Connections)
{
if (!playerInfoDict.ContainsKey(player.RemoteEndpoint))
playerInfoDict[player.RemoteEndpoint] = new List<PlayerInfo>();
}
foreach (NetConnection player in server.Connections)
{
//send information about every other player(not including self)
foreach (NetConnection otherPlayer in server.Connections)
{
if (player.RemoteEndpoint == otherPlayer.RemoteEndpoint)
continue;
// send position update about 'otherPlayer' to 'player'
NetOutgoingMessage om = server.CreateMessage();
om.Write((byte)OutgoingMessageType.DataOtherPlayerInfo);
om.Write(playerInfoDict[otherPlayer.RemoteEndpoint].Count);
foreach (PlayerInfo playerInfo in playerInfoDict[otherPlayer.RemoteEndpoint])
{
om.Write(playerInfo.position.X);
om.Write(playerInfo.position.Y);
om.Write(playerInfo.position.Z);
om.Write(playerInfo.orientation);
}
//send message
server.SendMessage(om, player, NetDeliveryMethod.ReliableOrdered);
}
}
gameStatus = GameStatus.Receive;
clientDoneCounter = 0;
}
}
}
server.Shutdown("server exiting");
}
public static void Main()
{
NetPeerConfiguration config = new NetPeerConfiguration("xnaapp");
config.EnableMessageType(NetIncomingMessageType.DiscoveryRequest);
config.Port = 14242;
// create and start server
NetServer server = new NetServer(config);
server.Start();
// schedule initial sending of position updates
double nextSendUpdates = NetTime.Now;
Dictionary<NetConnection, List<Damage>> damages = new Dictionary<NetConnection, List<Damage>>();
Dictionary<NetConnection, Position> positions = new Dictionary<NetConnection, Position>();
List<Npc> npcs = new List<Npc>();
npcs.Add(new Npc { X = 1700, Y = 1000, Speed = 4, Life = 3 });
// run until escape is pressed
int i = 0;
while (IsRunning)
{
NetIncomingMessage msg;
while ((msg = server.ReadMessage()) != null)
{
switch (msg.MessageType)
{
case NetIncomingMessageType.DiscoveryRequest:
//
// Server received a discovery request from a client; send a discovery response (with no extra data attached)
//
server.SendDiscoveryResponse(null, msg.SenderEndpoint);
break;
case NetIncomingMessageType.VerboseDebugMessage:
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.WarningMessage:
case NetIncomingMessageType.ErrorMessage:
//
// Just print diagnostic messages to console
//
//Console.WriteLine(msg.ReadString());
Debug.WriteLine(msg.ReadString());
break;
case NetIncomingMessageType.StatusChanged:
NetConnectionStatus status = (NetConnectionStatus)msg.ReadByte();
if (status == NetConnectionStatus.Connected)
{
//
// A new player just connected!
//
Console.WriteLine(NetUtility.ToHexString(msg.SenderConnection.RemoteUniqueIdentifier) + " connected!");
Debug.WriteLine(NetUtility.ToHexString(msg.SenderConnection.RemoteUniqueIdentifier) + " connected!");
msg.SenderConnection.Tag = new object[6];
}
break;
case NetIncomingMessageType.Data:
//
// The client sent input to the server
//
MessageRouts messageRout = (MessageRouts)msg.ReadByte();
switch (messageRout)
{
case MessageRouts.Position:
Position position = new Position();
position.X = msg.ReadInt32();
position.Y = msg.ReadInt32();
position.Angle = msg.ReadInt32();
position.IsShooting = msg.ReadBoolean();
position.IsHuman = msg.ReadBoolean();
positions[msg.SenderConnection] = position;
break;
case MessageRouts.Fire:
Damage damage = new Damage();
damage.PlayerId = msg.ReadInt64();
damage.WeaponId = msg.ReadByte();
damage.Angle = msg.ReadByte();
damage.X = msg.ReadInt32();
damage.Y = msg.ReadInt32();
if (damage.PlayerId > 50)
{
if (!damages.ContainsKey(msg.SenderConnection))
damages[msg.SenderConnection] = new List<Damage>();
damages[msg.SenderConnection].Add(damage);
}
else
{
npcs[(int)damage.PlayerId].Life -= 1;
if (npcs[(int)damage.PlayerId].Life <= 0)
npcs.RemoveAt((int)damage.PlayerId);
}
break;
}
break;
}
// send position updates 30 times per second
double now = NetTime.Now;
if (now > nextSendUpdates)
{
foreach (var position in positions.Values)
{
foreach (var npc in npcs)
{
float velX = position.X - npc.X;
float velY = position.Y - npc.Y;
float distance = (float)Math.Sqrt(Math.Pow(velX, 2) + Math.Pow(velY, 2));
if (distance < 300 && distance > 30)
{
velX /= distance;
velY /= distance;
npc.X += (int)(velX * npc.Speed);
npc.Y += (int)(velY * npc.Speed);
NetOutgoingMessage om2 = server.CreateMessage();
om2.Write((byte)MessageRouts.MoveNpc);
om2.Write((byte)npcs.IndexOf(npc));
om2.Write((int)npc.X);
om2.Write((int)npc.Y);
foreach (NetConnection player in server.Connections)
server.SendMessage(om2, player, NetDeliveryMethod.ReliableUnordered);
}
}
}
foreach (NetConnection player in server.Connections)
{
foreach (var damagePair in damages)
{
if (damagePair.Key != player)
{
foreach (var damage in damagePair.Value)
{
NetOutgoingMessage om2 = server.CreateMessage();
om2.Write((byte)MessageRouts.Fire);
om2.Write(damagePair.Key.RemoteUniqueIdentifier);
om2.Write(damage.PlayerId);
om2.Write(damage.WeaponId);
om2.Write(damage.Angle);
om2.Write(damage.X);
om2.Write(damage.Y);
server.SendMessage(om2, player, NetDeliveryMethod.ReliableUnordered);
}
}
}
foreach (NetConnection otherPlayer in server.Connections)
{
if (player != otherPlayer)
{
NetOutgoingMessage om = server.CreateMessage();
if (positions.ContainsKey(otherPlayer))
{
om.Write((byte)MessageRouts.Position);
om.Write(otherPlayer.RemoteUniqueIdentifier);
om.Write(positions[otherPlayer].X);
om.Write(positions[otherPlayer].Y);
om.Write(positions[otherPlayer].Angle);
om.Write(positions[otherPlayer].IsShooting);
om.Write(positions[otherPlayer].IsHuman);
server.SendMessage(om, player, NetDeliveryMethod.Unreliable);
}
// send message
}
}
}
foreach (var damageList in damages.Values)
damageList.Clear();
// schedule next update
nextSendUpdates += (1.0 / 30.0);
}
}
// sleep to allow other processes to run smoothly
Thread.Sleep(1);
}
server.Shutdown("app exiting");
}
static void Main(string[] args)
{
// create a configuration for the server
NetConfiguration config = new NetConfiguration("chatApp");
config.MaxConnections = 128;
config.Port = 14242;
// create server and start listening for connections
NetServer server = new NetServer(config);
server.SetMessageTypeEnabled(NetMessageType.ConnectionApproval, true);
server.Start();
// create a buffer to read data into
NetBuffer buffer = server.CreateBuffer();
// keep running until the user presses a key
Console.WriteLine("Press ESC to quit server");
bool keepRunning = true;
while (keepRunning)
{
NetMessageType type;
NetConnection sender;
// check if any messages has been received
while(server.ReadMessage(buffer, out type, out sender))
{
switch (type)
{
case NetMessageType.DebugMessage:
Console.WriteLine(buffer.ReadString());
break;
case NetMessageType.ConnectionApproval:
Console.WriteLine("Approval; hail is " + buffer.ReadString());
sender.Approve();
break;
case NetMessageType.StatusChanged:
Console.WriteLine("New status for " + sender + ": " + sender.Status + " (" + buffer.ReadString() + ")");
break;
case NetMessageType.Data:
// A client sent this data!
string msg = buffer.ReadString();
// send to everyone, including sender
NetBuffer sendBuffer = server.CreateBuffer();
sendBuffer.Write(sender.RemoteEndpoint.ToString() + " wrote: " + msg);
// send using ReliableInOrder
server.SendToAll(sendBuffer, NetChannel.ReliableInOrder1);
break;
}
}
// User pressed ESC?
while (Console.KeyAvailable)
{
ConsoleKeyInfo info = Console.ReadKey();
if (info.Key == ConsoleKey.Escape)
keepRunning = false;
}
Thread.Sleep(1);
}
server.Shutdown("Application exiting");
}
static void Main(string[] args)
{
sem = new Semaphore(1, 1);
NetPeerConfiguration config = new NetPeerConfiguration("robotcontra");
config.EnableMessageType(NetIncomingMessageType.DiscoveryRequest);
config.Port = 16868;
Thread _writeClientUpdate = new Thread(new ThreadStart(writeClientsUpdate));
// create and start server
server = new NetServer(config);
server.Start();
gameOver = false;
finishWritingLevel = false;
// schedule initial sending of position updates
double nextSendUpdates = NetTime.Now;
_writeClientUpdate.Start();
// run until escape is pressed
while (!Console.KeyAvailable || Console.ReadKey().Key != ConsoleKey.Escape)
{
NetIncomingMessage msg;
while ((msg = server.ReadMessage()) != null)
{
switch (msg.MessageType)
{
case NetIncomingMessageType.DiscoveryRequest:
//
// Server received a discovery request from a client; send a discovery response (with no extra data attached)
//
server.SendDiscoveryResponse(null, msg.SenderEndPoint);
break;
case NetIncomingMessageType.VerboseDebugMessage:
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.WarningMessage:
case NetIncomingMessageType.ErrorMessage:
//
// Just print diagnostic messages to console
//
Console.WriteLine(msg.ReadString());
break;
case NetIncomingMessageType.StatusChanged:
NetConnectionStatus status = (NetConnectionStatus)msg.ReadByte();
if (status == NetConnectionStatus.Connected)
{
//
// A new player just connected!
//
Console.WriteLine(NetUtility.ToHexString(msg.SenderConnection.RemoteUniqueIdentifier) + " connected!");
multiplayerPlayers.Add(new MultiplayerPlayers(msg.SenderConnection.RemoteUniqueIdentifier));
// randomize his position and store in connection tag
if (multiplayerPlayers.Count <= 1)
{
multiplayerPlayers[0].x = 10;
multiplayerPlayers[0].y = 350;
multiplayerPlayers[0].initialX = multiplayerPlayers[0].x;
multiplayerPlayers[0].initialY = multiplayerPlayers[0].y;
}
else
{
multiplayerPlayers[multiplayerPlayers.Count-1].x = multiplayerPlayers[multiplayerPlayers.Count - 2].x + 70;
multiplayerPlayers[multiplayerPlayers.Count-1].y = multiplayerPlayers[multiplayerPlayers.Count - 2].y;
multiplayerPlayers[multiplayerPlayers.Count - 1].initialX = multiplayerPlayers[multiplayerPlayers.Count - 1].x;
multiplayerPlayers[multiplayerPlayers.Count - 1].initialY = multiplayerPlayers[multiplayerPlayers.Count - 1].y;
}
for (int i = 0; i < server.Connections.Count; i++)
{
if (server.Connections[i].RemoteUniqueIdentifier == msg.SenderConnection.RemoteUniqueIdentifier)
{
NetConnection player = server.Connections[i] as NetConnection;
NetOutgoingMessage outMessage = server.CreateMessage();
outMessage.Write((byte)PacketTypes.CREATEPLAYER);
outMessage.Write((long)multiplayerPlayers[i].id);
outMessage.Write((float)multiplayerPlayers[i].x);
outMessage.Write((float)multiplayerPlayers[i].y);
server.SendMessage(outMessage, player, NetDeliveryMethod.ReliableOrdered);
break;
}
}
SetEnemyTarget();
}
else if (status == NetConnectionStatus.Disconnected || status == NetConnectionStatus.Disconnecting)
{
Console.WriteLine(NetUtility.ToHexString(msg.SenderConnection.RemoteUniqueIdentifier) + " DISCONNECTED FROM SERVER!");
for (int i = 0; i < multiplayerPlayers.Count; i++)
{
if (multiplayerPlayers[i].id == msg.SenderConnection.RemoteUniqueIdentifier)
{
if (multiplayerPlayers[i].isHost)
{
if (multiplayerPlayers.Count > 1)
{
multiplayerPlayers[i + 1].isHost = true;
NetConnection player = server.Connections[i];
NetOutgoingMessage outMsg = server.CreateMessage();
outMsg.Write((byte)PacketTypes.CHANGEHOST);
outMsg.Write((bool)multiplayerPlayers[i + 1].isHost);
server.SendMessage(outMsg, player, NetDeliveryMethod.ReliableOrdered);
}
}
multiplayerPlayers.RemoveAt(i);
if (deletePlayerFromServer(msg.SenderConnection.RemoteUniqueIdentifier))
{
Console.WriteLine(NetUtility.ToHexString(msg.SenderConnection.RemoteUniqueIdentifier) + " DELETED!");
}
else
{
Console.WriteLine(NetUtility.ToHexString(msg.SenderConnection.RemoteUniqueIdentifier) + " IS NOT EXIST!");
}
foreach (NetConnection player in server.Connections)
{
NetOutgoingMessage outMessage = server.CreateMessage();
outMessage.Write((byte)PacketTypes.DELETEPLAYER);
outMessage.Write((long)msg.SenderConnection.RemoteUniqueIdentifier);
server.SendMessage(outMessage, player, NetDeliveryMethod.ReliableOrdered);
}
SetEnemyTarget();
SendToAllPlayerEnemyTarget();
break;
}
}
}
break;
case NetIncomingMessageType.Data:
switch (msg.ReadByte())
{
case (byte)PacketTypes.MYPOSITION:
CharacterState state = (CharacterState)msg.ReadByte();
CharacterState laststate = (CharacterState)msg.ReadByte();
int health = msg.ReadInt32();
float xPosition = msg.ReadFloat();
float yPosition = msg.ReadFloat();
foreach (MultiplayerPlayers players in multiplayerPlayers)
{
if (players.id == msg.SenderConnection.RemoteUniqueIdentifier)
{
players.state = state;
players.lastState = laststate;
players.health = health;
players.x = xPosition;
players.y = yPosition;
break;
}
}
break;
case (byte)PacketTypes.UPDATEVELOCITY:
CharacterState currState = (CharacterState)msg.ReadByte();
CharacterState lastState = (CharacterState)msg.ReadByte();
float lastPosX = msg.ReadFloat();
float lastPosY = msg.ReadFloat();
float updateVelX = msg.ReadFloat();
float updateVelY = msg.ReadFloat();
foreach (MultiplayerPlayers players in multiplayerPlayers)
{
if (players.id == msg.SenderConnection.RemoteUniqueIdentifier)
{
players.state = currState;
players.lastState = lastState;
players.lastPosX = lastPosX;
players.lastPosY = lastPosY;
players.velocityX = updateVelX;
players.velocityY = updateVelY;
}
}
for (int i = 0; i < server.Connections.Count; i++)
{
NetConnection player = server.Connections[i] as NetConnection;
// ... send information about every other player (actually including self)
for (int j = 0; j < server.Connections.Count; j++)
{
// send position update about 'otherPlayer' to 'player'
NetOutgoingMessage om = server.CreateMessage();
// write who this position is for
om.Write((byte)PacketTypes.SENDUPDATEVELOCITY);
om.Write((long)multiplayerPlayers[j].id);
om.Write((byte)multiplayerPlayers[j].state);
om.Write((byte)multiplayerPlayers[j].lastState);
om.Write((float)multiplayerPlayers[j].lastPosX);
om.Write((float)multiplayerPlayers[j].lastPosY);
om.Write((float)multiplayerPlayers[j].velocityX);
om.Write((float)multiplayerPlayers[j].velocityY);
// send message
server.SendMessage(om, player, NetDeliveryMethod.Unreliable);
}
}
break;
case (byte)PacketTypes.SENDPLAYERDEAD:
foreach (MultiplayerPlayers players in multiplayerPlayers)
{
if (players.id == msg.SenderConnection.RemoteUniqueIdentifier)
{
players.isDead = true;
}
}
SetEnemyTarget();
SendToAllPlayerEnemyTarget();
break;
case (byte)PacketTypes.GETNUMBEROFPLAYERS:
NetOutgoingMessage msgOut = server.CreateMessage();
msgOut.Write((byte)PacketTypes.GETNUMBEROFPLAYERS);
msgOut.Write((short)multiplayerPlayers.Count);
server.SendMessage(msgOut, msg.SenderConnection, NetDeliveryMethod.ReliableOrdered);
break;
case (byte)PacketTypes.WRITELEVEL:
enemies.Clear();
for (int i = 0; i < multiplayerPlayers.Count; i++)
{
if (multiplayerPlayers[i].id == msg.SenderConnection.RemoteUniqueIdentifier)
{
multiplayerPlayers[i].isHost = true;
}
}
int enemiesInLevel = msg.ReadInt16();
level = msg.ReadInt16();
for (int i = 0; i < enemiesInLevel; i++)
{
Enemy tempEnemy = new Enemy();
tempEnemy.isDead = false;
tempEnemy.health = msg.ReadInt16();
tempEnemy.state = (CharacterState)msg.ReadByte();
tempEnemy.lastState = (CharacterState)msg.ReadByte();
tempEnemy.x = msg.ReadFloat();
tempEnemy.y = msg.ReadFloat();
enemies.Add(tempEnemy);
}
SetEnemyTarget();
SendToAllPlayerEnemyTarget();
finishWritingLevel = true;
break;
case (byte)PacketTypes.UPDATEENEMYPOSITION:
for (int i = 0; i < enemies.Count; i++)
{
if (finishWritingLevel == true)
{
enemies[i].health = msg.ReadInt32();
enemies[i].state = (CharacterState)msg.ReadByte();
enemies[i].lastState = (CharacterState)msg.ReadByte();
enemies[i].x = msg.ReadFloat();
enemies[i].y = msg.ReadFloat();
}
}
SendToAllEnemyPositionsToPlayers();
break;
case (byte)PacketTypes.DELETEENEMY:
int enemyDead = msg.ReadInt16();
if (enemies.Count > 0 && finishWritingLevel == true)
enemies[enemyDead].isDead = true;
break;
case (byte)PacketTypes.GETSERVERENEMYPOSITIONS:
msgOut = server.CreateMessage();
msgOut.Write((byte)PacketTypes.SENDENEMYPOSITIONS);
for (int i = 0; i < enemies.Count; i++)
{
msgOut.Write((byte)enemies[i].state);
msgOut.Write((byte)enemies[i].lastState);
msgOut.Write((bool)enemies[i].isDead);
msgOut.Write((float)enemies[i].x);
msgOut.Write((float)enemies[i].y);
}
server.SendMessage(msgOut, msg.SenderConnection, NetDeliveryMethod.ReliableOrdered);
break;
case (byte)PacketTypes.GETSERVERLEVEL:
msgOut = server.CreateMessage();
msgOut.Write((byte)PacketTypes.GETLEVEL);
msgOut.Write((short)level);
msgOut.Write((short)enemies.Count);
for (int i = 0; i < enemies.Count; i++)
{
msgOut.Write((byte)enemies[i].state);
msgOut.Write((byte)enemies[i].lastState);
msgOut.Write((short)enemies[i].health);
msgOut.Write((bool)enemies[i].isDead);
msgOut.Write((float)enemies[i].x);
msgOut.Write((float)enemies[i].y);
}
server.SendMessage(msgOut, msg.SenderConnection, NetDeliveryMethod.ReliableOrdered);
break;
case (byte)PacketTypes.GETENEMYTARGETPLAYER:
SetEnemyTarget();
SendToAllPlayerEnemyTarget();
break;
case (byte)PacketTypes.GAMEOVER:
gameOver = true;
break;
}
break;
}
}
double now = NetTime.Now;
if (now > nextSendUpdates)
{
// Yes, it's time to send position updates
// for each player...
for (int i = 0; i < server.Connections.Count; i++)
{
NetConnection player = server.Connections[i] as NetConnection;
// ... send information about every other player (actually including self)
for (int j = 0; j < multiplayerPlayers.Count; j++)
{
// send position update about 'otherPlayer' to 'player'
NetOutgoingMessage om = server.CreateMessage();
// write who this position is for
om.Write((byte)PacketTypes.UPDATEPLAYERS);
om.Write((long)multiplayerPlayers[j].id);
om.Write((byte)multiplayerPlayers[j].state);
om.Write((byte)multiplayerPlayers[j].lastState);
om.Write((int)multiplayerPlayers[j].health);
om.Write((bool)multiplayerPlayers[j].isDead);
om.Write((float)multiplayerPlayers[j].x);
om.Write((float)multiplayerPlayers[j].y);
// send message
server.SendMessage(om, player, NetDeliveryMethod.Unreliable);
}
}
// schedule next update
nextSendUpdates += (1.0 / 60.0);
}
// sleep to allow other processes to run smoothly
Thread.Sleep(1);
}
server.Shutdown("app exiting");
}
static unsafe void Main(string[] args)
{
// JIT stuff
NetBuffer msg = new NetBuffer(20);
msg.Write((short)short.MaxValue);
// Go
double timeStart = NetTime.Now;
msg = new NetBuffer(20);
for (int n = 0; n < 10000; n++)
{
msg.Reset();
msg.Write((short)short.MaxValue);
msg.Write((short)short.MinValue);
msg.Write((short)-42);
msg.Write(421);
msg.Write((byte)7);
msg.Write(-42.8f);
if (msg.LengthBytes != 15)
throw new Exception("Bad message length");
msg.Write("duke of earl");
int bytesWritten;
bytesWritten = msg.WriteVariableInt32(-1);
bytesWritten = msg.WriteVariableInt32(5);
bytesWritten = msg.WriteVariableInt32(-18);
bytesWritten = msg.WriteVariableInt32(42);
bytesWritten = msg.WriteVariableInt32(-420);
msg.Write((uint)9991);
// byte boundary kept until here
msg.Write(true);
msg.Write((uint)3, 5);
msg.Write(8.111f);
msg.Write("again");
byte[] arr = new byte[] { 1, 6, 12, 24 };
msg.Write(arr);
msg.Write((byte)7, 7);
msg.Write(Int32.MinValue);
msg.Write(UInt32.MaxValue);
msg.WriteRangedSingle(21.0f, -10, 50, 12);
// test reduced bit signed writing
msg.Write(15, 5);
msg.Write(2, 5);
msg.Write(0, 5);
msg.Write(-1, 5);
msg.Write(-2, 5);
msg.Write(-15, 5);
msg.Write(UInt64.MaxValue);
msg.Write(Int64.MaxValue);
msg.Write(Int64.MinValue);
msg.Write(42);
msg.WritePadBits();
int numBits = msg.WriteRangedInteger(0, 10, 5);
if (numBits != 4)
throw new Exception("Ack WriteRangedInteger failed");
// verify
msg.Position = 0;
short a = msg.ReadInt16();
short b = msg.ReadInt16();
short c = msg.ReadInt16();
if (a != short.MaxValue || b != short.MinValue || c != -42)
throw new Exception("Ack thpth short failed");
if (msg.ReadInt32() != 421)
throw new Exception("Ack thphth 1");
if (msg.ReadByte() != (byte)7)
throw new Exception("Ack thphth 2");
if (msg.ReadSingle() != -42.8f)
throw new Exception("Ack thphth 3");
if (msg.ReadString() != "duke of earl")
throw new Exception("Ack thphth 4");
if (msg.ReadVariableInt32() != -1) throw new Exception("ReadVariableInt32 failed 1");
if (msg.ReadVariableInt32() != 5) throw new Exception("ReadVariableInt32 failed 2");
if (msg.ReadVariableInt32() != -18) throw new Exception("ReadVariableInt32 failed 3");
if (msg.ReadVariableInt32() != 42) throw new Exception("ReadVariableInt32 failed 4");
if (msg.ReadVariableInt32() != -420) throw new Exception("ReadVariableInt32 failed 5");
if (msg.ReadUInt32() != 9991)
throw new Exception("Ack thphth 4.5");
if (msg.ReadBoolean() != true)
throw new Exception("Ack thphth 5");
if (msg.ReadUInt32(5) != (uint)3)
throw new Exception("Ack thphth 6");
if (msg.ReadSingle() != 8.111f)
throw new Exception("Ack thphth 7");
if (msg.ReadString() != "again")
throw new Exception("Ack thphth 8");
byte[] rrr = msg.ReadBytes(4);
if (rrr[0] != arr[0] || rrr[1] != arr[1] || rrr[2] != arr[2] || rrr[3] != arr[3])
throw new Exception("Ack thphth 9");
if (msg.ReadByte(7) != 7)
throw new Exception("Ack thphth 10");
if (msg.ReadInt32() != Int32.MinValue)
throw new Exception("Ack thphth 11");
if (msg.ReadUInt32() != UInt32.MaxValue)
throw new Exception("Ack thphth 12");
float v = msg.ReadRangedSingle(-10, 50, 12);
// v should be close to, but not necessarily exactly, 21.0f
if ((float)Math.Abs(21.0f - v) > 0.1f)
throw new Exception("Ack thphth *RangedSingle() failed");
if (msg.ReadInt32(5) != 15)
throw new Exception("Ack thphth ReadInt32 1");
if (msg.ReadInt32(5) != 2)
throw new Exception("Ack thphth ReadInt32 2");
if (msg.ReadInt32(5) != 0)
throw new Exception("Ack thphth ReadInt32 3");
if (msg.ReadInt32(5) != -1)
throw new Exception("Ack thphth ReadInt32 4");
if (msg.ReadInt32(5) != -2)
throw new Exception("Ack thphth ReadInt32 5");
if (msg.ReadInt32(5) != -15)
throw new Exception("Ack thphth ReadInt32 6");
UInt64 longVal = msg.ReadUInt64();
if (longVal != UInt64.MaxValue)
throw new Exception("Ack thphth UInt64");
if (msg.ReadInt64() != Int64.MaxValue)
throw new Exception("Ack thphth Int64");
if (msg.ReadInt64() != Int64.MinValue)
throw new Exception("Ack thphth Int64");
if (msg.ReadInt32() != 42)
throw new Exception("Ack thphth end");
msg.SkipPadBits();
if (msg.ReadRangedInteger(0, 10) != 5)
throw new Exception("Ack thphth ranged integer");
}
// test writevariableuint64
NetBuffer largeBuffer = new NetBuffer(100 * 8);
UInt64[] largeNumbers = new ulong[100];
for (int i = 0; i < 100; i++)
{
largeNumbers[i] = ((ulong)NetRandom.Instance.NextUInt() << 32) | (ulong)NetRandom.Instance.NextUInt();
largeBuffer.WriteVariableUInt64(largeNumbers[i]);
}
largeBuffer.Position = 0;
for (int i = 0; i < 100; i++)
{
UInt64 ln = largeBuffer.ReadVariableUInt64();
if (ln != largeNumbers[i])
throw new Exception("large fail");
}
//
// Extended tests on padbits
//
for (int i = 1; i < 31; i++)
{
NetBuffer buf = new NetBuffer();
buf.Write((int)1, i);
if (buf.LengthBits != i)
throw new Exception("Bad length!");
buf.WritePadBits();
int wholeBytes = buf.LengthBits / 8;
if (wholeBytes * 8 != buf.LengthBits)
throw new Exception("WritePadBits failed! Length is " + buf.LengthBits);
}
NetBuffer small = new NetBuffer(100);
byte[] rnd = new byte[24];
int[] bits = new int[24];
for (int i = 0; i < 24; i++)
{
rnd[i] = (byte)NetRandom.Instance.Next(0, 65);
bits[i] = NetUtility.BitsToHoldUInt((uint)rnd[i]);
small.Write(rnd[i], bits[i]);
}
small.Position = 0;
for (int i = 0; i < 24; i++)
{
byte got = small.ReadByte(bits[i]);
if (got != rnd[i])
throw new Exception("Failed small allocation test");
}
double timeEnd = NetTime.Now;
double timeSpan = timeEnd - timeStart;
Console.WriteLine("Trivial tests passed in " + (timeSpan * 1000.0) + " milliseconds");
Console.WriteLine("Creating client and server for live testing...");
NetConfiguration config = new NetConfiguration("unittest");
config.Port = 14242;
NetServer server = new NetServer(config);
NetBuffer serverBuffer = new NetBuffer();
server.Start();
config = new NetConfiguration("unittest");
NetClient client = new NetClient(config);
client.SetMessageTypeEnabled(NetMessageType.Receipt, true);
NetBuffer clientBuffer = client.CreateBuffer();
client.Start();
client.Connect("127.0.0.1", 14242);
List<string> events = new List<string>();
double end = double.MaxValue;
double disconnect = double.MaxValue;
while (NetTime.Now < end)
{
double now = NetTime.Now;
NetMessageType nmt;
NetConnection sender;
//
// client
//
if (client.ReadMessage(clientBuffer, out nmt))
{
switch (nmt)
{
case NetMessageType.StatusChanged:
Console.WriteLine("Client: " + client.Status + " (" + clientBuffer.ReadString() + ")");
events.Add("CStatus " + client.Status);
if (client.Status == NetConnectionStatus.Connected)
{
// send reliable message
NetBuffer buf = client.CreateBuffer();
buf.Write(true);
buf.Write((int)52, 7);
buf.Write("Hallon");
client.SendMessage(buf, NetChannel.ReliableInOrder1, new NetBuffer("kokos"));
}
if (client.Status == NetConnectionStatus.Disconnected)
end = NetTime.Now + 1.0; // end in one second
break;
case NetMessageType.Receipt:
events.Add("CReceipt " + clientBuffer.ReadString());
break;
case NetMessageType.ConnectionRejected:
case NetMessageType.BadMessageReceived:
throw new Exception("Failed: " + nmt);
case NetMessageType.DebugMessage:
// silently ignore
break;
default:
// ignore
Console.WriteLine("Ignored: " + nmt);
break;
}
}
//
// server
//
if (server.ReadMessage(serverBuffer, out nmt, out sender))
{
switch (nmt)
{
case NetMessageType.StatusChanged:
events.Add("SStatus " + sender.Status);
Console.WriteLine("Server: " + sender.Status + " (" + serverBuffer.ReadString() + ")");
break;
case NetMessageType.ConnectionRejected:
case NetMessageType.BadMessageReceived:
throw new Exception("Failed: " + nmt);
case NetMessageType.Data:
events.Add("DataRec " + serverBuffer.LengthBits);
bool shouldBeTrue = serverBuffer.ReadBoolean();
int shouldBeFifthTwo = serverBuffer.ReadInt32(7);
string shouldBeHallon = serverBuffer.ReadString();
if (shouldBeTrue != true ||
shouldBeFifthTwo != 52 ||
shouldBeHallon != "Hallon")
throw new Exception("Bad data transmission");
disconnect = now + 1.0;
break;
case NetMessageType.DebugMessage:
// silently ignore
break;
default:
// ignore
Console.WriteLine("Ignored: " + nmt);
break;
}
}
if (now > disconnect)
{
server.Connections[0].Disconnect("Bye", 0.1f);
disconnect = double.MaxValue;
}
}
// verify events
string[] expected = new string[] {
"CStatus Connecting",
"SStatus Connecting",
"CStatus Connected",
"SStatus Connected",
"DataRec 64",
"CReceipt kokos",
"SStatus Disconnecting",
"CStatus Disconnecting",
"SStatus Disconnected",
"CStatus Disconnected"
};
if (events.Count != expected.Length)
throw new Exception("Mismatch in events count! Expected " + expected.Length + ", got " + events.Count);
for(int i=0;i<expected.Length;i++)
{
if (events[i] != expected[i])
throw new Exception("Event " + i + " (" + expected[i] + ") mismatched!");
}
Console.WriteLine("All tests successful");
Console.ReadKey();
server.Shutdown("App exiting");
client.Shutdown("App exiting");
}
static void Main(string[] args)
{
NetConfiguration config = new NetConfiguration("durable");
config.MaxConnections = 128;
config.Port = 14242;
NetServer server = new NetServer(config);
server.SetMessageTypeEnabled(NetMessageType.ConnectionApproval, true);
server.SetMessageTypeEnabled(NetMessageType.DebugMessage, true);
//server.SetMessageTypeEnabled(NetMessageType.VerboseDebugMessage, true);
server.SetMessageTypeEnabled(NetMessageType.StatusChanged, true);
server.SimulatedMinimumLatency = 0.05f;
server.SimulatedLatencyVariance = 0.025f;
server.SimulatedLoss = 0.03f;
server.Start();
FileStream fs = new FileStream("./serverlog.txt", FileMode.Create, FileAccess.Write, FileShare.Read);
StreamWriter wrt = new StreamWriter(fs);
Output(wrt, "Log started at " + DateTime.Now);
wrt.Flush();
NetBuffer buffer = server.CreateBuffer();
int expected = 1;
Console.WriteLine("Press any key to quit");
while (!Console.KeyAvailable)
{
NetMessageType type;
NetConnection sender;
if (server.ReadMessage(buffer, out type, out sender))
{
switch (type)
{
case NetMessageType.StatusChanged:
if (sender.RemoteHailData != null)
Output(wrt, "New status: " + sender.Status + " (" + buffer.ReadString() + ") Remote hail is: " + Encoding.ASCII.GetString(sender.RemoteHailData));
else
Output(wrt, "New status: " + sender.Status + " (" + buffer.ReadString() + ") Remote hail hasn't arrived.");
break;
case NetMessageType.BadMessageReceived:
case NetMessageType.ConnectionRejected:
case NetMessageType.DebugMessage:
//
// All these types of messages all contain a single string in the buffer; display it
//
Output(wrt, buffer.ReadString());
break;
case NetMessageType.VerboseDebugMessage:
wrt.WriteLine(buffer.ReadString()); // don't output to console
break;
case NetMessageType.ConnectionApproval:
if (sender.RemoteHailData != null &&
Encoding.ASCII.GetString(sender.RemoteHailData) == "Hail from client")
{
Output(wrt, "Hail ok!");
sender.Approve(Encoding.ASCII.GetBytes("Hail from server"));
}
else
{
sender.Disapprove("Wrong hail!");
}
break;
case NetMessageType.Data:
string str = buffer.ReadString();
// parse it
int nr = Int32.Parse(str.Substring(9));
if (nr != expected)
{
Output(wrt, "Warning! Expected " + expected + "; received " + nr + " str is ---" + str + "---");
}
else
{
expected++;
Console.Title = "Server; received " + nr + " messages";
}
break;
default:
Output(wrt, "Unhandled: " + type + " " + buffer.ToString());
break;
}
}
Thread.Sleep(1);
}
// clean shutdown
wrt.Close();
server.Shutdown("Application exiting");
}
static void Main()
{
var connectedPlayers = 0;
var config = new NetPeerConfiguration("romero");
config.EnableMessageType(NetIncomingMessageType.DiscoveryRequest);
config.Port = 14242;
var PlayerNames = new Dictionary<long, string>();
//var xinput = 0;
//var yinput = 0;
var dummyName = string.Empty;
float angle = 0;
// create and start server
var server = new NetServer(config);
server.Start();
Console.WriteLine("Server online");
// schedule initial sending of position updates
var nextSendUpdates = NetTime.Now;
// run until escape is pressed
while (!Console.KeyAvailable || Console.ReadKey().Key != ConsoleKey.Escape)
{
NetIncomingMessage msg;
while ((msg = server.ReadMessage()) != null)
{
switch (msg.MessageType)
{
case NetIncomingMessageType.DiscoveryRequest:
//
// Server received a discovery request from a client; send a discovery response (with no extra data attached)
//
var om = server.CreateMessage();
if (connectedPlayers < 4)
{
om.Write(true);
server.SendDiscoveryResponse(om, msg.SenderEndpoint);
}
else
{
om.Write(false);
server.SendDiscoveryResponse(om, msg.SenderEndpoint);
}
break;
case NetIncomingMessageType.VerboseDebugMessage:
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.WarningMessage:
case NetIncomingMessageType.ErrorMessage:
//
// Just print diagnostic messages to console
//
Console.WriteLine(msg.ReadString());
break;
case NetIncomingMessageType.StatusChanged:
var status = (NetConnectionStatus)msg.ReadByte();
if (status == NetConnectionStatus.Connected)
{
//
// A new player just connected!
//
Console.WriteLine(msg.SenderConnection.RemoteUniqueIdentifier + " connected. (IP Address: " + msg.SenderEndpoint.Address + ")");
connectedPlayers++;
Console.WriteLine(connectedPlayers + " players ingame");
};
if (status == NetConnectionStatus.Disconnected)
{
Console.WriteLine(msg.SenderConnection.RemoteUniqueIdentifier + " disconnected. (IP Address: " + msg.SenderEndpoint.Address + ")");
connectedPlayers--;
Console.WriteLine(connectedPlayers + " players ingame");
}
break;
case NetIncomingMessageType.Data:
//
// The client sent input to the server
//
dummyName = msg.ReadString();
if (!PlayerNames.ContainsKey(msg.SenderConnection.RemoteUniqueIdentifier))
{
PlayerNames.Add(msg.SenderConnection.RemoteUniqueIdentifier, dummyName);
}
// fancy movement logic goes here
var xinput = msg.ReadInt32();
var yinput = msg.ReadInt32();
var playerAngle = msg.ReadFloat();
var pos = msg.SenderConnection.Tag as float[];
if (pos != null)
{
pos[0] = xinput;
pos[1] = yinput;
pos[2] = playerAngle;
}
break;
}
//
// send position updates 60 times per second
//
var now = NetTime.Now;
if (now > nextSendUpdates)
{
// Yes, it's time to send position updates
// for each player...
foreach (var player in server.Connections)
{
// ... send information about every other player (actually including self)
foreach (var otherPlayer in server.Connections)
{
// send position update about 'otherPlayer' to 'player'
var om = server.CreateMessage();
if (otherPlayer != null)
{
// write who this position is for
om.Write(otherPlayer.RemoteUniqueIdentifier);
if (PlayerNames.ContainsKey(otherPlayer.RemoteUniqueIdentifier))
{
om.Write(PlayerNames.Single(i => i.Key == otherPlayer.RemoteUniqueIdentifier).Value);
}
if (otherPlayer.Tag == null)
otherPlayer.Tag = new float[3];
var pos = otherPlayer.Tag as float[];
om.Write(pos[0]);
om.Write(pos[1]);
om.Write(pos[2]);
// send message
server.SendMessage(om, player, NetDeliveryMethod.Unreliable);
}
}
}
// schedule next update
nextSendUpdates += (1.0 / 60.0);
}
}
// sleep to allow other processes to run smoothly
Thread.Sleep(1);
}
Console.WriteLine("Server powering down..");
server.Shutdown("bye");
}
public void Deinitialize()
{
//Log.Debug(this, "Deinitialize");
_netServer.Shutdown("good-bye");
}
