Did you read through the appropriate parts of the Forum FAQ?

Typically, you define a protocol. Part of a protocol is typically a PDU (packet data unit) definition. A typical implementation of a PDU is a C-style "struct," or a defined binary serialization format of some sort. Another part is the surrounding framing -- letting the receiver know what kind of PDU is coming in, and how much data it is, so the PDUs don't run together.

A typical PDU framing header might look like:

byte: type
byte: datalength
byte[]: data


What "data" means depends on the "type" field. For example, you can define a byte with bit values for different keys:


enum KeyType {
KeyLeft = 0x1,
KeyRight = 0x2,
KeyUp = 0x4,
KeyDown = 0x8,
KeyJump = 0x10,
KeyAction = 0x20
};

enum PduType {
PduTypeKeys = 1,
PduTypeChat = 2
};


At this point, you'd send a PDU of type 1, containing a single byte, which is the bitwise OR of the keys that are down. You could also send a PDU of type 2, where the "data" would be the text of a chat message from the client.

The network interface layer then has to translate between whatever the input/actor/entity system uses for data, and the PDU format. Then it has to translate back on the receiving side. This translation mechanism is generally known as "marshaling" and is related to, but not the same thing as, serialization. Note that some serialization mechanisms use 10x or even 100x the amount of storage/bandwidth as a plain marshaling system, so don't just apply some random serialization library that happens to be available.

You set up the connection at the beginning, and then you keep it open. You send each new command/message on the same connection. Same thing with receiving, you "drain" the connection each time through your main loop, and decode the messages you receive this way, and hang on to whatever data is left at the end, as it will be the beginning of whatever message comes next.

Okay, I see what you're saying there. But I still don't understand how I can tell the server to move the player. Blah, networking is really confusing.

In pseudo code, if you want to move a player (only passing minimal info here), you would do something like this:

// defines the packet type being send
enum etPacketType
{
MOVE_PLAYER_TYPE,
BROADCAST_CHAT_TYPE
};

// packets defined in client and server:
struct tPacketHeader
{

etPacketType PacketType;
uint8_t DataLength;
}

struct tPlayerMoveData
{
uint32_t PlayerIdToMove;
double PositionX;
double PositionY;
double VelocityX;
double VelocityY;
}

struct tMovePacket
{
tPacketHeader PacketHeader;
tPlayerMoveData PlayerMoveData;

}

// Client code, where the MovePacket has been filled out
void MovePlayer(tMovePacket &PlayerToMove)
{
// Send this data to server, tell it to move this player
DataSend(ServerSocket, &PlayerToMove, sizeof(tMovePacket));
}

// in Server code, assuming you get notified when data comes in
void ReadData()
{
tPacketHeader PacketHeader;
tPlayerMoveData PlayerMoveData;

// Read the PacketHeader only 1st
RecvData(ClientSocket, &PacketHeader, sizeof(tPacketHeader);

switch (PacketHeader.PacketType) {
case MOVE_PLAYER_TYPE:
// Read the rest of the data into PlayerMoveData
RecvData(ClientSocket, &PlayerMoveData, sizeof(tPlayerMoveData);
// Now handle moving the Player given by playerId, located at the given positions,
// and mvoe it the given velocities
HandlePlayerMove(PlayerMoveData);

// handle others below
default:
break;


This is just a general idea of what you could do. There are tons of ways to do this, like just sending the key presses, and have the server move the player based on the keys it gets.