private static void Main(string[] args)
{
var config = new NetPeerConfiguration("airgap")
{
Port = port,
MaximumConnections = 50,
ConnectionTimeout = 5f
};
config.EnableMessageType(NetIncomingMessageType.ConnectionApproval);
var server = new NetServer(config);
server.Start();
Console.WriteLine("AudioGap Server Started");
waveOut.DeviceNumber = 0; // TODO: need an option for this
while (true)
{
NetIncomingMessage msg;
if ((msg = server.ReadMessage()) == null)
{
Thread.Sleep(1);
continue;
}
switch (msg.MessageType)
{
case NetIncomingMessageType.VerboseDebugMessage:
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.WarningMessage:
case NetIncomingMessageType.ErrorMessage:
Console.WriteLine(msg.ReadString());
break;
case NetIncomingMessageType.StatusChanged:
var status = (NetConnectionStatus)msg.ReadByte();
string reason = msg.ReadString();
Console.WriteLine("New status: " + status + " (" + reason + ")");
break;
case NetIncomingMessageType.ConnectionApproval:
SetupAudio(msg);
msg.SenderConnection.Approve();
break;
case NetIncomingMessageType.Data:
if (msg.SenderConnection.Status == NetConnectionStatus.Connected)
HandleAudioPacket(msg);
break;
default:
Console.WriteLine("Unhandled type: " + msg.MessageType);
break;
}
}
}
static void Main(string[] args)
{
server = new NetServer(new NetPeerConfiguration("Fireworks")
{
AcceptIncomingConnections = true,
Port = 7007,
ConnectionTimeout = 5
});
server.Start();
Console.WriteLine("Started server");
while (true)
{
NetIncomingMessage message;
while ((message = server.ReadMessage()) != null)
{
switch (message.MessageType)
{
case NetIncomingMessageType.Data:
{
var type = (Protocol)message.ReadByte();
HandleIncomingData(type, message.SenderConnection, message);
break;
}
case NetIncomingMessageType.StatusChanged:
{
var status = (NetConnectionStatus) message.ReadByte();
var msg = message.ReadString();
Console.WriteLine(status);
Console.WriteLine(msg);
if (status == NetConnectionStatus.Connected)
{
Console.WriteLine("Client connected from " + message.SenderConnection.ToString());
}
else if (status == NetConnectionStatus.Disconnected)
{
Console.WriteLine("Client disconnected from " + message.SenderConnection.ToString());
}
break;
}
}
}
Thread.Sleep(1);
}
}
static void Main(string[] args)
{
IPEndPoint masterServerEndpoint = NetUtility.Resolve("localhost", CommonConstants.MasterServerPort);
NetPeerConfiguration config = new NetPeerConfiguration("game");
config.SetMessageTypeEnabled(NetIncomingMessageType.NatIntroductionSuccess, true);
config.Port = 14242;
NetServer server = new NetServer(config);
server.Start();
Console.WriteLine("Server started; waiting 5 seconds...");
System.Threading.Thread.Sleep(5000);
var lastRegistered = -60.0f;
while(Console.KeyAvailable == false || Console.ReadKey().Key != ConsoleKey.Escape)
{
// (re-)register periodically with master server
if (NetTime.Now > lastRegistered + 60)
{
// register with master server
NetOutgoingMessage regMsg = server.CreateMessage();
regMsg.Write((byte)MasterServerMessageType.RegisterHost);
IPAddress mask;
IPAddress adr = NetUtility.GetMyAddress(out mask);
regMsg.Write(server.UniqueIdentifier);
regMsg.Write(new IPEndPoint(adr, 14242));
Console.WriteLine("Sending registration to master server");
server.SendUnconnectedMessage(regMsg, masterServerEndpoint);
lastRegistered = (float)NetTime.Now;
}
NetIncomingMessage inc;
while ((inc = server.ReadMessage()) != null)
{
switch (inc.MessageType)
{
case NetIncomingMessageType.VerboseDebugMessage:
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.WarningMessage:
case NetIncomingMessageType.ErrorMessage:
Console.WriteLine(inc.ReadString());
break;
}
}
System.Threading.Thread.Sleep(1);
}
Console.ReadKey();
}
static void Main(string[] args)
{
NetPeerConfiguration config = new NetPeerConfiguration("garbagethrower");
config.MaximumConnections = 1;
config.Port = 14242;
config.PingInterval = 2.0f;
config.ConnectionTimeout = 2.0f;
var server = new NetServer(config);
server.Start();
while (true)
{
NetIncomingMessage msg;
while ((msg = server.ReadMessage()) != null)
{
switch (msg.MessageType)
{
case NetIncomingMessageType.StatusChanged:
var status = (NetConnectionStatus)msg.ReadByte();
var reason = msg.ReadString();
Console.WriteLine("New status: " + status + " (" + reason + ")");
break;
case NetIncomingMessageType.WarningMessage:
case NetIncomingMessageType.VerboseDebugMessage:
case NetIncomingMessageType.ErrorMessage:
case NetIncomingMessageType.DebugMessage:
var str = msg.ReadString();
if (str.StartsWith("Malformed packet; stated") ||
str.StartsWith("Received unhandled library message") ||
str.StartsWith("Unexpected NetMessageType"))
break; // we'll get a bunch of these and we're fine with that
Console.WriteLine(msg.MessageType + ": " + str);
break;
case NetIncomingMessageType.Data:
Console.WriteLine("Received " + msg.LengthBits + " bits of data");
break;
case NetIncomingMessageType.UnconnectedData:
Console.WriteLine("Received " + msg.LengthBits + " bits of unconnected data");
break;
default:
Console.WriteLine("Received " + msg.MessageType);
break;
}
}
}
}
public void handleRequest(NetServer s)
{
NetIncomingMessage inc;
if ((inc = s.ReadMessage()) != null)
{
switch (inc.MessageType)
{
case NetIncomingMessageType.Data:
break;
default:
break;
}
}
}
static void Main(string[] args)
{
NetPeerConfiguration config = new NetPeerConfiguration("LidgrenTestServer");
config.Port = 14242;
config.MaximumConnections = 200;
NetServer server = new NetServer(config);
server.Start();
NetIncomingMessage msg;
while(true)
{
if((msg = server.ReadMessage()) != null)
{
Console.WriteLine(msg.ReadString());
server.Recycle(msg);
}
Thread.Sleep(20);
}
}
public void HandleEvent(int timeoutMs)
{
NetIncomingMessage netMessage;
while ((netMessage = _netServer.ReadMessage()) != null)
{
switch (netMessage.MessageType)
{
case NetIncomingMessageType.Data:
var receivedData = netMessage.ReadBytes(netMessage.LengthBytes);
OnNetworkReceive(netMessage.SenderConnection, receivedData);
break;
case NetIncomingMessageType.StatusChanged:
NetConnectionStatus status = (NetConnectionStatus)netMessage.ReadByte();
if (status == NetConnectionStatus.Connected)
{
//Log.Debug(this, $"Connected {netMessage.SenderConnection.Peer.UniqueIdentifier}");
OnPeerConnected(netMessage.SenderConnection);
}
else if (status == NetConnectionStatus.Disconnected)
{
//Log.Debug(this, $"Disconnected {netMessage.SenderConnection.Peer.UniqueIdentifier}");
OnPeerDisconnected(netMessage.SenderConnection);
}
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;
}
}
}
static void Main(string[] args)
{
var config = new NetPeerConfiguration("enctest");
config.MaximumConnections = 1;
config.Port = 14242;
var server = new NetServer(config);
server.Start();
var encryption = new NetAESEncryption(server, "Hallonpalt");
// loop forever
while (true)
{
var inc = server.ReadMessage();
if (inc != null)
{
switch (inc.MessageType)
{
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.WarningMessage:
case NetIncomingMessageType.VerboseDebugMessage:
case NetIncomingMessageType.ErrorMessage:
Console.WriteLine(inc.ReadString());
break;
case NetIncomingMessageType.StatusChanged:
var status = (NetConnectionStatus)inc.ReadByte();
Console.WriteLine(inc.SenderConnection + " (" + status + ") " + inc.ReadString());
break;
case NetIncomingMessageType.Data:
var ok = inc.Decrypt(encryption);
Console.WriteLine("Data (decrypted: " + (ok ? "ok" : "fail") + ") " + inc.ReadString());
break;
}
}
System.Threading.Thread.Sleep(1);
}
}
static void Main(string[] args)
{
//Setup the policy server first.
const string AllPolicy =
@"<?xml version='1.0'?>
<cross-domain-policy>
<allow-access-from domain=""*"" to-ports=""*"" />
</cross-domain-policy>";
SocketPolicyServer policyServer = new SocketPolicyServer(AllPolicy);
int ret = policyServer.Start();
if (ret != 0)
Console.WriteLine("Failed to start policy server.");
else
Console.WriteLine("Policy service started.");
//Alright, now onto the regular server.
config = new NetPeerConfiguration("crab_battle");
config.Port = 14248;
config.MaximumConnections = 10;
config.EnableMessageType(NetIncomingMessageType.ConnectionApproval);
server = new NetServer(config);
server.Start();
Console.WriteLine("Crab Battle server open for business.");
NetIncomingMessage inc;
DateTime time = DateTime.Now;
DateTime lastBeat = DateTime.Now;
DateTime introtime = DateTime.Now;
TimeSpan timetopass = new TimeSpan(0,0,0,0,50);
TimeSpan beatrate = new TimeSpan(0, 0, 1);
TimeSpan introlength;
bool skipintro = false;
if(skipintro == true)
introlength = new TimeSpan(0, 0, 3);
else
introlength = new TimeSpan(0, 0, 21);
int beatnum = 0;
players = new List<PlayerObject>();
int playercount = 0;
NetOutgoingMessage outmsg;
int gamePhase = 0;
int gameDifficulty = 1;
healthMod = 1;
CrabBehavior crab = new CrabBehavior();
while(true)
{
//The gamestate stuff comes first because we drop a continue if no packet is recieved.
if (gamePhase != (int)GameState.Lobby && players.Count == 0)
{
Console.WriteLine("All players disconnected, returning to lobby gamestate.");
gamePhase = (int)GameState.Lobby;
}
if (gamePhase == (int)GameState.Intro && ((introtime + introlength) < DateTime.Now))
{
//Intro has ran for it's length, lets start the game proper.
outmsg = server.CreateMessage();
outmsg.Write((byte)PacketTypes.StartGame);
server.SendMessage(outmsg, server.Connections, NetDeliveryMethod.ReliableOrdered, 1);
crab.Direction = false;
gamePhase = (int)GameState.InGame;
}
if(gamePhase == (int)GameState.InGame)
{
crab.GoGoBattleCrab();
}
//Handle dropping players.
if ((time + timetopass) < DateTime.Now)
{
for (int i = 0; i < players.Count; i++)
{
PlayerObject player = players[i];
//Make sure everyone is connected, and if not drop them.
if (player.Connection.Status == NetConnectionStatus.Disconnected || player.Connection.Status == NetConnectionStatus.Disconnecting)
{
Console.WriteLine(player.Name + " has disconnected, removing player object.");
SendLobbyMessage("Server", player.Name + " has disconnected.");
outmsg = server.CreateMessage();
outmsg.Write((byte)PacketTypes.RemovePlayer);
outmsg.Write((Int16)player.Id);
server.SendMessage(outmsg, server.Connections, NetDeliveryMethod.ReliableOrdered, 1);
players.Remove(player);
outmsg = server.CreateMessage();
outmsg.Write((byte)PacketTypes.PlayerCount);
outmsg.Write((Int16)players.Count);
server.SendMessage(outmsg, server.Connections, NetDeliveryMethod.ReliableOrdered, 1);
}
else
{
if (player.LastBeat + 5 < beatnum)
{
player.Connection.Disconnect("Timeout");
Console.WriteLine(player.Name + " has not responded in over 10 seconds. Closing connection.");
}
}
}
time = DateTime.Now;
}
//Send update beats.
if ((lastBeat + beatrate) < DateTime.Now)
{
//Send a beat to all users. Because the server doesn't really know if they disconnected unless we are sending packets to them.
//Beats go out every 2 seconds.
foreach (PlayerObject p in players)
{
outmsg = server.CreateMessage();
outmsg.Write((byte)PacketTypes.Beat);
outmsg.Write((Int16)beatnum);
outmsg.Write(p.Connection.AverageRoundtripTime/2f);
server.SendMessage(outmsg, p.Connection, NetDeliveryMethod.ReliableOrdered, 1);
}
beatnum++;
lastBeat = DateTime.Now;
}
// IT'S PACKET TIME
if ((inc = server.ReadMessage()) == null) continue;
switch(inc.MessageType)
{
case NetIncomingMessageType.ConnectionApproval:
//A new connection! If the game is not currently ongoing, we'll accept this connection.
Console.WriteLine("Incoming login request. " + inc.SenderConnection.ToString());
if (gamePhase > 0)
{
inc.SenderConnection.Deny("The server is already running a game.");
break;
}
Console.WriteLine("Assigning new player the name of Player " + (playercount+1) + ".");
inc.SenderConnection.Approve();
players.Add(new PlayerObject(playercount+1, inc.SenderConnection, "Player "+(playercount+1), beatnum));
SendLobbyMessage("Server", "Player " + (playercount + 1) + " has connected. Connected players: " + players.Count);
outmsg = server.CreateMessage();
outmsg.Write((byte)PacketTypes.Message);
outmsg.Write("You are now connected to CrabBattle Server.");
server.SendMessage(outmsg, inc.SenderConnection, NetDeliveryMethod.ReliableOrdered, 1);
outmsg = server.CreateMessage();
outmsg.Write((byte)PacketTypes.AssignId);
outmsg.Write((Int32)(playercount + 1));
server.SendMessage(outmsg, inc.SenderConnection, NetDeliveryMethod.ReliableOrdered, 1);
//Send the current playercount to the client.
outmsg = server.CreateMessage();
outmsg.Write((byte)PacketTypes.PlayerCount);
outmsg.Write((Int16)players.Count);
server.SendMessage(outmsg, inc.SenderConnection, NetDeliveryMethod.ReliableOrdered, 1);
outmsg = server.CreateMessage();
outmsg.Write((byte)PacketTypes.PlayerCount);
outmsg.Write((Int16)players.Count);
server.SendMessage(outmsg, server.Connections, NetDeliveryMethod.ReliableOrdered, 1);
//Send difficulty settings to the new player
Console.WriteLine(gameDifficulty + " " + healthMod);
outmsg = server.CreateMessage();
outmsg.Write((byte)PacketTypes.SettingsChange);
outmsg.Write((Int16)gameDifficulty);
outmsg.Write((Int16)healthMod);
server.SendMessage(outmsg, inc.SenderConnection, NetDeliveryMethod.ReliableOrdered, 1);
playercount++;
break;
case NetIncomingMessageType.Data:
PlayerObject player = players.Find(p => p.Connection == inc.SenderConnection);
if (player == null)
break; //Don't accept data from connections that don't have a player attached.
switch ((PacketTypes)inc.ReadByte())
{
case PacketTypes.LobbyMessage:
{
string msg = inc.ReadString();
SendLobbyMessage(player.Name, msg);
Console.WriteLine(player.Name + ": " + msg);
}
break;
case PacketTypes.SettingsChange:
{
//Difficulty or health mod changed, broadcast changes to all clients.
gameDifficulty = inc.ReadInt16();
healthMod = inc.ReadInt16();
Console.WriteLine(player.Name + " changed difficulty/healthmod to " + gameDifficulty + "/" + healthMod + ".");
outmsg = server.CreateMessage();
outmsg.Write((byte)PacketTypes.SettingsChange);
outmsg.Write((Int16)gameDifficulty);
outmsg.Write((Int16)healthMod);
server.SendMessage(outmsg, server.Connections, NetDeliveryMethod.ReliableOrdered, 1);
}
break;
case PacketTypes.Beat:
{
player.LastBeat = inc.ReadInt16();
player.X = inc.ReadFloat();
player.Y = inc.ReadFloat();
if (crab.CurrentTarget == player.Id)
{
float CrabX = inc.ReadFloat();
float CrabZ = inc.ReadFloat();
if (crab.random.Next(0, 10) > 8)
crab.Direction = !crab.Direction;
//Crab position and target sync.
outmsg = server.CreateMessage();
outmsg.Write((byte)PacketTypes.EnemySync);
outmsg.Write((Int16)player.Id); //Id of the current crab controller.
outmsg.Write(CrabX); //EnemyX
outmsg.Write(CrabZ); //EnemyZ
outmsg.Write(player.X);
outmsg.Write(player.Y);
outmsg.Write(crab.Direction);
outmsg.Write(player.Connection.AverageRoundtripTime/2f); //Divide by 2 to get trip time.
server.SendMessage(outmsg, server.Connections, NetDeliveryMethod.ReliableOrdered, 1);
}
}
break;
case PacketTypes.Ready:
{
//Player is ready to start the game.
player.Ready = inc.ReadBoolean();
Console.WriteLine(player.Name + " changed their ready status to " + player.Ready);
if (player.Ready)
SendLobbyMessage("Server", player.Name + " is now Ready.");
else
SendLobbyMessage("Server", player.Name + " is no longer ready.");
}
break;
case PacketTypes.UpdateName:
{
//Player changed their name. Since the clients aren't aware of each other until the game starts,
//there's no need to broadcast this message to other users.
string newname = inc.ReadString();
Console.WriteLine(player.Name + " changed their name to '" + newname + "'.");
SendLobbyMessage("Server", player.Name + " changed their name to '" + newname + "'.");
player.Name = newname;
}
break;
case PacketTypes.Disconnect:
{
//Player requests to disconnect from the server.
Console.WriteLine(player.Name + " has disconnected, removing player object.");
outmsg = server.CreateMessage();
outmsg.Write((byte)PacketTypes.RemovePlayer);
outmsg.Write((Int16)player.Id);
server.SendMessage(outmsg, server.Connections, NetDeliveryMethod.ReliableOrdered, 1);
players.Remove(player);
outmsg = server.CreateMessage();
outmsg.Write((byte)PacketTypes.PlayerCount);
outmsg.Write((Int16)players.Count);
server.SendMessage(outmsg, server.Connections, NetDeliveryMethod.ReliableOrdered, 1);
}
break;
case PacketTypes.StartGame:
{
//Someone clicked start game. Lets make sure everyone is ready and we're in a state where we can start.
if (gamePhase != (int)GameState.Lobby)
break;
bool ready = true;
foreach (PlayerObject p in players)
ready = ready & p.Ready;
if (ready)
{
outmsg = server.CreateMessage();
outmsg.Write((byte)PacketTypes.Message);
outmsg.Write("All players ready, launching game.");
server.SendMessage(outmsg, server.Connections, NetDeliveryMethod.ReliableOrdered, 1);
Console.WriteLine("All set, launching Game!");
float numplayers = players.Count();
float curplayer = ((numplayers-1) * 20f) / 2f * -1f;
for (int i = 0; i < players.Count; i++)
{
PlayerObject p = players[i];
//Lets create all the player objects for all players, 20 paces apart.
outmsg = server.CreateMessage();
outmsg.Write((byte)PacketTypes.AddPlayer);
outmsg.Write((Int16)p.Id);
p.X = curplayer;
p.Y = -500f; //Hardcoded ftw!
curplayer += 20f;
outmsg.Write(p.X);
outmsg.Write(p.Y);
outmsg.Write(p.Name);
server.SendMessage(outmsg, server.Connections, NetDeliveryMethod.ReliableOrdered, 1);
}
outmsg = server.CreateMessage();
outmsg.Write((byte)PacketTypes.PlayIntro);
server.SendMessage(outmsg, server.Connections, NetDeliveryMethod.ReliableOrdered, 1);
gamePhase = (int)GameState.Intro;
crab = new CrabBehavior(); //Prepare the CRAB!
introtime = DateTime.Now;
}
else
{
outmsg = server.CreateMessage();
outmsg.Write((byte)PacketTypes.Message);
outmsg.Write("A player attempted to start the game, but not all players are ready.");
server.SendMessage(outmsg, server.Connections, NetDeliveryMethod.ReliableOrdered, 1);
SendLobbyMessage("Server", "Game cannot start until all users are ready.");
}
}
break;
case PacketTypes.PlayerSpecial:
{
int shottype = inc.ReadInt16();
outmsg = server.CreateMessage();
outmsg.Write((byte)PacketTypes.PlayerSpecial);
outmsg.Write((Int16)player.Id);
outmsg.Write((Int16)shottype);
server.SendMessage(outmsg, server.Connections, NetDeliveryMethod.ReliableUnordered, 0);
//Console.WriteLine("Relaying Special Action Message for " + player.Name + ".");
}
break;
case PacketTypes.PlayerAction:
{
//Player hit a key or something! Change their status, broadcast to other users.
//Set player values
//inc.ReadInt16(); //Player id is submitted, but not used.
player.X = inc.ReadFloat();
player.Y = inc.ReadFloat();
player.VelocityX = inc.ReadFloat();
player.VelocityY = inc.ReadFloat();
player.Firing = inc.ReadBoolean();
//Broadcast them to everyone else
outmsg = server.CreateMessage();
outmsg.Write((byte)PacketTypes.PlayerAction);
outmsg.Write((Int16)player.Id);
outmsg.Write(player.X);
outmsg.Write(player.Y);
outmsg.Write(player.VelocityX);
outmsg.Write(player.VelocityY);
outmsg.Write(player.Firing);
outmsg.Write(player.Connection.AverageRoundtripTime/2f); //Not an exact science, but we'll use this to predict their position.
server.SendMessage(outmsg, server.Connections, NetDeliveryMethod.ReliableOrdered, 1);
//Console.WriteLine("Relaying Action Message for " + player.Name + ". "+player.VelocityX + " " + player.VelocityY);
}
break;
case PacketTypes.HurtTarget:
{
int damage = inc.ReadInt16();
crab.CurrentHealth -= damage;
bool hittype = inc.ReadBoolean();
if (!hittype)
player.dmgnormal += damage;
else
player.dmgweakpoint += damage;
outmsg = server.CreateMessage();
outmsg.Write((byte)PacketTypes.EnemyHealth);
outmsg.Write((Int16)crab.CurrentHealth);
server.SendMessage(outmsg, server.Connections, NetDeliveryMethod.Unreliable, 0);
}
break;
case PacketTypes.PlayerHit:
{
player.hitstaken += 1;
outmsg = server.CreateMessage();
outmsg.Write((byte)PacketTypes.PlayerHit);
outmsg.Write((Int16)player.Id);
server.SendMessage(outmsg, server.Connections, NetDeliveryMethod.ReliableUnordered, 0);
}
break;
}
break;
case NetIncomingMessageType.StatusChanged:
{
//Players connection status changed.
PlayerObject p1 = players.Find(p => p.Connection == inc.SenderConnection);
if (p1 == null)
break;
Console.WriteLine(p1.Name + " status changed to " + (NetConnectionStatus)inc.SenderConnection.Status + ".");
}
break;
default:
break;
}
}
}
public void Run()
{
// Server initialization
config = new NetPeerConfiguration("stryferpg");
config.Port = 1234;
server = new NetServer(config);
server.Start();
//TODO: services initialization
// Messages receipt
bool stop = false;
NetIncomingMessage message;
while (!stop)
{
while ((message = server.ReadMessage()) != null)
{
switch (message.MessageType)
{
case NetIncomingMessageType.Data:
SRActionMessage action = NetworkSerializer.DeserializeObject<SRActionMessage>(message.ReadBytes(message.LengthBytes));
switch (action.serviceType)
{
case ServiceType.Login:
LoginService.Instance.Handle(action, message.SenderConnection);
break;
case ServiceType.Char:
break;
case ServiceType.Map:
MapService.Instance.Handle(action, message.SenderConnection);
break;
}
break;
case NetIncomingMessageType.StatusChanged:
Console.WriteLine("StatusChanged");
switch (message.SenderConnection.Status)
{
case NetConnectionStatus.Connected:
Console.WriteLine("Connected");
break;
}
break;
case NetIncomingMessageType.DebugMessage:
Console.WriteLine(message.ReadString());
break;
default:
Console.WriteLine("unhandled message with type: "
+ message.MessageType);
break;
}
}
//stop = Console.ReadKey().Key == ConsoleKey.S;
Thread.Sleep(1);
}
}
private static void Main(string[] args)
{
//TODO: Chat
//TODO: UPnP
//TODO: Fix Simulated Conditions
config = new NetPeerConfiguration("spacebargame") {Port = 666, EnableUPnP = true, MaximumConnections = 50};
config.EnableMessageType(NetIncomingMessageType.ConnectionApproval);
server = new NetServer(config);
server.Start();
server.UPnP.ForwardPort(666, "Spacebar Game 2013");
NetIncomingMessage inc; // Incoming Message
//Write to con..
var consoleInput = new Thread(ConsoleIn); //Console.ReadLine is blocked, Thread it
consoleInput.Start(); //Start the Thread
UserToConnection = new Dictionary<long, Client>(); //UserStore
while (true) //While True
{
if ((inc = server.ReadMessage()) != null) //if message is not null
{
//Console.WriteLine(inc.MessageType); //Print MessageType
switch (inc.MessageType)
{
case NetIncomingMessageType.ConnectionApproval: //If ConnectionApproval request
if (inc.ReadByte() == (byte) PacketTypes.LOGIN) //and LOGIN PacketHeader
{
Console.WriteLine("Incoming LOGIN"); //Incoming Login
Name = inc.ReadString(); //Name is String Sent by Client
Console.WriteLine(Name); //Print Name
if (server.ConnectionsCount == 0) //ConnectionCount = 0
{
Started = false; //Reset
}
if (UserToConnection.Values.Any(c => c.Name == Name) || Started || Name.Length >= 12)
//If Name exists, or Game has Started or the Length is more then 12
{
inc.SenderConnection.Deny("Duplicate Name"); //Deny
}
else
{
inc.SenderConnection.Approve(); //Else Allow
UserToConnection.Add(inc.SenderConnection.RemoteUniqueIdentifier,
new Client(Name, inc.SenderConnection, 0, new byte[00000000]));
//Add them to the Dictionary for PlayerStore
}
Thread.Sleep(500); //Sleep for Half a Second
if (server.ConnectionsCount == 1) //If Server.ConnectionCount is 1 they are host
{
NetOutgoingMessage msg = server.CreateMessage(); //Host Message
msg.Write((byte) PacketTypes.HOST); //Write HOST PacketHeader
msg.Write("Congratulations, You are the host");
server.SendMessage(msg, inc.SenderConnection, NetDeliveryMethod.ReliableOrdered);
}
}
break;
case NetIncomingMessageType.Data:
var packetheader = inc.ReadByte();
switch ((PacketTypes) packetheader)
{
case PacketTypes.AVATAR:
var bufferLength = inc.ReadInt32();
var buffer = inc.ReadBytes(bufferLength);
Console.WriteLine("Buffer Length:" + bufferLength);
UserToConnection[inc.SenderConnection.RemoteUniqueIdentifier].Buffer = buffer;
foreach (KeyValuePair<long, Client> entry in UserToConnection)
{
if (entry.Key != inc.SenderConnection.RemoteUniqueIdentifier)
{
NetOutgoingMessage syncClient = server.CreateMessage();
syncClient.Write((byte) PacketTypes.RECEIVEPLAYER);
syncClient.Write(Name);
syncClient.Write(inc.SenderConnection.RemoteUniqueIdentifier);
var buffer1 =
UserToConnection[inc.SenderConnection.RemoteUniqueIdentifier].Buffer;
syncClient.Write(buffer1.Length);
syncClient.Write(buffer1);
Console.WriteLine("SENT Client Name: {0}| Client ID: {1}", Name,
inc.SenderConnection.RemoteUniqueIdentifier);
Console.WriteLine("TO: {0}, {1}", entry.Value.Name, entry.Value.Score);
server.SendMessage(syncClient, entry.Value.Connection,
NetDeliveryMethod.ReliableOrdered); //OTHERPEOPLE
}
}
foreach (KeyValuePair<long, Client> entry in UserToConnection)
{
//if (entry.Key != inc.SenderConnection.RemoteUniqueIdentifier)
{
NetOutgoingMessage syncClient = server.CreateMessage();
syncClient.Write((byte) PacketTypes.RECEIVEPLAYER);
syncClient.Write(entry.Value.Name);
syncClient.Write(entry.Key);
var buffer1 = entry.Value.Buffer;
syncClient.Write(buffer1.Length);
syncClient.Write(buffer1);
Console.WriteLine(buffer1.Length);
Console.WriteLine("SENT Client Name: {0}| Client ID: {1}", entry.Value.Name,
entry.Key);
Console.WriteLine("TO: {0}", inc.SenderConnection);
server.SendMessage(syncClient, inc.SenderConnection,
NetDeliveryMethod.ReliableOrdered); //CLIENT
}
}
break;
case PacketTypes.SENDPOS:
UserToConnection[inc.SenderConnection.RemoteUniqueIdentifier].Score =
Convert.ToInt16(inc.ReadString());
Console.WriteLine("{0}'s score is now: {1}",
UserToConnection[inc.SenderConnection.RemoteUniqueIdentifier].Name,
UserToConnection[inc.SenderConnection.RemoteUniqueIdentifier].Score);
ID = inc.SenderConnection.RemoteUniqueIdentifier;
UpdateScore();
break;
case PacketTypes.STARTGAME:
//GOGOGOGO
Console.WriteLine("START THE GAME");
Started = true;
foreach (KeyValuePair<long, Client> entry in UserToConnection)
{
{
NetOutgoingMessage syncClient = server.CreateMessage();
syncClient.Write((byte) PacketTypes.STARTGAME);
syncClient.Write("Go");
syncClient.Write(
UserToConnection[inc.SenderConnection.RemoteUniqueIdentifier].Score);
server.SendMessage(syncClient, entry.Value.Connection,
NetDeliveryMethod.ReliableOrdered);
}
}
break;
case PacketTypes.CHATSEND:
string messager = inc.ReadString();
Console.WriteLine("{0} : {1}",
UserToConnection[inc.SenderConnection.RemoteUniqueIdentifier].Name,
messager);
RelayChat(inc.SenderConnection.RemoteUniqueIdentifier, messager);
break;
}
break;
case NetIncomingMessageType.StatusChanged:
Console.WriteLine(inc.SenderConnection + " status changed. " + inc.SenderConnection.Status);
if (inc.SenderConnection.Status == NetConnectionStatus.Disconnected ||
inc.SenderConnection.Status == NetConnectionStatus.Disconnecting)
{
UserToConnection.Remove(inc.SenderConnection.RemoteUniqueIdentifier);
NetOutgoingMessage outmsg = server.CreateMessage();
outmsg.WriteVariableInt64(inc.SenderConnection.RemoteUniqueIdentifier);
server.SendToAll(outmsg, NetDeliveryMethod.ReliableOrdered);
}
break;
case NetIncomingMessageType.DiscoveryRequest:
NetOutgoingMessage discovermsg = server.CreateMessage();
discovermsg.Write("Hey I just met you, I'm a server, so address me maybe");
Console.WriteLine("WOW ~NETWORKING~");
server.SendDiscoveryResponse(discovermsg, inc.SenderEndPoint);
break;
}
}
Thread.Sleep(1);
}
}
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(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 void Main(string[] args)
{
var config = new NetPeerConfiguration("ConquerLeague")
{
Port = 47410
};
config.EnableMessageType(NetIncomingMessageType.DiscoveryRequest);
server = new NetServer(config);
server.Start();
SessionManager sessionManager = new SessionManager();
while (true)
{
NetIncomingMessage message;
while ((message = server.ReadMessage()) != null)
{
switch (message.MessageType)
{
case NetIncomingMessageType.DiscoveryRequest:
NetOutgoingMessage response = server.CreateMessage(); // Create a response and write some example data to it
response.Write("ConquerLeagueServer");
server.SendDiscoveryResponse(response, message.SenderEndPoint); // Send the response to the sender of the request
break;
case NetIncomingMessageType.Data:
var dataLength = message.ReadInt32();
var data = message.ReadBytes(dataLength);
sessionManager.ForwardMessageToSession(message.SenderConnection, dataLength, data);
break;
case NetIncomingMessageType.StatusChanged:
Console.WriteLine(message.SenderConnection.Status);
switch (message.SenderConnection.Status)
{
case NetConnectionStatus.Connected:
Console.WriteLine("Client " + message.SenderConnection.RemoteEndPoint.ToString() + " connected!");
sessionManager.AddPlayerToMatchmaking(message.SenderConnection);
break;
case NetConnectionStatus.RespondedConnect:
Console.WriteLine(message.SenderConnection.Status.ToString());
break;
default:
Console.WriteLine("Unhandled status change with type: " + message.SenderConnection.Status.ToString());
break;
}
break;
case NetIncomingMessageType.ConnectionApproval:
message.SenderConnection.Approve();
break;
case NetIncomingMessageType.DebugMessage:
Console.WriteLine(message.ReadString());
break;
case NetIncomingMessageType.WarningMessage:
Console.WriteLine("Warning: " + message.ReadString());
break;
default:
Console.WriteLine("unhandled message with type: " + message.MessageType);
break;
}
server.Recycle(message);
}
}
}
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");
}
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");
}
/// <summary>
/// ProcessMessage runs in a separate thread and manages the incoming messages of the clients.
/// </summary>
/// <param name="obj">object obj represents a NetServer object.</param>
private void ProcessMessage(object obj)
{
try
{
netServer = (NetServer)obj;
NetIncomingMessage msg;
Log.Message("Server thread started. ProcessMessage(). Current MPRole: " + MPManager.Instance.MPRole);
StopMessageProcessingThread.Condition = false;
MPManager.Instance.IsProcessMessageThreadRunning = true;
while (!StopMessageProcessingThread.Condition)
{ // As long as the netServer is started
while ((msg = netServer.ReadMessage()) != null)
{
switch (msg.MessageType)
{
// Debuggen
#region Debug
case NetIncomingMessageType.VerboseDebugMessage:
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.WarningMessage:
case NetIncomingMessageType.ErrorMessage:
Log.Warning("DebugMessage: " + msg.ReadString());
break;
#endregion
// StatusChanged
#region NetIncomingMessageType.StatusChanged
case NetIncomingMessageType.StatusChanged:
NetConnectionStatus state = (NetConnectionStatus)msg.ReadByte();
if (state == NetConnectionStatus.Connected)
{
OnClientConnected(new ReceivedMessageEventArgs(msg));
}
else if (state == NetConnectionStatus.Disconnected || state == NetConnectionStatus.Disconnecting)
{
OnClientDisconnected(new ReceivedMessageEventArgs(msg));
if (netServer.ConnectionsCount == 0)
{
OnAllClientsDisconnected(new ReceivedMessageEventArgs(msg));
}
}
break;
#endregion
// If the message contains data
#region NetIncomingMessageType.Data
case NetIncomingMessageType.Data:
Log.Message("Server Incoming Message Data.");
int type = msg.ReadInt32();
Log.Message("Type: " + type + "; MPMessageType: " + (MPMessageType)type);
ProgressData((MPMessageType)type, msg); //Test
break;
#endregion
// Connectionapproval
#region NetIncomingMessageType.ConnectionApproval
case NetIncomingMessageType.ConnectionApproval:
// Connection logic. Is the user allowed to connect
// Receive information to process
string sentPassword = msg.ReadString();
string sentUsername = msg.ReadString();
int sentEnabledModCount = msg.ReadInt32();
if (netServer.ConnectionsCount <= ServerMaximumPlayerAmount)
{ // Check if server is full
Log.Warning(String.Format("User ({0}) trying to connect. Sent password: {1}", sentUsername, sentPassword));
if (ServerPassword == sentPassword)
{ // Password is the same
if (PluginManager.instance.enabledModCount == sentEnabledModCount)
{ // The client and server have the same amount of mods enabled
msg.SenderConnection.Approve();
OnClientConnectionRequestApproved(new ConnectionRequestEventArgs(msg, "User accepted", sentUsername, sentPassword));
}
else
{
msg.SenderConnection.Deny();
OnClientConenctionRequestDenied(new ConnectionRequestEventArgs(msg, String.Format("Denied: Different amount of mods activated. User: {0}; Server: {1}", sentEnabledModCount, PluginManager.instance.enabledModCount), sentUsername, sentPassword));
}
}
else
{
msg.SenderConnection.Deny();
OnClientConenctionRequestDenied(new ConnectionRequestEventArgs(msg, "Denied: Wrong password.", sentUsername, sentPassword));
}
}
else
{
msg.SenderConnection.Deny();
OnClientConenctionRequestDenied(new ConnectionRequestEventArgs(msg, "Denied: Game is full/Cannot accept any more connections.", sentUsername, sentPassword));
}
break;
#endregion
default:
OnReceivedUnhandledMessage(new ReceivedUnhandledMessageEventArgs(msg, msg.MessageType.ToString()));
break;
}
}
}
}
catch (NetException ex)
{
throw new MPException("NetException (Lidgren) in Server.ProcessMessage. Message: " + ex.ToString(), ex);
}
catch (Exception ex)
{
throw new MPException("Exception in Server.ProcessMessage(). Message: " + ex.ToString(), ex);
}
finally
{
IsServerStarted = false;
StopMessageProcessingThread.Condition = false;
OnServerLeavingProcessingMessageThread(new EventArgs());
}
}
static void Main(string[] args)
{
// Create new instance of configs. Parameter is "application Id". It has to be same on client and server.
Config = new NetPeerConfiguration("game");
// Set server port
Config.Port = 14242;
// Max client amount
Config.MaximumConnections = 200;
// Enable New messagetype. Explained later
Config.EnableMessageType(NetIncomingMessageType.ConnectionApproval);
// Create new server based on the configs just defined
Server = new NetServer(Config);
// Start it
Server.Start();
// Eh..
Console.WriteLine("Server Started");
// Create list of "Characters" ( defined later in code ). This list holds the world state. Character positions
List<Character> GameWorldState = new List<Character>();
// Object that can be used to store and read messages
NetIncomingMessage inc;
// Check time
DateTime time = DateTime.Now;
// Create timespan of 30ms
TimeSpan timetopass = new TimeSpan(0, 0, 0, 0, 30);
// Write to con..
Console.WriteLine("Waiting for new connections and updateing world state to current ones");
// Main loop
// This kind of loop can't be made in XNA. In there, its basically same, but without while
// Or maybe it could be while(new messages)
while (true)
{
// Server.ReadMessage() Returns new messages, that have not yet been read.
// If "inc" is null -> ReadMessage returned null -> Its null, so dont do this :)
if ((inc = Server.ReadMessage()) != null)
{
// Theres few different types of messages. To simplify this process, i left only 2 of em here
switch (inc.MessageType)
{
// If incoming message is Request for connection approval
// This is the very first packet/message that is sent from client
// Here you can do new player initialisation stuff
case NetIncomingMessageType.ConnectionApproval:
// Read the first byte of the packet
// ( Enums can be casted to bytes, so it be used to make bytes human readable )
if (inc.ReadByte() == (byte)PacketTypes.LOGIN)
{
Console.WriteLine("Incoming LOGIN");
// Approve clients connection ( Its sort of agreenment. "You can be my client and i will host you" )
inc.SenderConnection.Approve();
// Init random
Random r = new Random();
// Add new character to the game.
// It adds new player to the list and stores name, ( that was sent from the client )
// Random x, y and stores client IP+Port
GameWorldState.Add(new Character(inc.ReadString(), r.Next(1, 40), r.Next(1, 20),inc.SenderConnection));
// Create message, that can be written and sent
NetOutgoingMessage outmsg = Server.CreateMessage();
// first we write byte
outmsg.Write((byte)PacketTypes.WORLDSTATE);
// then int
outmsg.Write(GameWorldState.Count);
// iterate trought every character ingame
foreach (Character ch in GameWorldState)
{
// This is handy method
// It writes all the properties of object to the packet
outmsg.WriteAllProperties(ch);
}
// Now, packet contains:
// Byte = packet type
// Int = how many players there is in game
// character object * how many players is in game
// Send message/packet to all connections, in reliably order, channel 0
// Reliably means, that each packet arrives in same order they were sent. Its slower than unreliable, but easyest to understand
Server.SendMessage(outmsg, inc.SenderConnection, NetDeliveryMethod.ReliableOrdered, 0);
// Debug
Console.WriteLine("Approved new connection and updated the world status");
}
break;
// Data type is all messages manually sent from client
// ( Approval is automated process )
case NetIncomingMessageType.Data:
// Read first byte
if (inc.ReadByte() == (byte)PacketTypes.MOVE)
{
// Check who sent the message
// This way we know, what character belongs to message sender
foreach (Character ch in GameWorldState)
{
// If stored connection ( check approved message. We stored ip+port there, to character obj )
// Find the correct character
if (ch.Connection != inc.SenderConnection)
continue;
// Read next byte
byte b = inc.ReadByte();
// Handle movement. This byte should correspond to some direction
if ((byte)MoveDirection.UP == b)
ch.Y--;
if ((byte)MoveDirection.DOWN == b)
ch.Y++;
if ((byte)MoveDirection.LEFT == b)
ch.X--;
if ((byte)MoveDirection.RIGHT == b)
ch.X++;
// Create new message
NetOutgoingMessage outmsg = Server.CreateMessage();
// Write byte, that is type of world state
outmsg.Write((byte)PacketTypes.WORLDSTATE);
// Write int, "how many players in game?"
outmsg.Write(GameWorldState.Count);
// Iterate throught all the players in game
foreach (Character ch2 in GameWorldState)
{
// Write all the properties of object to message
outmsg.WriteAllProperties(ch2);
}
// Message contains
// Byte = PacketType
// Int = Player count
// Character obj * Player count
// Send messsage to clients ( All connections, in reliable order, channel 0)
Server.SendMessage(outmsg, Server.Connections, NetDeliveryMethod.ReliableOrdered, 0);
break;
}
}
break;
case NetIncomingMessageType.StatusChanged:
// In case status changed
// It can be one of these
// NetConnectionStatus.Connected;
// NetConnectionStatus.Connecting;
// NetConnectionStatus.Disconnected;
// NetConnectionStatus.Disconnecting;
// NetConnectionStatus.None;
// NOTE: Disconnecting and Disconnected are not instant unless client is shutdown with disconnect()
Console.WriteLine(inc.SenderConnection.ToString() + " status changed. " + (NetConnectionStatus)inc.SenderConnection.Status);
if (inc.SenderConnection.Status == NetConnectionStatus.Disconnected || inc.SenderConnection.Status == NetConnectionStatus.Disconnecting)
{
// Find disconnected character and remove it
foreach (Character cha in GameWorldState)
{
if (cha.Connection == inc.SenderConnection)
{
GameWorldState.Remove(cha);
break;
}
}
}
break;
default:
// As i statet previously, theres few other kind of messages also, but i dont cover those in this example
// Uncommenting next line, informs you, when ever some other kind of message is received
//Console.WriteLine("Not Important Message");
break;
}
} // If New messages
// if 30ms has passed
if ((time + timetopass) < DateTime.Now)
{
// If there is even 1 client
if (Server.ConnectionsCount != 0)
{
// Create new message
NetOutgoingMessage outmsg = Server.CreateMessage();
// Write byte
outmsg.Write((byte)PacketTypes.WORLDSTATE);
// Write Int
outmsg.Write(GameWorldState.Count);
// Iterate throught all the players in game
foreach (Character ch2 in GameWorldState)
{
// Write all properties of character, to the message
outmsg.WriteAllProperties(ch2);
}
// Message contains
// byte = Type
// Int = Player count
// Character obj * Player count
// Send messsage to clients ( All connections, in reliable order, channel 0)
Server.SendMessage(outmsg, Server.Connections, NetDeliveryMethod.ReliableOrdered, 0);
}
// Update current time
time = DateTime.Now;
}
// While loops run as fast as your computer lets. While(true) can lock your computer up. Even 1ms sleep, lets other programs have piece of your CPU time
//System.Threading.Thread.Sleep(1);
}
}
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");
}
static void Main(string[] args)
{
Config = new NetPeerConfiguration("pokemon");
Config.Port = 7377;
Config.MaximumConnections = 20;
Config.EnableMessageType(NetIncomingMessageType.ConnectionApproval);
Server = new NetServer(Config);
Server.Start();
Console.WriteLine("time to own");
/*/Creating a ContentManager to load maps from XML
Form form = new Form();
GraphicsDeviceService gds = GraphicsDeviceService.AddRef(form.Handle,
form.ClientSize.Width, form.ClientSize.Height);
ServiceContainer services = new ServiceContainer();
services.AddService<IGraphicsDeviceService>(gds);
content = new ContentManager(services, "Content");*/
//Initialize all the maps here
List<PlayerPrimitive> Players = new List<PlayerPrimitive>();
ServerNPCController = new NPCController();
NPC npc = new NPC(null, new Vector2(15, 15), 2);
ServerNPCController.addNPC(npc);
NetIncomingMessage nic;
DateTime time = DateTime.Now;
TimeSpan updateSpan = new TimeSpan(0, 0, 0, 0, 30);
Console.WriteLine("Waiting for players to join...");
while (true)
{
if ((nic = Server.ReadMessage()) != null)
{
switch (nic.MessageType)
{
case NetIncomingMessageType.ConnectionApproval :
if (nic.ReadByte() == (byte)PacketTypes.Login)
{
Console.WriteLine("New Player joining.");
nic.SenderConnection.Approve();
PlayerPrimitive prim = DataReadWrite.ReadPlayer(nic);
prim.Connection = nic.SenderConnection;
Players.Add(prim);
Console.WriteLine("The following players are in:");
foreach (PlayerPrimitive player in Players)
{
Console.WriteLine(player.Name + " joined " + System.DateTime.Now);
Console.WriteLine(player.UniqueId);
}
NetOutgoingMessage outmsg = Server.CreateMessage();
outmsg.Write((byte)PacketTypes.WorldState);
outmsg.Write(Players.Count);
foreach (PlayerPrimitive player in Players)
{
outmsg.WriteAllProperties(player);
}
Server.SendMessage(outmsg, nic.SenderConnection, NetDeliveryMethod.ReliableOrdered, 0);
Console.WriteLine("New player has joined, server updated and shit.");
}
break;
case NetIncomingMessageType.Data :
if (nic.ReadByte() == (byte)PacketTypes.Move)
{
foreach (PlayerPrimitive player in Players)
{
if (player.Connection != nic.SenderConnection)
continue;
Vector2 position = XNAExtensions.ReadVector2(nic);
bool running = nic.ReadBoolean();
player.X = (int)position.X;
player.Y = (int)position.Y;
player.IsRunning = running;
Console.WriteLine(player.Name + " position: " + player.X + ", " + player.Y + ": running = " + running);
/*NetOutgoingMessage outmsg = Server.CreateMessage();
outmsg.Write((byte)PacketTypes.WorldState);
outmsg.Write(Players.Count);
foreach (PlayerPrimitive playa in Players)
outmsg.WriteAllProperties(playa);
Server.SendMessage(outmsg, Server.Connections, NetDeliveryMethod.ReliableOrdered, 0);*/
break;
}
}
break;
case NetIncomingMessageType.StatusChanged :
Console.WriteLine(nic.SenderConnection.ToString() + " status changed." + (NetConnectionStatus)nic.SenderConnection.Status);
if (nic.SenderConnection.Status == NetConnectionStatus.Disconnected ||
nic.SenderConnection.Status == NetConnectionStatus.Disconnecting)
{
foreach (PlayerPrimitive player in Players)
{
if (player.Connection == nic.SenderConnection)
{
Players.Remove(player);
Console.WriteLine(player.Name + " left the game " + System.DateTime.Now);
break;
}
}
}
break;
default :
Console.WriteLine("Message type is: " + nic.MessageType);
break;
}
}
if ((time + updateSpan) < DateTime.Now)
{
ServerNPCController.UpdateNPCs(updateSpan);
if (Server.ConnectionsCount > 0)
{
NetOutgoingMessage outmsg = Server.CreateMessage();
outmsg.Write((byte)PacketTypes.WorldState);
outmsg.Write(Players.Count);
outmsg.Write(ServerNPCController.NPCs.Count);
foreach (PlayerPrimitive player in Players)
outmsg.WriteAllProperties(player);
foreach (NPC nerdo in ServerNPCController.NPCs)
outmsg.WriteAllProperties(nerdo.toPrimitive());
Server.SendMessage(outmsg, Server.Connections, NetDeliveryMethod.ReliableOrdered, 0);
}
time = DateTime.Now;
}
System.Threading.Thread.Sleep(1);
}
}
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");
}
private static void Main()
{
var config = new NetPeerConfiguration("pic")
{
Port = 666,
EnableUPnP = true,
MaximumConnections = 50,
ConnectionTimeout = 5f
};
config.EnableMessageType(NetIncomingMessageType.ConnectionApproval);
_server = new NetServer(config);
RoundTimer.Elapsed += roundTimer_Elapsed;
_server.Start();
_server.UPnP.ForwardPort(666, "Pictionary");
Console.WriteLine(@"Pictionary Server Started");
long timeToRun;
int loadedWords = LoadWords("list.txt", out _wordList, out timeToRun);
Console.WriteLine("Loaded {0} words into the Word list taking {1} ms to run", loadedWords, timeToRun);
loadedWords = LoadWords("badwords.txt", out _badwordList, out timeToRun);
Console.WriteLine("Loaded {0} words into the Bad word list taking {1} ms to run", loadedWords, timeToRun);
NetIncomingMessage inc; // Incoming Message
while (true)
{
if ((inc = _server.ReadMessage()) == null) continue;
HandleMessage(inc, _server);
}
// ReSharper disable once FunctionNeverReturns
}
static void Main(string[] args)
{
IPEndPoint masterServerEndpoint = NetUtility.Resolve("localhost", CommonConstants.MasterServerPort);
NetPeerConfiguration config = new NetPeerConfiguration("game");
config.SetMessageTypeEnabled(NetIncomingMessageType.NatIntroductionSuccess, true);
config.Port = 14242;
NetServer server = new NetServer(config);
server.Start();
Console.WriteLine("Server started; waiting 5 seconds...");
System.Threading.Thread.Sleep(5000);
var lastRegistered = -60.0f;
while(Console.KeyAvailable == false || Console.ReadKey().Key != ConsoleKey.Escape)
{
// (re-)register periodically with master server
if (NetTime.Now > lastRegistered + 60)
{
// register with master server
NetOutgoingMessage regMsg = server.CreateMessage();
regMsg.Write((byte)MasterServerMessageType.RegisterHost);
IPAddress mask;
IPAddress adr = NetUtility.GetMyAddress(out mask);
regMsg.Write(server.UniqueIdentifier);
regMsg.Write(new IPEndPoint(adr, 14242));
Console.WriteLine("Sending registration to master server");
server.SendUnconnectedMessage(regMsg, masterServerEndpoint);
lastRegistered = (float)NetTime.Now;
}
NetIncomingMessage inc;
while ((inc = server.ReadMessage()) != null)
{
switch (inc.MessageType)
{
case NetIncomingMessageType.VerboseDebugMessage:
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.WarningMessage:
case NetIncomingMessageType.ErrorMessage:
Console.WriteLine(inc.ReadString());
break;
case NetIncomingMessageType.Data:
// incoming chat message from a client
string chat = inc.ReadString();
Console.WriteLine(chat);
//Output("Broadcasting '" + chat + "'");
// broadcast this to all connections, except sender
List<NetConnection> all = server.Connections; // get copy
all.Remove(inc.SenderConnection);
if (all.Count > 0) {
NetOutgoingMessage om = server.CreateMessage();
om.Write(NetUtility.ToHexString(inc.SenderConnection.RemoteUniqueIdentifier) + " said: " + chat);
server.SendMessage(om, all, NetDeliveryMethod.ReliableOrdered, 0);
}
break;
}
}
System.Threading.Thread.Sleep(1);
}
Console.ReadKey();
}
/// <summary>
///
/// </summary>
/// <param name="message"></param>
void DispatchIM ( GameTime gameTime, SnapshotQueue queue, NetServer server )
{
NetIncomingMessage msg;
while ((msg = server.ReadMessage()) != null)
{
switch (msg.MessageType)
{
case NetIncomingMessageType.VerboseDebugMessage:Log.Debug ("SV Net: " + msg.ReadString()); break;
case NetIncomingMessageType.DebugMessage: Log.Verbose ("SV Net: " + msg.ReadString()); break;
case NetIncomingMessageType.WarningMessage: Log.Warning ("SV Net: " + msg.ReadString()); break;
case NetIncomingMessageType.ErrorMessage: Log.Error ("SV Net: " + msg.ReadString()); break;
case NetIncomingMessageType.ConnectionLatencyUpdated:
if (Game.Network.ShowLatency) {
float latency = msg.ReadFloat();
Log.Verbose("...SV ping - {0} {1,6:0.00} ms", msg.SenderEndPoint, (latency*1000) );
}
break;
case NetIncomingMessageType.DiscoveryRequest:
Log.Message("Discovery request from {0}", msg.SenderEndPoint.ToString() );
var response = server.CreateMessage( ServerInfo() );
server.SendDiscoveryResponse( response, msg.SenderEndPoint );
break;
case NetIncomingMessageType.ConnectionApproval:
var userGuid = msg.SenderConnection.GetHailGuid();
var userInfo = msg.SenderConnection.GetHailUserInfo();
var reason = "";
var approve = ApproveClient( userGuid, userInfo, out reason );
if (approve) {
msg.SenderConnection.Approve( server.CreateMessage( ServerInfo() ) );
} else {
msg.SenderConnection.Deny( reason );
}
break;
case NetIncomingMessageType.StatusChanged:
DispatchStatusChange( msg );
break;
case NetIncomingMessageType.Data:
DispatchDataIM( gameTime, queue, msg );
break;
default:
Log.Warning("SV: Unhandled type: " + msg.MessageType);
break;
}
server.Recycle(msg);
}
}
public static void Run()
{
// initialize
int mapDimension = 16;
Map mapServer = Map.GenerateShipsOnMap(new Map(mapDimension));
Map mapHuman = Map.GenerateShipsOnMap(new Map(mapDimension));
Player playerServer = new Player("Server", mapServer); // non-player-character ie our server
Player playerHuman = new Player("Human", mapHuman); // player character
int currentRound = 0;
ArrayList sequences = initSequenceList("Scripts");
NetPeerConfiguration config = new NetPeerConfiguration("xnaapp");
config.EnableMessageType(NetIncomingMessageType.DiscoveryRequest);
config.Port = 14242;
// create and start server
NetServer server = new NetServer(config);
try
{
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!");
// create new player object
// initialize new game
//playerServer.startGame();
//playerHuman.startGame();
}
break;
case NetIncomingMessageType.Data:
String responseString = "Nothing happend";
// player round
// The client sent input to the server
String sequenceName = msg.ReadString();
int round = msg.ReadInt32();
if (round > currentRound)
{
currentRound = round;
if (sequences.Contains(sequenceName))
{
// choose and fire sequence
var executer = new SequenceExecuter(playerServer.map);
var resultMessagePlayer = executer.LoadScript(sequenceName);
// switch round to npc
// fire random sequence
int randomIndex = RandomNumber(0, sequences.Count);
sequenceName = (String)sequences[randomIndex];
executer = new SequenceExecuter(playerHuman.map);
var resultMessageNPC = executer.LoadScript(sequenceName);
// send response to client
String battlefield = Battlefield.Draw(playerHuman, playerServer);
responseString = "Player: " + resultMessagePlayer + "\n" + battlefield + " \nComputer: " + resultMessageNPC;
} else {
responseString = "FireSequence not recognized!";
}
} else {
responseString = "Game round invalid";
}
NetOutgoingMessage om = server.CreateMessage();
om.Write(responseString);
// send to every player, which is only one in our case
foreach (NetConnection player in server.Connections)
{
server.SendMessage(om, player, NetDeliveryMethod.Unreliable);
}
break;
} // switch messageType
} // while readMessage
// sleep to allow other processes to run smoothly
Thread.Sleep(1);
} // while thread
}
catch (SocketException ex)
{
System.Console.WriteLine("Socket could not be initiated, is the port already used?!");
System.Windows.Forms.MessageBox.Show("Socket could not be initiated, is the port already used?!",
"September 1983 Server");
}
}
static void Main(string[] args)
{
Globals.Init();
server = new NetServer(Globals.config);
WriteLine("Building Map");
WriteLine("Server Starting");
server.Start();
while (true)
{
while (server.MessageAvailable)
{
NetIncomingMessage msg = server.ReadMessage();
switch (msg.MessageType)
{
case NetIncomingMessageType.VerboseDebugMessage:
case NetIncomingMessageType.WarningMessage:
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.ErrorMessage:
WriteLine(msg.ReadString());
break;
case NetIncomingMessageType.Data:
string netStr = msg.ReadString();
switch (netStr.Substring(0, 4))
{
case "NICK":
string newNick = netStr.Substring(4);
string str1 = " : " + GetPlayerNick(msg.SenderConnection) + " : Changed there Nickname to " + newNick;
WriteLine(newNick + str1);
if (Connections.Count > 0)
{
for (int i = 0; i < Connections.Count; i++)
{
if (Connections[i].Connection == msg.SenderConnection)
{
Player update = Connections[i];
update.Name = newNick;
Connections[i] = update;
}
}
}
SendToAll("[Server]", str1);
break;
case "SAY ":
string nick = GetPlayerNick(msg.SenderConnection);
string str = netStr.Substring(4);
WriteLine(nick + " : " + str);
SendToAll(nick, str);
break;
case "PRIV":
netStr = netStr.Substring(5);
string nickname = netStr.Substring(0, netStr.IndexOf(' '));
NetOutgoingMessage msg3 = server.CreateMessage();
NetConnection conn = GetPlayerConn(nickname);
if (conn != null)
{
msg3.Write("PRIV");
msg3.Write(GetPlayerNick(msg.SenderConnection));
msg3.Write(netStr.Substring(nickname.Length));
server.SendMessage(msg3, conn, NetDeliveryMethod.ReliableOrdered, 0);
}
break;
case "JOIN":
string game = netStr.Substring(5);
Player gamePlayer = GetPlayer(msg.SenderConnection);
string pnick = gamePlayer.Name;
WriteLine(pnick + " Joining : " + game);
NetOutgoingMessage msg4 = server.CreateMessage();
msg4.Write("GAMEJOIN");
Game playerGame = GetGame(game);
if (playerGame == null)
{
playerGame = new Game(game);
Games.Add(playerGame);
}
msg4.Write(game);
playerGame.Players.Add(gamePlayer);
playerGame.CurrentMap.GenerateMapPacket(msg4);
gamePlayer.Resources = 10000;
server.SendMessage(msg4, msg.SenderConnection, NetDeliveryMethod.ReliableOrdered, 0);
break;
default:
NetOutgoingMessage msg2 = server.CreateMessage();
msg2.Write("[Server] : Server Command not Found, You Wrote : " + netStr);
msg.SenderConnection.SendMessage(msg2, NetDeliveryMethod.ReliableOrdered);
break;
}
break;
case NetIncomingMessageType.StatusChanged:
ReadStatus(msg);
break;
case NetIncomingMessageType.ConnectionApproval:
WriteLine("New Client Connected from : " + msg.SenderEndpoint.ToString());
msg.SenderConnection.Approve();
SendToAll("[Server]", "New Client Connected");
Connections.Add(new Player("Player", msg.SenderConnection));
//SendFile("server_file.bin", msg.SenderConnection);
break;
default:
WriteLine("Can Not Pause Message Type: " + msg.MessageType.ToString());
break;
}
}
Thread.Sleep(10);
}
}
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");
}
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");
}
static void Main( string[] args )
{
// Generate a Profile object. When this project is near the end of its development,
// we will need to remove the leading "..\\"'s from this file path.
if ( File.Exists("Profile.txt"))
{
Profile = new tvProfile("Profile.txt", false);
}
// If it doesn't exist locally, use the embedded one.
else
{
// Ensure that the pack scheme is known: http://stackoverflow.com/questions/6005398/uriformatexception-invalid-uri-invalid-port-specified
string ensurePackSchemeIsKnown = PackUriHelper.UriSchemePack;
StreamResourceInfo stream = Application.GetResourceStream(new Uri(PATH_TO_PROFILE, UriKind.Absolute));
StreamReader reader = new StreamReader(stream.Stream);
Profile = new tvProfile(reader.ReadToEnd());
}
// Create a new deck.
Deck = new Deck(Profile);
// Create a new list of players.
PlayerList = new List<Player>();
// Create a new Dicard Pile.
DiscardPile = new List<Card>();
// Create new instance of configs. Parameter is "application Id". It has to be same on client and server.
Config = new NetPeerConfiguration("game");
// Set server port
Config.Port = ServerUtilities.PORT_NUMBER;
// Max client amount
Config.MaximumConnections = 200;
// Enable New messagetype. Explained later
Config.EnableMessageType(NetIncomingMessageType.ConnectionApproval);
// Create new server based on the configs just defined
Server = new NetServer(Config);
// Start it
Server.Start();
// Eh..
Console.WriteLine("Server Started");
// Object that can be used to store and read messages
NetIncomingMessage inc;
// Check time
DateTime time = DateTime.Now;
// Create timespan of 30ms
TimeSpan timetopass = new TimeSpan(0, 0, 0, 0, 30);
// Write to con..
Console.WriteLine("Waiting for new connections");
// Main loop
// This kind of loop can't be made in XNA. In there, its basically same, but without while
// Or maybe it could be while(new messages)
while ( true )
{
// Server.ReadMessage() Returns new messages, that have not yet been read.
// If "inc" is null -> ReadMessage returned null -> Its null, so dont do this :)
if ( (inc = Server.ReadMessage()) != null )
{
// Theres few different types of messages. To simplify this process, i left only 2 of em here
switch ( inc.MessageType )
{
// If incoming message is Request for connection approval
// This is the very first packet/message that is sent from client
// Here you can do new player initialisation stuff
case NetIncomingMessageType.ConnectionApproval:
{
// Read the first byte of the packet
// ( Enums can be casted to bytes, so it be used to make bytes human readable )
if ( inc.ReadByte() == (byte)PacketTypes.LOGIN )
{
Console.WriteLine("Incoming LOGIN");
// Approve clients connection ( Its sort of agreenment. "You can be my client and i will host you" )
inc.SenderConnection.Approve();
// Debug
Console.WriteLine("Approved new connection and updated the world status");
}
break;
}
// All messages manually sent from clients are considered "Data" messages.
// ( Approval is an automated process )
case NetIncomingMessageType.Data:
{
Datatype messageType = (Datatype)inc.ReadByte();
switch ( messageType )
{
// Receive an updated Deck from a client.
case Datatype.UpdateDeck:
{
Deck = (Deck)ServerUtilities.ReceiveMessage(inc, messageType);
if ( Server.ConnectionsCount != 0 )
{
ServerUtilities.SendMessage(Server, Datatype.UpdateDeck, Deck);
}
break;
}
// Receive an updated DiscardPile from a client.
case Datatype.UpdateDiscardPile:
{
DiscardPile = (List<Card>)ServerUtilities.ReceiveMessage(inc, messageType);
// Send the updated DiscardPile to all clients.
if ( Server.ConnectionsCount != 0 )
{
ServerUtilities.SendMessage(Server, Datatype.UpdateDiscardPile, DiscardPile);
}
break;
}
// Add or modify a player in the PlayerList.
case Datatype.UpdatePlayer:
{
Player updatedPlayer = (Player)ServerUtilities.ReceiveMessage(inc, messageType);
bool isPlayerInList = false;
// If the updated Player is already in the server's list, update that's Player's properties.
// Note: This search only works if players have unique names.
foreach ( Player player in PlayerList )
{
if ( updatedPlayer.Name == player.Name )
{
player.CardsInHand = updatedPlayer.CardsInHand;
player.CardsInPlay = updatedPlayer.CardsInPlay;
isPlayerInList = true;
break;
}
}
// If the Player is not on the list, add it.
if ( !isPlayerInList )
{
PlayerList.Add(updatedPlayer);
}
// Send the updated PlayerList to all clients.
if ( Server.ConnectionsCount != 0 )
{
ServerUtilities.SendMessage(Server, Datatype.UpdatePlayerList, PlayerList);
}
break;
}
// Update the server's Player List and send it to the clients.
case Datatype.UpdatePlayerList:
{
PlayerList = (List<Player>)ServerUtilities.ReceiveMessage(inc, messageType);
if ( Server.ConnectionsCount != 0 )
{
ServerUtilities.SendMessage(Server, Datatype.UpdatePlayerList, PlayerList);
}
break;
}
// Send the updated turn to all players.
case Datatype.UpdateTurn:
{
Turn = (Turn)ServerUtilities.ReceiveMessage(inc, messageType);
if ( Server.ConnectionsCount != 0 )
{
ServerUtilities.SendMessage(Server, Datatype.UpdateTurn, Turn);
}
break;
}
// Set up the players for the game. This case should be hit only when a client launches the game.
case Datatype.LaunchGame:
{
// Deal the initial hands to the players.
for ( int i = 0; i < PlayerList.Count; ++i )
{
PlayerList[i] = new Player(Deck, PlayerList[i].Name);
}
//// Send the Player List to the clients.
//if ( Server.ConnectionsCount != 0 )
//{
// ServerUtilities.SendMessage(Server, Datatype.UpdatePlayerList, PlayerList);
//}
// Generate the Turn object to keep track of the current turn.
Turn = new Turn(PlayerList.Count);
// Tell all clients to launch the game and send them the Turn object.
if ( Server.ConnectionsCount != 0 )
{
ServerUtilities.SendMessage(Server, Datatype.LaunchGame, Turn);
}
break;
}
case Datatype.TimeToConnect:
{
string playerToConnect = (String)ServerUtilities.ReceiveMessage(inc, messageType);
// Broadcast a message that tells a specific client to launch the game.
if ( Server.ConnectionsCount != 0 )
{
ServerUtilities.SendMessage(Server, Datatype.TimeToConnect, playerToConnect);
}
break;
}
// Send the rent request to all clients.
case Datatype.RequestRent:
{
ActionData.RentRequest request = (ActionData.RentRequest)ServerUtilities.ReadRentRequest(inc);
if ( Server.ConnectionsCount != 0 )
{
ServerUtilities.SendMessage(Server, Datatype.RequestRent, request);
}
break;
}
// Send the rent response to all clients.
case Datatype.GiveRent:
{
ActionData.RentResponse response = (ActionData.RentResponse)ServerUtilities.ReadRentResponse(inc);
if ( Server.ConnectionsCount != 0 )
{
ServerUtilities.SendMessage(Server, Datatype.GiveRent, response);
}
break;
}
// Send the theft request to all clients.
case Datatype.RequestTheft:
{
ActionData.TheftRequest request = (ActionData.TheftRequest)ServerUtilities.ReadTheftRequest(inc);
if ( Server.ConnectionsCount != 0 )
{
ServerUtilities.SendMessage(Server, Datatype.RequestTheft, request);
}
break;
}
// Send the theft response to all clients.
case Datatype.ReplyToTheft:
{
ActionData.TheftResponse response = (ActionData.TheftResponse)ServerUtilities.ReadTheftResponse(inc);
if ( Server.ConnectionsCount != 0 )
{
ServerUtilities.SendMessage(Server, Datatype.ReplyToTheft, response);
}
break;
}
case Datatype.EndTurn:
{
Turn = (Turn)ServerUtilities.ReceiveMessage(inc, Datatype.EndTurn);
// Send the updated Turn object to the clients.
ServerUtilities.SendMessage(Server, Datatype.EndTurn, Turn);
break;
}
// Send the server's Deck to all clients.
case Datatype.RequestDeck:
{
if ( Server.ConnectionsCount != 0 )
{
ServerUtilities.SendMessage(Server, Datatype.UpdateDeck, Deck);
}
break;
}
// Send the server's PlayerList to all clients.
case Datatype.RequestPlayerList:
{
if ( Server.ConnectionsCount != 0 )
{
ServerUtilities.SendMessage(Server, Datatype.UpdatePlayerList, PlayerList);
}
break;
}
}
break;
}
case NetIncomingMessageType.StatusChanged:
{
// In case status changed
// It can be one of these
// NetConnectionStatus.Connected;
// NetConnectionStatus.Connecting;
// NetConnectionStatus.Disconnected;
// NetConnectionStatus.Disconnecting;
// NetConnectionStatus.None;
// NOTE: Disconnecting and Disconnected are not instant unless client is shutdown with disconnect()
Console.WriteLine(inc.SenderConnection.ToString() + " status changed. " + (NetConnectionStatus)inc.SenderConnection.Status);
if ( inc.SenderConnection.Status == NetConnectionStatus.Disconnected || inc.SenderConnection.Status == NetConnectionStatus.Disconnecting )
{
}
break;
}
default:
{
// As i statet previously, theres few other kind of messages also, but i dont cover those in this example
// Uncommenting next line, informs you, when ever some other kind of message is received
//Console.WriteLine("Not Important Message");
break;
}
}
} // If New messages
// if 30ms has passed
if ( (time + timetopass) < DateTime.Now )
{
time = DateTime.Now;
}
// While loops run as fast as your computer lets. While(true) can lock your computer up. Even 1ms sleep, lets other programs have piece of your CPU time
System.Threading.Thread.Sleep(100);
}
}
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");
}
private void MGServer_DoWork (object sender, DoWorkEventArgs e)
{
BackgroundWorker worker = sender as BackgroundWorker;
NetPeerConfiguration config = new NetPeerConfiguration (applicationIdentifier);
config.EnableMessageType (NetIncomingMessageType.DiscoveryRequest);
config.EnableMessageType (NetIncomingMessageType.DiscoveryResponse);
config.EnableMessageType (NetIncomingMessageType.NatIntroductionSuccess);
if (availableSession == null)
config.Port = port;
// create and start server
peer = new NetServer (config);
peer.Start ();
myLocalAddress = GetMyLocalIpAddress ();
IPAddress adr = IPAddress.Parse (myLocalAddress);
myLocalEndPoint = new IPEndPoint (adr, port);
// force a little wait until we have a LocalGamer otherwise things
// break. This is the first item in the queue so it shouldnt take long before we
// can continue.
while (session.LocalGamers.Count <= 0)
{
Thread.Sleep(10);
}
if (availableSession != null) {
if (!this.online) {
peer.Connect (availableSession.EndPoint);
} else {
RequestNATIntroduction (availableSession.EndPoint, peer);
}
} else {
if (this.online) {
IPAddress ipaddr = NetUtility.Resolve (masterServer);
if (ipaddr != null) {
m_masterServer = new IPEndPoint (ipaddr, masterserverport);
LocalNetworkGamer localMe = session.LocalGamers [0];
NetOutgoingMessage om = peer.CreateMessage ();
om.Write ((byte)0);
om.Write (session.AllGamers.Count);
om.Write (localMe.Gamertag);
om.Write (session.PrivateGamerSlots);
om.Write (session.MaxGamers);
om.Write (localMe.IsHost);
om.Write (myLocalEndPoint);
om.Write (peer.Configuration.AppIdentifier);
// send up session properties
int[] propertyData = new int[session.SessionProperties.Count * 2];
NetworkSessionProperties.WriteProperties (session.SessionProperties, propertyData);
for (int x = 0; x < propertyData.Length; x++) {
om.Write (propertyData [x]);
}
peer.SendUnconnectedMessage (om, m_masterServer); // send message to peer
} else {
throw new Exception ("Could not resolve live host");
}
}
}
// run until we are done
do {
NetIncomingMessage msg;
while ((msg = peer.ReadMessage ()) != null) {
switch (msg.MessageType) {
case NetIncomingMessageType.UnconnectedData :
break;
case NetIncomingMessageType.NatIntroductionSuccess:
#if !WINDOWS_PHONE
Game.Instance.Log("NAT punch through OK " + msg.SenderEndpoint);
#endif
peer.Connect (msg.SenderEndpoint);
break;
case NetIncomingMessageType.DiscoveryRequest:
//
// Server received a discovery request from a client; send a discovery response (with no extra data attached)
//
// Get the primary local gamer
LocalNetworkGamer localMe = session.LocalGamers [0];
NetOutgoingMessage om = peer.CreateMessage ();
om.Write (session.RemoteGamers.Count);
om.Write (localMe.Gamertag);
om.Write (session.PrivateGamerSlots);
om.Write (session.MaxGamers);
om.Write (localMe.IsHost);
int[] propertyData = new int[session.SessionProperties.Count * 2];
NetworkSessionProperties.WriteProperties (session.SessionProperties, propertyData);
for (int x = 0; x < propertyData.Length; x++) {
om.Write (propertyData [x]);
}
peer.SendDiscoveryResponse (om, msg.SenderEndpoint);
break;
case NetIncomingMessageType.VerboseDebugMessage:
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.WarningMessage:
case NetIncomingMessageType.ErrorMessage:
//
// Just print diagnostic messages to console
//
#if !WINDOWS_PHONE
Game.Instance.Log(msg.ReadString());
#endif
break;
case NetIncomingMessageType.StatusChanged:
NetConnectionStatus status = (NetConnectionStatus)msg.ReadByte ();
if (status == NetConnectionStatus.Disconnected) {
#if !WINDOWS_PHONE
Game.Instance.Log(NetUtility.ToHexString(msg.SenderConnection.RemoteUniqueIdentifier) + " disconnected! from " + msg.SenderEndpoint);
#endif
CommandGamerLeft cgj = new CommandGamerLeft (msg.SenderConnection.RemoteUniqueIdentifier);
CommandEvent cmde = new CommandEvent (cgj);
session.commandQueue.Enqueue (cmde);
}
if (status == NetConnectionStatus.Connected) {
//
// A new player just connected!
//
if (!pendingGamers.ContainsKey (msg.SenderConnection.RemoteUniqueIdentifier)) {
#if !WINDOWS_PHONE
Game.Instance.Log(NetUtility.ToHexString(msg.SenderConnection.RemoteUniqueIdentifier) + " connected! from " + msg.SenderEndpoint);
#endif
pendingGamers.Add (msg.SenderConnection.RemoteUniqueIdentifier, msg.SenderConnection);
SendProfileRequest (msg.SenderConnection);
} else {
#if !WINDOWS_PHONE
Game.Instance.Log("Already have a connection for that user, this is probably due to both NAT intro requests working");
#endif
}
}
break;
case NetIncomingMessageType.Data:
NetworkMessageType mt = (NetworkMessageType)msg.ReadByte ();
switch (mt) {
case NetworkMessageType.Data:
byte[] data = new byte[msg.LengthBytes - 1];
msg.ReadBytes (data, 0, data.Length);
CommandEvent cme = new CommandEvent (new CommandReceiveData (msg.SenderConnection.RemoteUniqueIdentifier,
data));
session.commandQueue.Enqueue (cme);
break;
case NetworkMessageType.Introduction:
var introductionAddress = msg.ReadString ();
try {
IPEndPoint endPoint = ParseIPEndPoint (introductionAddress);
if (myLocalEndPoint.ToString () != endPoint.ToString () && !AlreadyConnected (endPoint)) {
#if !WINDOWS_PHONE
Game.Instance.Log("Received Introduction for: " + introductionAddress +
" and I am: " + myLocalEndPoint + " from: " + msg.SenderEndpoint);
#endif
peer.Connect (endPoint);
}
} catch (Exception exc) {
#if !WINDOWS_PHONE
Game.Instance.Log("Error parsing Introduction: " + introductionAddress + " : " + exc.Message);
#endif
}
break;
case NetworkMessageType.GamerProfile:
#if !WINDOWS_PHONE
Game.Instance.Log("Profile recieved from: " + NetUtility.ToHexString(msg.SenderConnection.RemoteUniqueIdentifier));
#endif
if (pendingGamers.ContainsKey (msg.SenderConnection.RemoteUniqueIdentifier)) {
pendingGamers.Remove (msg.SenderConnection.RemoteUniqueIdentifier);
msg.ReadInt32 ();
string gamerTag = msg.ReadString ();
msg.ReadInt32 ();
msg.ReadInt32 ();
GamerStates state = (GamerStates)msg.ReadInt32 ();
state &= ~GamerStates.Local;
CommandGamerJoined cgj = new CommandGamerJoined (msg.SenderConnection.RemoteUniqueIdentifier);
cgj.GamerTag = gamerTag;
cgj.State = state;
CommandEvent cmde = new CommandEvent (cgj);
session.commandQueue.Enqueue (cmde);
} else {
#if !WINDOWS_PHONE
Game.Instance.Log("We received a profile for an existing gamer. Need to update it.");
#endif
}
break;
case NetworkMessageType.RequestGamerProfile:
#if !WINDOWS_PHONE
Game.Instance.Log("Profile Request recieved from: " + msg.SenderEndpoint);
#endif
SendProfile (msg.SenderConnection);
break;
case NetworkMessageType.GamerStateChange:
GamerStates gamerstate = (GamerStates)msg.ReadInt32 ();
gamerstate &= ~GamerStates.Local;
#if !WINDOWS_PHONE
Game.Instance.Log("State Change from: " + msg.SenderEndpoint + " new State: " + gamerstate);
#endif
foreach (var gamer in session.RemoteGamers) {
if (gamer.RemoteUniqueIdentifier == msg.SenderConnection.RemoteUniqueIdentifier)
gamer.State = gamerstate;
}
break;
case NetworkMessageType.SessionStateChange:
NetworkSessionState sessionState = (NetworkSessionState)msg.ReadInt32 ();
foreach (var gamer in session.RemoteGamers) {
if (gamer.RemoteUniqueIdentifier == msg.SenderConnection.RemoteUniqueIdentifier) {
#if !WINDOWS_PHONE
Game.Instance.Log("Session State change from: " + NetUtility.ToHexString(msg.SenderConnection.RemoteUniqueIdentifier) +
" session is now: " + sessionState);
#endif
if (gamer.IsHost && sessionState == NetworkSessionState.Playing) {
session.StartGame ();
}
}
}
break;
}
break;
}
}
// sleep to allow other processes to run smoothly
// This may need to be changed depending on network throughput
Thread.Sleep (1);
if (worker.CancellationPending) {
#if !WINDOWS_PHONE
Game.Instance.Log("worker CancellationPending");
#endif
e.Cancel = true;
done = true;
}
} while (!done);
}
static void Main(string[] args)
{
var config = new NetPeerConfiguration("Battleship438")
{
Port = 14241,
MaximumConnections = 2,
ConnectionTimeout = 5
};
config.EnableMessageType(NetIncomingMessageType.ConnectionApproval);
config.EnableMessageType(NetIncomingMessageType.Data);
config.EnableMessageType(NetIncomingMessageType.StatusChanged);
config.EnableMessageType(NetIncomingMessageType.Receipt);
_server = new NetServer(config);
_server.Start();
Console.WriteLine("Server started...");
while (true)
{
NetIncomingMessage im;
while ((im = _server.ReadMessage()) != null)
{
switch (im.MessageType)
{
case NetIncomingMessageType.VerboseDebugMessage:
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.WarningMessage:
case NetIncomingMessageType.ErrorMessage:
Console.WriteLine(im.ReadString());
break;
case NetIncomingMessageType.StatusChanged:
Console.WriteLine("********" + NetIncomingMessageType.StatusChanged);
Console.WriteLine("SENDER STATUS: " + im.SenderConnection.Status);
switch ((NetConnectionStatus)im.ReadByte())
{
case NetConnectionStatus.Connected:
Console.WriteLine(NetConnectionStatus.Connected + " -- Adding PLAYER");
AddPlayer(im);
break;
case NetConnectionStatus.Disconnected:
Console.WriteLine("{0} Disconnected");
break;
case NetConnectionStatus.RespondedAwaitingApproval:
NetOutgoingMessage hailMessage = _server.CreateMessage("hail: APPROVE");
im.SenderConnection.Approve(hailMessage);
break;
}
break;
case NetIncomingMessageType.Error:
break;
case NetIncomingMessageType.UnconnectedData:
break;
case NetIncomingMessageType.ConnectionApproval:
Console.WriteLine("********" + NetIncomingMessageType.ConnectionApproval);
ConnectionApproval(im, _server);
break;
case NetIncomingMessageType.Data:
Console.WriteLine("********" + NetIncomingMessageType.Data);
var number = im.ReadInt32();
Console.WriteLine(number);
break;
case NetIncomingMessageType.Receipt:
Console.WriteLine("********" + NetIncomingMessageType.Receipt);
break;
case NetIncomingMessageType.DiscoveryRequest:
Console.WriteLine("********" + NetIncomingMessageType.DiscoveryRequest);
break;
case NetIncomingMessageType.DiscoveryResponse:
Console.WriteLine("********" + NetIncomingMessageType.DiscoveryResponse);
break;
case NetIncomingMessageType.NatIntroductionSuccess:
Console.WriteLine("********" + NetIncomingMessageType.NatIntroductionSuccess);
break;
case NetIncomingMessageType.ConnectionLatencyUpdated:
Console.WriteLine("********" + NetIncomingMessageType.ConnectionLatencyUpdated);
break;
default:
Console.WriteLine("default");
throw new ArgumentOutOfRangeException();
}
}
}
}
