Date post: | 01-Nov-2014 |
Category: |
Documents |
Upload: | boybuon205 |
View: | 757 times |
Download: | 0 times |
Tran Minh Triet – Nguyen Khac HuyTran Minh Triet – Nguyen Khac HuyFaculty of Information TechnologyFaculty of Information TechnologyUniversity of Science, VNU-HCMUniversity of Science, VNU-HCM
This slide is based on This slide is based on
Chapter 25 and 26 of Chapter 25 and 26 of
Microsoft® XNA™ Game Studio 3.0 UnleashedMicrosoft® XNA™ Game Studio 3.0 Unleashed
by Chad Carter, SAMS (2009)by Chad Carter, SAMS (2009)
Client/Server
Peer to Peer
Hybrid
One machine (server) acts as the host, other machines (clients) connect to the host.
All the data is passed to the server. The server then sends the messages to the individual clients.
This scenario is common on Windows because cheating by modifying the packets is possible. The server can ignore any attempts at modifying the data because it knows exactly where all the players are and the status of each player.
Typically when trying to join a session, a particular machine needs to be the server so everyone who wants to join the game can find the game. Each client sends a ready command, and the host will start the game by sending a start command to each client.
The peer-to-peer approach broadcasts data from one peer to all the other peers. Or it can send a private message to one peer. The data can travel quicker in this environment because it does not have to be re-sent from a central location. Cheating: Each peer can modify the packet to cheat the game. Xbox LIVE helps us with these concerns because the network traffic is secure. The data is encrypted, which makes it really difficult for anyone to decrypt a packet, modify it, encrypt it again, and then process it.
Most games actually use both approaches.
The client/server architecture is used for creating and joining a network session
Once the game play starts it moves into a peer-to-peer architecture, where each player is sending its data to the peers (or just the peers that are within range, on the team, and so on).
Programming multiplayer games is all about compromise. Writing a game that is both completely accurate and completely lag-free is not possible. It may make sense to be less accurate in order to have a more immediate response.
Using a single authority machine (client/server approach) to decide the answers for important problems in a game
NetworkSession.InviteAccepted += OnInviteAccepted;
private void OnInviteAccepted
(object sender, InviteAcceptedEventArgs args)
{
// Quit the current session
if (session != null)
{
session.Dispose();
session = null;
}
// Join the new session
session = NetworkSession.JoinInvited(maxLocalGamers);
}
private NetworkSession networkSession;
private PacketReader packetReader = new PacketReader();
private PacketWriter packetWriter = new PacketWriter();
const int maxGamers = 16;
const int maxLocalGamers = 4;
if (networkSession == null)
{
// If we are not in a network session, update the
// menu screen that will let us create or join one.
UpdateMenuScreen();
}
else
{
// If we are in a network session, update it.
UpdateNetworkSession();
}
private void UpdateMenuScreen()
{
if (IsActive)
{
if (Gamer.SignedInGamers.Count == 0)
{
// If there are no profiles signed in, we cannot proceed.
// Show the Guide so the user can sign in.
Guide.ShowSignIn(maxLocalGamers, false);
}
. . . . . .
. . . . . .
else if (input.WasPressed(0, InputHandler.ButtonType.A,
Keys.A))
{ // Create a new session?
CreateSession();
}
else if (input.WasPressed(0, InputHandler.ButtonType.B,
Keys.B))
{ // Join an existing session?
JoinSession();
}
}
}
private void CreateSession()
{
DrawMessage("Creating session...");
try
{
networkSession = NetworkSession.Create
(NetworkSessionType.SystemLink,
maxLocalGamers, maxGamers);
HookSessionEvents();
}
. . . . . .
. . . . . .
catch (Exception e)
{
errorMessage = e.Message;
if (networkSession != null)
{
networkSession.Dispose();
networkSession = null;
}
}
}
private void DrawMessage(string message)
{
if (!BeginDraw())
return;
GraphicsDevice.Clear(Color.CornflowerBlue);
spriteBatch.Begin();
spriteBatch.DrawString
(font, message, new Vector2(6, 6), Color.Black);
spriteBatch.DrawString
(font, message, new Vector2(5, 5), Color.White);
spriteBatch.End();
EndDraw();
}
private void HookSessionEvents()
{
networkSession.GamerJoined += GamerJoinedEventHandler;
networkSession.SessionEnded += SessionEndedEventHandler;
}
private void GamerJoinedEventHandler
(object sender, GamerJoinedEventArgs e)
{
int gamerIndex =
networkSession.AllGamers.IndexOf(e.Gamer);
Texture2D gamerProfilePic = blankProfilePicture;
. . . . . .
. . . . . .
foreach (SignedInGamer signedInGamer in
SignedInGamer.SignedInGamers)
{ if (signedInGamer.Gamertag == e.Gamer.Gamertag &&
signedInGamer.IsSignedInToLive)
{
GamerProfile gp = e.Gamer.GetProfile();
gamerProfilePic = gp.GamerPicture;
}
}
e.Gamer.Tag = new GamerObject
(gamerIndex, gamerProfilePic, screenWidth, screenHeight);
}
private void SessionEndedEventHandler
(object sender, NetworkSessionEndedEventArgs e)
{
errorMessage = e.EndReason.ToString();
networkSession.Dispose();
networkSession = null;
}
private void JoinSession()
{ DrawMessage(“Joining session...”);
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. networkSession = NetworkSession.Join(availableSessions[0]); HookSessionEvents(); } } catch (Exception e) { errorMessage = e.Message; if (networkSession != null) { networkSession.Dispose(); networkSession = null; } }}
private void UpdateNetworkSession()
{
//Update our locally controlled player and
//send their latest position to everyone else
foreach (LocalNetworkGamer gamer in
networkSession.LocalGamers)
{
UpdateLocalGamer(gamer);
}
. . . . . .
. . . . . .
//Need to call Update on every frame
networkSession.Update();
//Make sure the session has not ended
if (networkSession == null)
return;
//Get packets that contain positions of remote players
foreach (LocalNetworkGamer gamer in
networkSession.LocalGamers)
{
ReadIncomingPackets(gamer);
}
}
private void UpdateLocalGamer(LocalNetworkGamer gamer)
{
// Look up what gamerObject is associated with
// this local player
GamerObject gamerObject = gamer.Tag as GamerObject;
// Update the object
ReadInputs(gamerObject, gamer.SignedInGamer.PlayerIndex);
gamerObject.Update();
//Write the player state into a network packet
packetWriter.Write(gamerObject.Position);
// Send the data to everyone in the session.
gamer.SendData(packetWriter, SendDataOptions.InOrder);
}
private void ReadIncomingPackets(LocalNetworkGamer gamer)
{
//As long as incoming packets are available keep reading them
while (gamer.IsDataAvailable)
{
NetworkGamer sender;
//Read a single network packet
gamer.ReceiveData(packetReader, out sender);
//Ignore packets sent by local gamers
//since we already know their state
if (sender.IsLocal)
continue;
. . . . . .
. . . . . .
//Look up the player associated with
// whoever sent this packet
GamerObject remoteGamerObject =
sender.Tag as GamerObject;
//Read the state of this gamer object from the network
remoteGamerObject.Position =
packetReader.ReadVector2();
}
}