library HelloWorld;

uses
  PluginsShared in '..\ProtocolExtender\PluginsShared.pas',
  uMain in 'HelloWorld\uMain.pas';

{$E plg}
exports InitializationProc;
begin
end.

unit PluginsShared;

interface

const
  PF_REGISTERPACKETHANDLER: Cardinal = 1;
  PF_UNREGISTERPACKETHANDLER: Cardinal = 2;
  PF_REGISTERPACKETTYPE: Cardinal = 3; // Not supported right now. Reserved for futher use.
  PF_SENDPACKET: Cardinal = 4;

type
  TPacketHandler = function (Data: Pointer; var Size:Cardinal; var Send: Boolean; IsFromServerToClient: Boolean):Boolean stdcall;
  (**
    Send - Send this package to reciver.
    Result - If true - this event breaks bubbling.
    If Send = false then Result forced to true.
  **)

  RAPIFunc = record
    FuncType: Cardinal;
    Func: Pointer;
  End;
  PAPIFunc=^RAPIFunc;

  TInitializationProc = procedure (anAPIFunc: PAPIFunc) stdcall;

  TRegisterPacketHandler = procedure(Header:Byte; Handler: TPacketHandler) stdcall;
  TUnRegisterPacketHandler = procedure(Header: Byte; Handler: TPacketHandler) stdcall;
  TRegisterPacketType = procedure(Header:Byte; Size:Word) stdcall;
  TSendPacket = function(Packet: Pointer; Length: Cardinal; ToServer, Direct: Boolean; var Valid: Boolean):Boolean; stdcall;

implementation

end.

unit PluginAPI;

interface

uses PluginsShared;

type
  TPluginInitialization = procedure;

  TPluginApi = class
  private
    FRegisterPacketHandler: TRegisterPacketHandler;
    FUnRegisterPacketHandler: TUnRegisterPacketHandler;
    FSendPacket: TSendPacket;
  protected
    procedure RegisterAPIFunc(anAPIDescriptor: PAPIFunc);
  public
    procedure RegisterPacketHandler(Header:Byte; Handler: TPacketHandler);
    procedure UnRegisterPacketHandler(Header:Byte; Handler: TPacketHandler);
    function SendPacket(Packet: Pointer; Length: Cardinal; ToServer, Direct: Boolean; var Valid: Boolean):Boolean;
  end;

  procedure InitializationProc (anAPIFunc: PAPIFunc) stdcall;

var
  API : TPluginApi;
  PluginInitialization : TPluginInitialization;
  Initialized : Boolean;
  Initialazing : Boolean;

implementation

uses SysUtils;

// Procedures

procedure InitializationProc (anAPIFunc: PAPIFunc) stdcall;
begin
  API.RegisterAPIFunc(anAPIFunc);
  If anAPIFunc = nil Then Begin
    If not Initialazing Then Initialazing := True
    else Begin
      Initialazing := False;
      If Assigned(PluginInitialization) Then PluginInitialization();
      Initialized := True;
    End;
  End;
end;

// TPluginApi

procedure TPluginApi.RegisterAPIFunc(anAPIDescriptor: PAPIFunc);
begin
  If anAPIDescriptor = nil Then Exit;
  If anAPIDescriptor^.FuncType = PF_REGISTERPACKETHANDLER Then
    FRegisterPacketHandler := anAPIDescriptor^.Func
  Else If anAPIDescriptor^.FuncType = PF_UNREGISTERPACKETHANDLER Then
    FUnRegisterPacketHandler := anAPIDescriptor^.Func
  Else If anAPIDescriptor^.FuncType = PF_SENDPACKET Then
    FSendPacket := anAPIDescriptor^.Func
end;

procedure TPluginApi.RegisterPacketHandler(Header:Byte; Handler: TPacketHandler);
begin
  If @FRegisterPacketHandler = nil Then Raise Exception.Create('RegisterPacketHandler not supplied by host');
  FRegisterPacketHandler(Header, Handler);
end;

procedure TPluginApi.UnRegisterPacketHandler(Header:Byte; Handler: TPacketHandler);
begin
  If @FUnRegisterPacketHandler = nil Then Raise Exception.Create('UnRegisterPacketHandler not supplied by host');
  FUnRegisterPacketHandler(Header, Handler);
end;

function TPluginApi.SendPacket(Packet: Pointer; Length: Cardinal; ToServer, Direct: Boolean; var Valid: Boolean):Boolean;
begin
  If @FSendPacket = nil Then Raise Exception.Create('SendPacket not supplied by host');
  Result := FSendPacket(Packet, Length, ToServer, Direct, Valid);
end;

initialization
  API := TPluginApi.Create;
  PluginInitialization := nil;
finalization
  API.Free;
end.

library HelloWorld;

uses
  PluginsShared in '..\ProtocolExtender\PluginsShared.pas',
  PluginAPI in 'Common\PluginAPI.pas',
  uMain in 'HelloWorld\uMain.pas';

{$E plg}
exports InitializationProc;
begin
end.

unit uMain;

interface

implementation

uses Windows, WinSock, PluginAPI;

var
  HelloWorldPacket: Array [0..56] of Byte;

function HelloHandler(Data: Pointer; var Size:Cardinal; var Send: Boolean; IsFromServerToClient: Boolean):Boolean stdcall;
var
  isValid: Boolean;
begin
  API.UnRegisterPacketHandler($3A, @HelloHandler);
  API.SendPacket(@HelloWorldPacket, 57, False, True, isValid);
  Result := False;
end;

procedure Init;
var
  sDummy: String;
Begin
  API.RegisterPacketHandler($3A, @HelloHandler);

// Filling Hello world packet
  ZeroMemory(@HelloWorldPacket, 57);
  PByte(@HelloWorldPacket)^ :=  $1C; //Header (1Byte)
  PWord(Cardinal(@HelloWorldPacket) + 1)^ :=  htons(57); // SizeOfpacket (2Bytes)
  PCardinal(Cardinal(@HelloWorldPacket) + 3)^ :=  $FFFFFFFF; //Serial (4Bytes)
  PWord(Cardinal(@HelloWorldPacket) + 7)^ :=  $FFFF; // Graphic (2Bytes)
  PByte(Cardinal(@HelloWorldPacket) + 9)^ :=  $00; // MessageType (1Byte)
  PWord(Cardinal(@HelloWorldPacket) + 10)^ :=  htons($03B2); // Hue (2Bytes)
  PWord(Cardinal(@HelloWorldPacket) + 12)^ :=  htons($0003); // Font (2Bytes)
  sDummy := 'System';
  CopyMemory(PChar(Cardinal(@HelloWorldPacket) + 14), @sDummy[1], 6); // Name (30Bytes)
  sDummy := 'Hello World!' + #0;
  CopyMemory(PChar(Cardinal(@HelloWorldPacket) + 44), @sDummy[1], 12); // Message (Various)
End;

initialization
  PluginInitialization := @Init;
end.