private static void HandleMessage(NetIncomingMessage inc, NetServer server)
{
switch (inc.MessageType)
{
case NetIncomingMessageType.ConnectionApproval: //If ConnectionApproval request
if (inc.ReadByte() == (byte) PacketTypes.Headers.Login)
{
string username = inc.ReadString();
Console.WriteLine("New Login Request from: {0}", username);
if (username.Length > 1 & Players.Values.All(c => c.Name != username) &
!_badwordList.Contains(username, StringComparer.OrdinalIgnoreCase))
{
inc.SenderConnection.Approve();
NetOutgoingMessage connectedMessage = server.CreateMessage();
Thread.Sleep(500);
Console.WriteLine("Sending a ack to {0}", username);
connectedMessage.Write((byte) PacketTypes.Headers.LoggedIn);
connectedMessage.Write(true);
server.SendMessage(connectedMessage, inc.SenderConnection, NetDeliveryMethod.ReliableOrdered);
}
else
{
inc.SenderConnection.Deny("Bad Username");
}
}
break;
case NetIncomingMessageType.Data:
byte packetheader = inc.ReadByte();
HandleProtocol(inc, packetheader, server);
break;
case NetIncomingMessageType.StatusChanged:
Console.WriteLine(inc.SenderConnection + " status changed. " + inc.SenderConnection.Status);
if (inc.SenderConnection.Status == NetConnectionStatus.Disconnected)
{
Console.WriteLine("Player: {0} has disconnected",
Players[inc.SenderConnection.RemoteUniqueIdentifier].Name);
Players.Remove(inc.SenderConnection.RemoteUniqueIdentifier);
}
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(@"Auto Discovery Request");
server.SendDiscoveryResponse(discovermsg, inc.SenderEndPoint);
break;
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.ErrorMessage:
case NetIncomingMessageType.WarningMessage:
case NetIncomingMessageType.VerboseDebugMessage:
Console.WriteLine(@"---Debug---");
Console.WriteLine(inc.ReadString());
Console.WriteLine(@"---End---");
break;
}
}
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()
{
var connectedPlayers = 0;
var config = new NetPeerConfiguration("romero");
config.EnableMessageType(NetIncomingMessageType.DiscoveryRequest);
config.Port = 14242;
var PlayerNames = new Dictionary<long, string>();
//var xinput = 0;
//var yinput = 0;
var dummyName = string.Empty;
float angle = 0;
// create and start server
var server = new NetServer(config);
server.Start();
Console.WriteLine("Server online");
// schedule initial sending of position updates
var nextSendUpdates = NetTime.Now;
// run until escape is pressed
while (!Console.KeyAvailable || Console.ReadKey().Key != ConsoleKey.Escape)
{
NetIncomingMessage msg;
while ((msg = server.ReadMessage()) != null)
{
switch (msg.MessageType)
{
case NetIncomingMessageType.DiscoveryRequest:
//
// Server received a discovery request from a client; send a discovery response (with no extra data attached)
//
var om = server.CreateMessage();
if (connectedPlayers < 4)
{
om.Write(true);
server.SendDiscoveryResponse(om, msg.SenderEndpoint);
}
else
{
om.Write(false);
server.SendDiscoveryResponse(om, msg.SenderEndpoint);
}
break;
case NetIncomingMessageType.VerboseDebugMessage:
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.WarningMessage:
case NetIncomingMessageType.ErrorMessage:
//
// Just print diagnostic messages to console
//
Console.WriteLine(msg.ReadString());
break;
case NetIncomingMessageType.StatusChanged:
var status = (NetConnectionStatus)msg.ReadByte();
if (status == NetConnectionStatus.Connected)
{
//
// A new player just connected!
//
Console.WriteLine(msg.SenderConnection.RemoteUniqueIdentifier + " connected. (IP Address: " + msg.SenderEndpoint.Address + ")");
connectedPlayers++;
Console.WriteLine(connectedPlayers + " players ingame");
};
if (status == NetConnectionStatus.Disconnected)
{
Console.WriteLine(msg.SenderConnection.RemoteUniqueIdentifier + " disconnected. (IP Address: " + msg.SenderEndpoint.Address + ")");
connectedPlayers--;
Console.WriteLine(connectedPlayers + " players ingame");
}
break;
case NetIncomingMessageType.Data:
//
// The client sent input to the server
//
dummyName = msg.ReadString();
if (!PlayerNames.ContainsKey(msg.SenderConnection.RemoteUniqueIdentifier))
{
PlayerNames.Add(msg.SenderConnection.RemoteUniqueIdentifier, dummyName);
}
// fancy movement logic goes here
var xinput = msg.ReadInt32();
var yinput = msg.ReadInt32();
var playerAngle = msg.ReadFloat();
var pos = msg.SenderConnection.Tag as float[];
if (pos != null)
{
pos[0] = xinput;
pos[1] = yinput;
pos[2] = playerAngle;
}
break;
}
//
// send position updates 60 times per second
//
var now = NetTime.Now;
if (now > nextSendUpdates)
{
// Yes, it's time to send position updates
// for each player...
foreach (var player in server.Connections)
{
// ... send information about every other player (actually including self)
foreach (var otherPlayer in server.Connections)
{
// send position update about 'otherPlayer' to 'player'
var om = server.CreateMessage();
if (otherPlayer != null)
{
// write who this position is for
om.Write(otherPlayer.RemoteUniqueIdentifier);
if (PlayerNames.ContainsKey(otherPlayer.RemoteUniqueIdentifier))
{
om.Write(PlayerNames.Single(i => i.Key == otherPlayer.RemoteUniqueIdentifier).Value);
}
if (otherPlayer.Tag == null)
otherPlayer.Tag = new float[3];
var pos = otherPlayer.Tag as float[];
om.Write(pos[0]);
om.Write(pos[1]);
om.Write(pos[2]);
// send message
server.SendMessage(om, player, NetDeliveryMethod.Unreliable);
}
}
}
// schedule next update
nextSendUpdates += (1.0 / 60.0);
}
}
// sleep to allow other processes to run smoothly
Thread.Sleep(1);
}
Console.WriteLine("Server powering down..");
server.Shutdown("bye");
}
public 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");
}
}
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)
{
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");
}
public static void Start()
{
NetPeerConfiguration config = new NetPeerConfiguration("xnaapp");
config.EnableMessageType(NetIncomingMessageType.DiscoveryRequest);
config.Port = 14242;
// create and start server
NetServer server = new NetServer(config);
server.Start();
// schedule initial sending of position updates
double nextSendUpdates = NetTime.Now;
// run until escape is pressed
//while (!Console.KeyAvailable || Console.ReadKey().Key != ConsoleKey.Escape)
while(true)
{
NetIncomingMessage msg;
while ((msg = server.ReadMessage()) != null)
{
switch (msg.MessageType)
{
case NetIncomingMessageType.DiscoveryRequest:
//
// Server received a discovery request from a client; send a discovery response (with no extra data attached)
//
server.SendDiscoveryResponse(null, msg.SenderEndpoint);
break;
case NetIncomingMessageType.VerboseDebugMessage:
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.WarningMessage:
case NetIncomingMessageType.ErrorMessage:
//
// Just print diagnostic messages to console
//
Console.WriteLine(msg.ReadString());
break;
case NetIncomingMessageType.StatusChanged:
NetConnectionStatus status = (NetConnectionStatus)msg.ReadByte();
if (status == NetConnectionStatus.Connected)
{
//
// A new player just connected!
//
Console.WriteLine(NetUtility.ToHexString(msg.SenderConnection.RemoteUniqueIdentifier) + " connected!");
// randomize his position and store in connection tag
msg.SenderConnection.Tag = new int[] {
NetRandom.Instance.Next(10, 100),
NetRandom.Instance.Next(10, 100)
};
}
break;
case NetIncomingMessageType.Data:
//
// The client sent input to the server
//
int xinput = msg.ReadInt32();
int yinput = msg.ReadInt32();
int[] pos = msg.SenderConnection.Tag as int[];
// fancy movement logic goes here; we just append input to position
pos[0] += xinput;
pos[1] += yinput;
break;
}
//
// send position updates 30 times per second
//
double now = NetTime.Now;
if (now > nextSendUpdates)
{
// Yes, it's time to send position updates
// for each player...
foreach (NetConnection player in server.Connections)
{
// ... send information about every other player (actually including self)
foreach (NetConnection otherPlayer in server.Connections)
{
// send position update about 'otherPlayer' to 'player'
NetOutgoingMessage om = server.CreateMessage();
// write who this position is for
om.Write(otherPlayer.RemoteUniqueIdentifier);
if (otherPlayer.Tag == null)
otherPlayer.Tag = new int[2];
int[] pos = otherPlayer.Tag as int[];
om.Write(pos[0]);
om.Write(pos[1]);
// send message
server.SendMessage(om, player, NetDeliveryMethod.Unreliable);
}
}
// schedule next update
nextSendUpdates += (1.0 / 30.0);
}
}
// sleep to allow other processes to run smoothly
Thread.Sleep(1);
}
server.Shutdown("app exiting");
}
/// <summary>
///
/// </summary>
/// <param name="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);
}
}
static void Main(string[] args)
{
NetPeerConfiguration config = new NetPeerConfiguration("projectorigin");
config.EnableMessageType(NetIncomingMessageType.DiscoveryRequest);
config.Port = 14242;
// Create and start server
NetServer server = new NetServer(config);
server.Start();
Console.WriteLine("Game Server starts");
//Schedule initial sending of position updates
double nextSendUpdates = NetTime.Now;
GameStatus gameStatus = GameStatus.Initial;
int clientDoneCounter = 0;
//Generate a map and wait client to connect
//InternalMap map = GenerateMap();
int mapSeed = 1000;
Random rand = new Random();
mapSeed = rand.Next();
//Run until escape is pressed
while (!Console.KeyAvailable || Console.ReadKey().Key != ConsoleKey.Escape)
{
NetIncomingMessage msg;
while ((msg = server.ReadMessage()) != null)
{
switch (msg.MessageType)
{
case NetIncomingMessageType.DiscoveryRequest:
//
// Server received a discovery request from a client; send a discovery response (with no extra data attached)
//
NetOutgoingMessage com = server.CreateMessage();
//byte[] mapData = Serializer<InternalMap>.SerializeObject(map);
switch (server.ConnectionsCount)
{
case 0:
com.Write((int)PlayerId.Green);
com.Write((int)mapSeed); //Write map seed
break;
case 1:
com.Write((int)PlayerId.Red);
com.Write((int)mapSeed); //Write map seed
gameStatus = GameStatus.Receive;
break;
}
server.SendDiscoveryResponse(com, msg.SenderEndpoint);
Console.WriteLine("Connect to: " + msg.SenderEndpoint);
break;
case NetIncomingMessageType.Data:
if (gameStatus == GameStatus.Receive)
{
//
// The client sent input to the server
//
IncomingMessageType imt = (IncomingMessageType)msg.ReadByte();
if (imt == IncomingMessageType.DataPlayerInfo)
{
int wayPointCounter = msg.ReadInt32();
List<PlayerInfo> wayPoints = new List<PlayerInfo>();
for (int i = 1; i <= wayPointCounter; ++i)
{
Vector3 tempPos;
tempPos.X = msg.ReadFloat();
tempPos.Y = msg.ReadFloat();
tempPos.Z = msg.ReadFloat();
float tempOrientation;
tempOrientation = msg.ReadFloat();
PlayerInfo wayPoint = new PlayerInfo(tempPos, tempOrientation);
wayPoints.Add(wayPoint);
}
playerInfoDict[msg.SenderEndpoint] = wayPoints;
Console.WriteLine("Receive message from" + msg.SenderEndpoint);
clientDoneCounter++;
if (clientDoneCounter == 2)
gameStatus = GameStatus.Sending;
}
}
break;
}
//
// send position updates 30 times per second
//
if (gameStatus == GameStatus.Sending)
{
// Yes, it's time to send position updates
// for each player...
foreach (NetConnection player in server.Connections)
{
if (!playerInfoDict.ContainsKey(player.RemoteEndpoint))
playerInfoDict[player.RemoteEndpoint] = new List<PlayerInfo>();
}
foreach (NetConnection player in server.Connections)
{
//send information about every other player(not including self)
foreach (NetConnection otherPlayer in server.Connections)
{
if (player.RemoteEndpoint == otherPlayer.RemoteEndpoint)
continue;
// send position update about 'otherPlayer' to 'player'
NetOutgoingMessage om = server.CreateMessage();
om.Write((byte)OutgoingMessageType.DataOtherPlayerInfo);
om.Write(playerInfoDict[otherPlayer.RemoteEndpoint].Count);
foreach (PlayerInfo playerInfo in playerInfoDict[otherPlayer.RemoteEndpoint])
{
om.Write(playerInfo.position.X);
om.Write(playerInfo.position.Y);
om.Write(playerInfo.position.Z);
om.Write(playerInfo.orientation);
}
//send message
server.SendMessage(om, player, NetDeliveryMethod.ReliableOrdered);
}
}
gameStatus = GameStatus.Receive;
clientDoneCounter = 0;
}
}
}
server.Shutdown("server exiting");
}
public static void Main()
{
NetPeerConfiguration config = new NetPeerConfiguration("xnaapp");
config.EnableMessageType(NetIncomingMessageType.DiscoveryRequest);
config.Port = 14242;
// create and start server
NetServer server = new NetServer(config);
server.Start();
// schedule initial sending of position updates
double nextSendUpdates = NetTime.Now;
Dictionary<NetConnection, List<Damage>> damages = new Dictionary<NetConnection, List<Damage>>();
Dictionary<NetConnection, Position> positions = new Dictionary<NetConnection, Position>();
List<Npc> npcs = new List<Npc>();
npcs.Add(new Npc { X = 1700, Y = 1000, Speed = 4, Life = 3 });
// run until escape is pressed
int i = 0;
while (IsRunning)
{
NetIncomingMessage msg;
while ((msg = server.ReadMessage()) != null)
{
switch (msg.MessageType)
{
case NetIncomingMessageType.DiscoveryRequest:
//
// Server received a discovery request from a client; send a discovery response (with no extra data attached)
//
server.SendDiscoveryResponse(null, msg.SenderEndpoint);
break;
case NetIncomingMessageType.VerboseDebugMessage:
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.WarningMessage:
case NetIncomingMessageType.ErrorMessage:
//
// Just print diagnostic messages to console
//
//Console.WriteLine(msg.ReadString());
Debug.WriteLine(msg.ReadString());
break;
case NetIncomingMessageType.StatusChanged:
NetConnectionStatus status = (NetConnectionStatus)msg.ReadByte();
if (status == NetConnectionStatus.Connected)
{
//
// A new player just connected!
//
Console.WriteLine(NetUtility.ToHexString(msg.SenderConnection.RemoteUniqueIdentifier) + " connected!");
Debug.WriteLine(NetUtility.ToHexString(msg.SenderConnection.RemoteUniqueIdentifier) + " connected!");
msg.SenderConnection.Tag = new object[6];
}
break;
case NetIncomingMessageType.Data:
//
// The client sent input to the server
//
MessageRouts messageRout = (MessageRouts)msg.ReadByte();
switch (messageRout)
{
case MessageRouts.Position:
Position position = new Position();
position.X = msg.ReadInt32();
position.Y = msg.ReadInt32();
position.Angle = msg.ReadInt32();
position.IsShooting = msg.ReadBoolean();
position.IsHuman = msg.ReadBoolean();
positions[msg.SenderConnection] = position;
break;
case MessageRouts.Fire:
Damage damage = new Damage();
damage.PlayerId = msg.ReadInt64();
damage.WeaponId = msg.ReadByte();
damage.Angle = msg.ReadByte();
damage.X = msg.ReadInt32();
damage.Y = msg.ReadInt32();
if (damage.PlayerId > 50)
{
if (!damages.ContainsKey(msg.SenderConnection))
damages[msg.SenderConnection] = new List<Damage>();
damages[msg.SenderConnection].Add(damage);
}
else
{
npcs[(int)damage.PlayerId].Life -= 1;
if (npcs[(int)damage.PlayerId].Life <= 0)
npcs.RemoveAt((int)damage.PlayerId);
}
break;
}
break;
}
// send position updates 30 times per second
double now = NetTime.Now;
if (now > nextSendUpdates)
{
foreach (var position in positions.Values)
{
foreach (var npc in npcs)
{
float velX = position.X - npc.X;
float velY = position.Y - npc.Y;
float distance = (float)Math.Sqrt(Math.Pow(velX, 2) + Math.Pow(velY, 2));
if (distance < 300 && distance > 30)
{
velX /= distance;
velY /= distance;
npc.X += (int)(velX * npc.Speed);
npc.Y += (int)(velY * npc.Speed);
NetOutgoingMessage om2 = server.CreateMessage();
om2.Write((byte)MessageRouts.MoveNpc);
om2.Write((byte)npcs.IndexOf(npc));
om2.Write((int)npc.X);
om2.Write((int)npc.Y);
foreach (NetConnection player in server.Connections)
server.SendMessage(om2, player, NetDeliveryMethod.ReliableUnordered);
}
}
}
foreach (NetConnection player in server.Connections)
{
foreach (var damagePair in damages)
{
if (damagePair.Key != player)
{
foreach (var damage in damagePair.Value)
{
NetOutgoingMessage om2 = server.CreateMessage();
om2.Write((byte)MessageRouts.Fire);
om2.Write(damagePair.Key.RemoteUniqueIdentifier);
om2.Write(damage.PlayerId);
om2.Write(damage.WeaponId);
om2.Write(damage.Angle);
om2.Write(damage.X);
om2.Write(damage.Y);
server.SendMessage(om2, player, NetDeliveryMethod.ReliableUnordered);
}
}
}
foreach (NetConnection otherPlayer in server.Connections)
{
if (player != otherPlayer)
{
NetOutgoingMessage om = server.CreateMessage();
if (positions.ContainsKey(otherPlayer))
{
om.Write((byte)MessageRouts.Position);
om.Write(otherPlayer.RemoteUniqueIdentifier);
om.Write(positions[otherPlayer].X);
om.Write(positions[otherPlayer].Y);
om.Write(positions[otherPlayer].Angle);
om.Write(positions[otherPlayer].IsShooting);
om.Write(positions[otherPlayer].IsHuman);
server.SendMessage(om, player, NetDeliveryMethod.Unreliable);
}
// send message
}
}
}
foreach (var damageList in damages.Values)
damageList.Clear();
// schedule next update
nextSendUpdates += (1.0 / 30.0);
}
}
// sleep to allow other processes to run smoothly
Thread.Sleep(1);
}
server.Shutdown("app exiting");
}
static void Main(string[] args)
{
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);
}
}
}
