I''d do it this way:

send a normal packet with the TEXT_MESSAGE command, right after that the charakter stream.. then abort it as soon as the ''\0'' charakter appears.. also, you could somehow compress the message, cause a lot of charakters won''t be used..

just my thoughts,
cya,
Phil

Visit Rarebyte!
and no!, there are NO kangaroos in Austria (I got this questions a few times over in the states

this is how i do it:


// define maximum text message length in characters
#define MAXTEXTLEN 100

// message types
enum {
MSG_LOGINREQUEST = 1,
MSG_LOGINREPLY,
MSG_TEXT,
MSG_CONNECT,
MSG_DISCONNECT
};

// text message structure
struct MsgText {
int m_Type; // type of message, MSG_TEXT for text
char m_Buffer[MAXTEXTLEN]; // buffer for text message
};

// create packet and send
MsgText msg;
ZeroMemory(&msg, sizeof(MsgText));
msg.m_Type = MSG_TEXT;
strcpy(msg.m_Buffer, "This is a text message from me.");
send((void *)&msg);


If you are using UDP, you can ask wsa for the packet size. The packet structure should have everthing a constant size except the payload (which would contain the text msg in the case of a chat packet).

If you''re using TCP the first thing sent with every packet should be (must be!) the amount of data that''s coming.

  //tcp exampleenum PacketType	{	PT_EMPTY        = 0x0000,	PT_CHAT         = 0x0001,	PT_LOGIN        = 0x0002,	PT_PING         = 0x0003,	PT_PONG         = 0x0004,	PT_PLAYER       = 0x0005,	PT_FORCEDWORD   = 0xFFFFFFFF	};class CPacket	{	public:		CPacket();		~CPacket();		//friend class CRecvSocket;		//friend class CNetworkClient;		void Chat(const CString&);		//void Player(const CPlayer&);		void Player(const CPlayer&);		void Pack(const void*, long);				void Serialize(CArchive& ar);		friend CArchive& operator<<(CArchive& arc, const CPacket& packet);		friend CArchive& operator>>(CArchive& arc, CPacket& packet);				const PacketType& GetPacketType()			{			return(packettype);			}	//protected:		DWORD GenerateSerial(DWORD);		DWORD GenerateECC();	//private:		long length;		PacketType packettype;		DWORD serialnum;		DWORD ecc;		char* data;			};//the sendCArchive& operator<<(CArchive& arc, const CPacket& packet)	{	if (arc.IsStoring())		{		arc << packet.length;		arc << (long)packet.packettype;		arc << packet.serialnum;		int n = packet.length - sizeof(CPacket) + sizeof(packet.data);		for(int i=0;i<n;i++)			arc << packet.data<i>;		arc << packet.ecc;		}	return(arc);	}//the receiveCArchive& operator >>(CArchive& arc, CPacket& packet)	{	if (!arc.IsStoring())		{		long pt;		arc >> packet.length;		arc >> pt; packet.packettype = (PacketType) pt;		arc >> packet.serialnum;		if(packet.data)			delete[] packet.data;		int n = packet.length - sizeof(CPacket) + sizeof(packet.data);		packet.data = new char[n+1];		packet.data[n]=0;		for(int i=0;i<n;i++)			{			int b = arc.IsBufferEmpty();			arc >> packet.data[i];			}		arc >> packet.ecc;		DWORD cs = packet.GenerateECC();		if(cs!=packet.ecc)			{			char* breakhere =0;			*breakhere = *breakhere; //something went horribly wrong!			}		}	return arc;	}  

Using DPlay all you have to do is have to do is specify exactly how big the message is. My packet struct is simply

struct message
{
unsigned char type;
unsigned char msg[65536];
}

when I send I set sizeof to how many bytes I actually want to send. My struct is 64k but I can send 1 byte if I want. When it reaches it''s destination the type value tells the client or server how to interpret the message.

Course I''ve noticed most dispise Dplay for whatever reason on this list. I''m sure Winsock can utilize the same trick though.

Ben

type tells the server or client if it''s a text message or something else. The same struct is also used to send position updates and everything else.

message_struct
{
unsigned char type, data[65536];
}


say the text type is 5

so you''d go

message.type=5
message.data[0]=3
message.data[1]=''H'';
message.data[2]=''I'';
message.data[3]=''!'';

since the data array is 65536 characters you have to adjust the send routine accordingly

g_pDP->Send( g_LocalPlayerDPID, PlayerSendToID, DPSEND_GUARANTEED, &message, sizeof(message_struct)-65536+4);

By subtracting 65536 we tell the send command we are only sending the bytes in variables defined prior to the data array.

It''s + 4 since there are 4 values you need to get sent within the data array.

The server does automatically retrieve the size of messages sent to it. In this case it would be 5 since the type is one byte.

You''ll just need a routine at the destination end to check what type the message is and how to read it.

It has to be chars or unsigned chars for the struct to work. If you change it to say shorts then you would double everything. It''s easier just to break everything down to chars prior to sending. If you have decimals you''ll have to get them to integers and then break them up. Then do the reverse on the recieving end.

Once you get that going you can use it with everything. It''s basically a binary file.

Ben

Part of the UDP packet header is how big the packet is. The UDP packet header is a fixed size, so you always know how much data was sent (so long as you stay under 1500, or whatever odd value the MTU happens to be).

Typically the data actually sent has a header itself that describes the rest of the data attached. ie whether is a chat packet, position update, login request, attack, etc...