Game Network Engine

[tanffn]

Any news on the network engine endeavor?
Its not has fun as AI or 3D rendering but, sadly, it has to be done

I want to (re)start working on my RTS-TBS game and for that I need reliable TSP/IP based networking.

It could have been nice to have WCF/Remoting style in Delphi, is there something like that available?
Any ideas/request for approaching this?
I was thinking about a simple approach, send command records with a known format:
[pascal]TBasePacket = packed record
ID: cardinal;
Size: cardinal;
End;
TDoSomthingPacket = packed record
ID: cardinal;
Size: cardinal;
NewX, NewY: integer;
...
End;
[/pascal]This way the software reads the stream, with the ID it knows what type of packet it is (for casting).

[arthurprs]

variant record?

[technomage]

I dropped the idea of building a Net work engine in favour of building a 3D game engine InfintEngine for the InfiniteSpace-Online project.

I have recently started using ENet as a basis for the Network engine as it provides Reliable UDP support. However I am using Indy as well but this detils will be wrapped up under one simple interface.

[tanffn]

arthurprs: no, simple record.
You read a stream of data, you know that the 1st word has the Type ID. so you can read the next SizeOf(OurRecord) directly into the record's pointer.
Nothing smart, I don't understand the data I simply dump it into the correct record type.

technomage: Sent you a PM.

[cairnswm]

What I have done before for networking was through a use of a case inside the record. So the recieving side can always load it directly into a record because every message is the same size:

[pascal]type
TShapeList = (Rectangle, Triangle, Circle, Ellipse, Other);
TFigure = record
ID : TShapeList
case TShapeList of
Rectangle: (Height, Width: Real);

Triangle: (Side1, Side2, Angle: Real);
Circle: (Radius: Real);
Ellipse, Other: ();
end;
[/pascal]

And then you dont need to do fancy tricks reading off the stream as every record is the same size.

[tanffn]

That’s a nice idea but it works for simple objects, as the more complex are the object the more overhead you’ll get.
but its a good idea to keep in mind

[arthurprs]

cairnswm code is a variant record, whats the problem with then?

of course they are not good for complex objects but they are very simple and easy to manage

[tanffn]

No problem with them, simply not what I want to do
I am reading a few articles about networking. I’ll post my finding in a separate post.

[Brainer]

I'm not a networking guru, but I'd like to share my knowledge with you.

In past few years I worked with two ways of dealing with the networking. The first way was based on strings. Consider this:

Packet Type|User ID|Param Count|Param0|Param1...|Paramn

Using strings like that you can transfer data pretty easily. Look at this example:
[pascal]
const
PACKET_TYPE_LOGIN = 'LOG';
PACKET_TYPE_LOGOFF = 'OFF';
PACKET_TYPE_CHAT = 'CHT';
PACKET_TYPE_MOVE = 'MOV';
PACKET_TYPE_SHOOT = 'SHT';

var
Msg: ShortString;
UserID: Integer;
begin
UserID := 20;
Msg := PACKET_TYPE_LOGOFF + '|' + IntToStr(UserID) + '|' + '0';
end;
[/pascal]
This is an example of the message send to the server when user tries to log off. As for the server, it could use something like that to read the data:
[pascal]
const
PACKET_TYPE_LOGIN = 'LOG';
PACKET_TYPE_LOGOFF = 'OFF';
PACKET_TYPE_CHAT = 'CHT';
PACKET_TYPE_MOVE = 'MOV';
PACKET_TYPE_SHOOT = 'SHT';

procedure Split(const AOutput: TStrings; const AText, ASeparator: String);
var
S1, S2: string;
begin
AOutput.Clear();
S2 := AText + ASeparator;
repeat
S1 := Copy(S2, 0, Pos(ASeparator, S2) - 1);
AOutput.Add(S1);
Delete(S2, 1, Length(S1 + ASeparator));
until (S2 = '');
end;

var
RcvdMsg: String;
SL: TStringList;
begin
// before calling this, RcvdMsg has to be filled with data
Split(SL, RcvdMsg, '|');

// check if the packet type is logging in
if (SL[0] = PACKET_TYPE_LOGOFF) then
begin
if not UserList.UserConnected(SL[1]) then // user is connected
exit;
if (StrToInt(SL[2]) <> 0) then // invalid paramater count
exit;
UserList.Delete(StrToInt(SL[1]));
end;

end;
[/pascal]
I think this way is good for small games.

Another idea is to use variant records. I think someone has mentioned an example of a variant record before, yet I'm doing it again:
[pascal]
type
{ .: TPacketType :. }
TPacketType = (ptLogin, ptLogoff, ptChat, ptMove, ptShoot);

{ .: TPacket :. }
TPacket = packed record
PkgType: TPacketType;
UserID: Integer;
case TPacketType of
ptLogin: (Login: String[15]; Password: String[15]);
ptChat: (Destination: String[15]; ChatText: String[255]);
ptMove: (X, Z: Single);
ptShoot: (StartX, StartZ: Single);
end;
[/pascal]
Personally, I'd stick with variant records, because the size of the record is always the same, no matter what type it is.

Now, let's compare the bandwidth used by both solutions. With strings, it varies, because it depends on the packet type. But let's assume that each packet is 255 bytes. It's around 21,5 MB/day for one person. Similar situation is with variant record. Its size is 277 bytes and the bandwidth is around 23,3 MB/day. It's quite a lot, but with records, you can reduce the size by using Word type instead of Integer.

Correct me if I'm wrong.

[paul_nicholls]

Hi guys,
I am definitely not a networking guru either, but I have whipped up a quick example of a possible way to do the packets which should be very flexible too.

see the code below:

Unit packet_types;
{$IFDEF fpc}
{$MODE DELPHI} {$H+}
{$ENDIF}
Interface

Type
{..............................................................................}
    TPacketType = (
        ePacketType_Login,
        ePacketType_Logoff,
        ePacketType_Chat
    );
    TPacket = Packed Record
        PacketType : TPacketType;
    End;
    TPacket_Login = Packed Record
        PacketType : TPacketType;
        Username   : String[15];
        Password   : String[15];
    End;
    TPacket_Logoff = Packed Record
        PacketType : TPacketType;
        Username   : String[15];
        Password   : String[15];
    End;
    TPacket_Chat = Packed Record
        PacketType : TPacketType;
        Msg        : ShortString;
    End;
    PPacket        = ^TPacket;
    PPacket_Login  = ^TPacket_Login;
    PPacket_Logoff = ^TPacket_Logoff;
    PPacket_Chat   = ^TPacket_Chat;
{..............................................................................}

Implementation

End.

Unit packet_classes;
{$IFDEF fpc}
{$MODE DELPHI} {$H+}
{$ENDIF}
Interface

Uses
    packet_types;

Type
{..............................................................................}
    TPacketReader = Class
    Private
    Protected
        Function  ReadData(Const AData : Pointer; Const ADataSize : LongInt) : Boolean;  Virtual;
    Public
        Function  ReadPacket(Var APacket : Pointer) : Boolean;
        Procedure FreePacket(Var APacket : Pointer);
    End;
{..............................................................................}

{..............................................................................}
    TPacketWriter = Class
    Private
        Function  WritePacket(Const APacket : PPacket) : Boolean;
    Protected
        Function  WriteData(Const AData : Pointer; Const ADataSize : LongInt) : Boolean; Virtual;
    Public
        Function  WriteLoginPacket (Const AUserName,APassWord : AnsiString) : Boolean;
        Function  WriteLogoffPacket(Const AUserName,APassWord : AnsiString) : Boolean;
        Function  WriteChatPacket  (Const AMsg                : AnsiString) : Boolean;
    End;
{..............................................................................}


Implementation

{..............................................................................}

{..............................................................................}
Function TPacketWriter.WriteData(Const AData : Pointer; Const ADataSize : LongInt) : Boolean;
Begin
    Result := False;
    {Write ADataASize bytes from AData to the network and return true if successfull}
    {override this in descendent classes}
End;
{..............................................................................}

{..............................................................................}
Function TPacketReader.ReadData(Const AData : Pointer; Const ADataSize : LongInt) : Boolean;
Begin
    Result := False;
   {fill AData with ADataSize bytes from the network and return true if successfull}
    {override this in descendent classes}
End;
{..............................................................................}

{..............................................................................}
Function TPacketReader.ReadPacket(Var APacket : Pointer) : Boolean;
Var
    DataSize : LongInt;
    Packet   : Pointer;
Begin
    Result := False;
    If Not ReadData(@DataSize,SizeOf(DataSize)) Then Exit;
    GetMem(Packet,DataSize);
    If Not ReadData(Packet,DataSize) Then
    Begin
        FreeMem(Packet);
        Exit;
    End;
    APacket := Packet;
    Result  := True;
End;
{..............................................................................}

{..............................................................................}
Procedure TPacketReader.FreePacket(Var APacket : Pointer);
Begin
    If APacket = Nil Then Exit;
    FreeMem(APacket);
    APacket := Nil;
End;
{..............................................................................}

{..............................................................................}
Function  TPacketWriter.WritePacket(Const APacket : PPacket) : Boolean;
Var
    DataSize : LongInt;
Begin
    Result := False;
    Case APacket^.PacketType Of
        ePacketType_Login  : DataSize := SizeOf(TPacket_Login);
        ePacketType_Logoff : DataSize := SizeOf(TPacket_Logoff);
        ePacketType_Chat   : DataSize := SizeOf(TPacket_Chat);
    Else
        Exit;
    End;
    If Not WriteData(@DataSize,SizeOf(DataSize)) Then Exit;
    If Not WriteData(APacket,DataSize)           Then Exit;
    Result := True;
End;
{..............................................................................}

{..............................................................................}
Function  TPacketWriter.WriteLoginPacket(Const AUserName,APassWord : AnsiString) : Boolean;
Var
    LoginPacket : TPacket_Login;
Begin
    LoginPacket.PacketType := ePacketType_Login;
    LoginPacket.Username   := AUserName;
    LoginPacket.PassWord   := APassWord;
    Result := WritePacket(@LoginPacket);
End;
{..............................................................................}

{..............................................................................}
Function  TPacketWriter.WriteLogoffPacket(Const AUserName,APassWord : AnsiString) : Boolean;
Var
    LogoffPacket : TPacket_Logoff;
Begin
    LogoffPacket.PacketType := ePacketType_Logoff;
    LogoffPacket.Username   := AUserName;
    LogoffPacket.PassWord   := APassWord;
    Result := WritePacket(@LogoffPacket);
End;
{..............................................................................}

{..............................................................................}
Function  TPacketWriter.WriteChatPacket(Const AMsg : AnsiString) : Boolean;
Var
    ChatPacket : TPacket_Chat;
Begin
    ChatPacket.PacketType := ePacketType_Chat;
    ChatPacket.Msg        := AMsg;
    Result := WritePacket(@ChatPacket);
End;
{..............................................................................}

{..............................................................................}
End.

Example usage:

Type
{..............................................................................}
    TPacketReader_Stream = Class(TPacketReader)
    Private
        FStream : TStream;
    Protected
        Function ReadData(Const AData : Pointer; Const ADataSize : LongInt) : Boolean;  Override;
    Public
        Constructor Create(Const AStream : TStream);
    End;
{..............................................................................}

{..............................................................................}
    TPacketWriter_Stream = Class(TPacketWriter)
    Private
        FStream : TStream;
    Protected
        Function WriteData(Const AData : Pointer; Const ADataSize : LongInt) : Boolean; Override;
    Public
        Constructor Create(Const AStream : TStream);
    End;
{..............................................................................}

Constructor TPacketReader_Stream.Create(Const AStream : TStream);
Begin
    Inherited Create;
    FStream := AStream;
End;
{..............................................................................}

{..............................................................................}
Function TPacketReader_Stream.ReadData(Const AData : Pointer; Const ADataSize : LongInt) : Boolean;
Type
    PByte = ^Byte;
Begin
    Result := FStream.Read(PByte(AData)^,ADataSize) = ADataSize;
End;
{..............................................................................}

{..............................................................................}
Constructor TPacketWriter_Stream.Create(Const AStream : TStream);
Begin
    Inherited Create;
    FStream := AStream;
End;
{..............................................................................}

{..............................................................................}
Function TPacketWriter_Stream.WriteData(Const AData : Pointer; Const ADataSize : LongInt) : Boolean;
Type
    PByte = ^Byte;
Begin
    Result := FStream.Write(PByte(AData)^,ADataSize) = ADataSize;
End;
{..............................................................................}

{..............................................................................}
Procedure WritePackets(Const APacketWriter : TPacketWriter);
Begin
    APacketWriter.WriteLoginPacket ('UserName','PassWord');
    APacketWriter.WriteChatPacket  ('Message#1');
    APacketWriter.WriteChatPacket  ('Message#2');
    APacketWriter.WriteChatPacket  ('Message#3');
    APacketWriter.WriteChatPacket  ('Message#4');
    APacketWriter.WriteChatPacket  ('Message#5');
    APacketWriter.WriteChatPacket  ('Message#6');
    APacketWriter.WriteLogoffPacket('UserName','PassWord');
End;
{..............................................................................}

{..............................................................................}
Procedure ProcessLoginPacket(Const APacket : PPacket_Login);
Begin
    WriteLn('Login Packet:');
    WriteLn('  ',APacket^.UserName);
    WriteLn('  ',APacket^.PassWord);
End;
{..............................................................................}

{..............................................................................}
Procedure ProcessLogoffPacket(Const APacket : PPacket_Logoff);
Begin
    WriteLn('Logoff Packet:');
    WriteLn('  ',APacket^.UserName);
    WriteLn('  ',APacket^.PassWord);
End;
{..............................................................................}

{..............................................................................}
Procedure ProcessChatPacket(Const APacket : PPacket_Chat);
Begin
    WriteLn('Chat Packet: ');
    WriteLn('  ',APacket^.Msg);
End;
{..............................................................................}

{..............................................................................}
Procedure ReadPackets(Const APacketReader : TPacketReader);
Var
    Packet : Pointer;
Begin
    While APacketReader.ReadPacket(Packet) Do
    Begin
        Case PPacket(Packet)^.PacketType Of
            ePacketType_Login  : ProcessLoginPacket (Packet);
            ePacketType_Logoff : ProcessLogoffPacket(Packet);
            ePacketType_Chat   : ProcessChatPacket  (Packet);
        Else
            {unknown packet so do error or something}
        End;
        APacketReader.FreePacket(Packet);
    End;
End;
{..............................................................................}

{..............................................................................}
Var
    PacketReader : TPacketReader;
    PacketWriter : TpacketWriter;
    MemoryStream : TMemoryStream;
begin
    MemoryStream := TMemoryStream.Create;
    PacketWriter := TPacketWriter_Stream.Create(MemoryStream);
    PacketReader := TPacketReader_Stream.Create(MemoryStream);
    WritePackets(PacketWriter);
    MemoryStream.Position := 0;
    ReadPackets(PacketReader);
    MemoryStream.Free;
    WriteLn('Finished!');
    ReadLn;
End.

It does work (I tried it on a Stream packet reader writer descendants as a test), and should be easy to modify.
It should be fairly easy to make TPacketReader/Writer descendants to read and write from sockets too (synapse, indy, etc).

cheers,
Paul