Multiplayer: Unterschied zwischen den Versionen

Aus Das Sopra Wiki
Zur Navigation springen Zur Suche springen
Zeile 235: Zeile 235:
  
 
[[Kategorie:Code-Beispiele]]
 
[[Kategorie:Code-Beispiele]]
 +
[[Kategorie:Begriffe]]
 +
[[Kategorie:Tutorials]]

Version vom 12. April 2011, 19:01 Uhr

Netzwerk

Da die Implementierung von Netzwerkfunktionalität für Multiplayer-Unterstützung nicht ganz trivial umzusetzen ist wird sie gern als optionales Feature für die spätere Entwicklung angedacht. Das Problem hierbei ist, dass Netzwerkfunktionalität einen entscheidenden Einfluss auf die gesamte Architektur hat. Wenn Netzwerkfunktionalität geplant ist sollte diese daher von vornherein als festes Feature eingeplant werden.

Wenn man sich dafür entscheided Netzwerkfunktionalität zu implementieren, sollte man wissen dass es für das XNA Framework zwei grundlegend verschiedene Möglichkeiten gibt:

Davon unabhängig sind für die Realisierung eines klassischen Client/Server Konzepts folgende Schritte notwendig:

Auf Server Seite:

  • Socket öffnen & Clientverbindungen annehmen
  • Daten gemäß Protokoll transportieren

Auf Client Seite:

  • Mit Server Socket verbinden
  • Daten gemäß Protokoll transportieren


Multiplayer mit der Lidgren Bibliothek

Die NetBuffer Klasse

Eine Instanz der NetBuffer Klasse erhält man stets durch Aufruf der Methode CreateBuffer() auf einem NetServer respektive NetClient Objekt.

Die Klasse stellt zum Schreiben von Nutzdaten die Methode Write() mit unzähligen Overloads für die einzelnen Datentypen zur Verfügung. Wenn die XNA Extension genutzt wird können auch direkt XNA Datentypen wie z.B. Vector3 in einen NetBuffer geschrieben werden.

Um die Nutzdaten aus einem NetBuffer Objekt auszulesen werden die entsprechend benannten Read() Methoden verwendet. So gibt es z.B. ReadString(), ReadBoolean(), ReadFloat() und falls die XNA Extension eingebunden ist auch Methoden wie ReadVector3().

Zu beachten hierbei ist, dass die Daten in einem Buffer in der gleichen Reihenfolge wieder gelesen werden müssen in der sie auch geschrieben wurden.

Network Channels

Es gibt 4 verschiedene virtuelle Netzwerk Kanäle die beim versenden von Paketen mittels der Lidgren Library angegeben werden können:

  • UnreliableUnordered - Nachrichten kommen entweder beim Empfänger an oder auch nicht
  • UnreliableInOrder - Auslieferung der Nachrichten ebenfalls nicht garantiert, falls eine Nachricht zu spät kommt, d.h. eine neuere Nachricht ist vorher eingetroffen, so wird die ältere gedroppt
  • ReliableUnordered - Garantierte Auslieferung der Nachrichten, allerdings nicht notwendigerweise in der Reihenfolge in der sie gesendet wurden
  • ReliableInOrder - Alle Nachrichten kommen in der Reihenfolge in der sie gesendet wurden beim Empfänger an

Server

Starten des Servers

NetPeerConfiguration config = new NetPeerConfiguration("MyApp");
config.Port = 4096;
NetServer myNetServer = new NetServer(config);
myNetServer.Start();

Empfangen von Clientdaten

NetIncomingMessage msg;
while ((msg = server.ReadMessage()) != null)
{
	switch (msg.MessageType)
	{
		case NetIncomingMessageType.VerboseDebugMessage:
		case NetIncomingMessageType.DebugMessage:
		case NetIncomingMessageType.WarningMessage:
		case NetIncomingMessageType.ErrorMessage:
			Console.WriteLine(msg.ReadString());
			break;
		case NetIncomingMessageType.Data:
			// data sent by client..
			// buffer contains the userdata from the client..
			// sending client is specified in sender
			break;
	}
}

Daten an Clients senden

myNetServer.SendMessage(buffer, client, NetChannel.UnreliableInOrder1);
myNetServer.SendToAll(buffer, NetChannel.UnreliableInOrder1);

Client

Client starten

NetConfiguration config = new NetConfiguration("MyApp");
NetClient myNetClient = new NetClient(config);
myNetClient.SetMessageTypeEnabled(NetMessageType.ConnectionRejected, true);
myNetClient.DiscoverLocalServers(4096);

Daten vom Server empfangen

NetBuffer buffer = myNetClient.CreateBuffer();
NetMessageType type;
while (myNetClient.ReadMessage(buffer, out type))
{
	switch (type)
	{
		case NetMessageType.ServerDiscovered:
			// just connect to any server found!
			myNetClient.Connect(buffer.ReadIPEndPoint());
			break;
		case NetMessageType.ConnectionRejected:
			Console.WriteLine("Rejected: " + buffer.ReadString());
			break;
		case NetMessageType.DebugMessage:
		case NetMessageType.VerboseDebugMessage:
			Console.WriteLine(buffer.ReadString());
			break;
		case NetMessageType.StatusChanged:
			string statusMessage = buffer.ReadString();
			NetConnectionStatus newStatus = (NetConnectionStatus)buffer.ReadByte();
			Console.WriteLine("New status: " + newStatus + " (" + statusMessage + ")");
			break;
		case NetMessageType.Data:
			// userdata sent from the server is now in the buffer
			break;
	}
}

Daten zum Server senden

myNetClient.SendMessage(buffer, NetChannel.UnreliableInOrder1);

Multiplayer mittels Windows Live

PacketReader & PacketWriter

Instanzen dieser Klassen dienen zum bequemen Schreiben bzw. Lesen von Netzwerkdaten. Die PacketWriter Klasse verfügt über eine merfach überladene Write() Methode für verschiedenste Datentypen. Ebenso einfach können diese Datentypen über die entsprechend benannten Read() Methoden der PacketReader Klasse wieder gelesen werden. Auch hier gilt, dass die Reihenfolge des Lesens und Schreibens die Gleiche sein sollte.

SendDataOptions

Das Windows Live System bietet ebenfalls die 4 grundlegenden Transportwege an. Diese können beim Senden durch Setzen eines Wertes des Typ SendDataOptions ausgewählt werden. Diese Enum enthält unter anderem folgende Definitionen:

  • None - Nachrichten kommen entweder beim Empfänger an oder auch nicht
  • InOrder - Auslieferung der Nachrichten ebenfalls nicht garantiert, falls eine Nachricht zu spät kommt, d.h. eine neuere Nachricht ist vorher eingetroffen, so wird die ältere gedroppt
  • Reliable - Garantierte Auslieferung der Nachrichten, allerdings nicht notwendigerweise in der Reihenfolge in der sie gesendet wurden
  • ReliableInOrder - Alle Nachrichten kommen in der Reihenfolge in der sie gesendet wurden beim Empfänger an

Server

Starten des Servers

const int maxGamers = 16;
const int maxLocalGamers = 4;
try
{

    NetworkSession myNetworkSession = NetworkSession.Create(NetworkSessionType.SystemLink,
    	maxLocalGamers, maxGamers);
	// hook event handlers
	myNetworkSession.GamerJoined += GamerJoinedEventHandler;
	myNetworkSession.SessionEnded += SessionEndedEventHandler;
}
catch (Exception e)
{
    errorMessage = e.Message;
}

Die Eventhandler

void GamerJoinedEventHandler(object sender, GamerJoinedEventArgs e);
void SessionEndedEventHandler(object sender, NetworkSessionEndedEventArgs e)
{
    errorMessage = e.EndReason.ToString();
    myNetworkSession.Dispose();
    myNetworkSession = null;
}

Empfangen von Clientdaten

// Keep reading as long as incoming packets are available.
while (gamer.IsDataAvailable)
{
    NetworkGamer sender;

    // Read a single packet from the network.
    gamer.ReceiveData(packetReader, out sender);

    if (!sender.IsLocal)
    {
        // Read the packetdata available in packetReader
    }
}

Daten an Clients senden

LocalNetworkGamer server = (LocalNetworkGamer)myNetworkSession.Host;
server.SendData(packetWriter, SendDataOptions.InOrder, client);
myNetworkSession.Update();
LocalNetworkGamer server = (LocalNetworkGamer)myNetworkSession.Host;
server.SendData(packetWriter, SendDataOptions.InOrder);
myNetworkSession.Update();

Client

Client starten

const int maxLocalGamers = 4;
try
{
	// Search for sessions.
	using (AvailableNetworkSessionCollection availableSessions = NetworkSession.Find(
		NetworkSessionType.SystemLink, maxLocalGamers, null))
	{
	    if (availableSessions.Count == 0)
	    {
	        errorMessage = "No network sessions found.";
	        return;
	    }
	
		// Join the first session we found.
		myNetworkSession = NetworkSession.Join(availableSessions[0]);
		// hook event handlers
		myNetworkSession.GamerJoined += GamerJoinedEventHandler;
		myNetworkSession.SessionEnded += SessionEndedEventHandler;
	}
}
catch (Exception e)
{
    errorMessage = e.Message;
}

Daten vom Server empfangen

// Keep reading as long as incoming packets are available.
while (gamer.IsDataAvailable)
{
    NetworkGamer sender;
    // Read a single packet from the network.
    gamer.ReceiveData(packetReader, out sender);
    // Read the data from packetReader..
}

Daten zum Server senden

gamer.SendData(packetWriter, SendDataOptions.InOrder, myNetworkSession.Host);