clientinterpreter.pas

一般的数据库管理系统 uses Classes, SConnectEx, TltConst, ExtCtrls, MMSystem, Types, windows, TltLogic , Sy

unit ClientInterpreter;
{Tlt logic layer}
interface
uses Classes, SConnect, TltConst, ExtCtrls, rltgame;
type
  TrltClientInterpreter = class(TDataBlockInterpreter)
    function DoCustomAction(Action: Integer; const Data: IDataBlock): Boolean; override;
  private
    function CallGetCurrentRoundNo: integer;
  public
    {Receiving Calls}
    //do game round
    procedure DoSetCountDown(const Data: IDataBlock);
    //do player manage
    procedure DoLoginPlayer(const Data: IDataBlock) ;
//    procedure DoLogoffPlayer(const Data: IDataBlock);
//    procedure DoResetRound(const Data: IDataBlock);
    procedure DoSetRound(const Data: IDataBlock);
    procedure DoTimeSetting(const Data: IDataBlock);
    procedure DoBet(const Data: IDataBlock);
    procedure DoPlayerInfo(const Data: IDataBlock);
    procedure DoWheelParams(const Data: IDataBlock);
    procedure DoLogout(const Data: IDataBlock);





//    procedure DoResetRound(const Data: IDataBlock);
    {Sending Calls}
    //get info
    function CallGetServerInfo : TServerInfo;
    function CallGetCurrentRound : TRound;
    function CallGetTimeSetting :TTimeSetting;
    function CallLoginPlayer(PlayerID, Password : String): boolean;
    function CallLogoffPlayer(PlayerID : String): boolean;
    function CallGetPlayerInfo(PlayerID : String) : TPlayerInfo;
    function CallGetScore(RoundNo, WheelNo: integer) : TRoundScord;
    function CallGetWheelParams : TWheelParams ;



    //player
//    function LoginPlayer(APlayer : TPlayer): boolean;
//    procedure LogoffPlayer(APlayer : TPlayer);
    function CallBet(APlayer : TPlayer): boolean;
//    function LoginPlayer

  end;

  TrltSocketConnection = class(TSocketConnection)
  private
    FInterpreter : TrltClientInterpreter;
  protected
    function GetInterpreter: TCustomDataBlockInterpreter; override;

  end;





implementation
uses ScktCnst, rltClient;


{ TTltInterpreter }

function TrltClientInterpreter.CallGetServerInfo: TServerInfo;
var
  Data: IDataBlock;
  Size : integer;
  s : TServerInfo;
begin
  Data := TDataBlock.Create as IDataBlock;
  Data.Signature := CallSig or asGetServerInfo;
  Data := FSendDataBlock.Send(Data, True);
  Data.Read(size, sizeof(size));
  Data.Read(s,Size);
  Result := s;
//  Result := ReadVariant(Flags, Data);
end;

function TrltClientInterpreter.CallGetCurrentRoundNo: integer;
var
  Data: IDataBlock;
  Size : integer;
  s : integer;
begin
  Data := TDataBlock.Create as IDataBlock;
  Data.Signature := CallSig or asGetCurrentRound;
  Data := FSendDataBlock.Send(Data, True);
  Data.Read(size, sizeof(size));
  Data.Read(s,Size);
  Result := s;
//  Result := ReadVariant(Flags, Data);
end;


function TrltClientInterpreter.DoCustomAction(Action: Integer;
  const Data: IDataBlock): Boolean; 
begin
  inherited DoCustomAction(Action, Data);
  case (Action and asMask) of
    //client
    asSetCountDown : DoSetCountDown(Data);
    asSetRound : DoSetRound(Data);
    asTimeSetting : DoTimeSetting(Data);
    asBet : DoBet(Data);
    asPlayerInfo : DoPlayerInfo(Data);
    asWheelParams : DoWheelParams(Data);
    asLogoffPlayer : DoLogout(Data);

  else
    Result := false;
  end;
end;





procedure TrltClientInterpreter.DoSetCountDown(const Data: IDataBlock);
var
  VarSize : integer;
  VarFlag : TVarFlags;
begin
  rlt.Round.CountDown := ReadVariant(VarFlag, Data);
end;

{ TrltSocketConnetion }

function TrltSocketConnection.GetInterpreter: TCustomDataBlockInterpreter;
begin
  if not Assigned(FInterpreter) then
  FInterpreter := TrltClientInterpreter.Create(Self, SSockets);
  Result := FInterpreter;

end;

function TrltClientInterpreter.CallBet(APlayer: TPlayer): boolean;
var
  Data: IDataBlock;
  Size : integer;
  s : boolean;
  Flays : TVarFlags;
begin
  Data := TDataBlock.Create as IDataBlock;
  Data.Signature := CallSig or asBet;
  WriteVariant(APlayer.UserID, Data);
  WriteVariant(APlayer.RBet, Data);
  WriteVariant(APlayer.BBet, Data);
  WriteVariant(APlayer.GBet, Data);
  Data := FSendDataBlock.Send(Data, false);
end;

procedure TrltClientInterpreter.DoLoginPlayer(const Data: IDataBlock);
var
  IsLogined : boolean;
  VarFlag : TVarFlags;
  VarSize : integer;
begin
  //check is logined
  IsLogined := ReadVariant(VarFlag, Data);
  //active player
  //
end;

function TrltClientInterpreter.CallGetCurrentRound: TRound;
var
  Data: IDataBlock;
  VarSize : integer;
  VarFlag : TVarFlags;
begin
  Data := TDataBlock.Create as IDataBlock;
  Data.Signature := CallSig or asGetCurrentRound;
  Data := FSendDataBlock.Send(Data, True);
  Data.Read(VarSize, sizeof(VarSize));
  Data.Read(Result, VarSize);
end;

procedure TrltClientInterpreter.DoTimeSetting(const Data: IDataBlock);
var
  VarSize : integer;
  VarFlag : TVarFlags;
begin
  Data.Read(VarSize, sizeof(VarSize));
  Data.Read(rlt.TimeSetting, VarSize);
end;

function TrltClientInterpreter.CallGetTimeSetting: TTimeSetting;
var
  Data: IDataBlock;
  Size : integer;
  s : TTimeSetting;
begin
  Data := TDataBlock.Create as IDataBlock;
  Data.Signature := CallSig or asTimeSetting;
  Data := FSendDataBlock.Send(Data, True);
  Data.Read(size, sizeof(size));
  Data.Read(s,Size);
  Result := s;

end;

function TrltClientInterpreter.CallLoginPlayer(PlayerID, Password : String): boolean;
var
  Data: IDataBlock;
  Size : integer;
  s : boolean;
  Flays : TVarFlags;
begin
  Data := TDataBlock.Create as IDataBlock;
  Data.Signature := CallSig or asLoginPlayer;
  WriteVariant(PlayerID, Data);
  WriteVariant(Password, Data);
  Data := FSendDataBlock.Send(Data, True);
  Result :=  ReadVariant(Flays, Data);
end;

function TrltClientInterpreter.CallGetPlayerInfo(
  PlayerID: String): TPlayerInfo;
var
  Data: IDataBlock;
  Size : integer;
  s : boolean;
  Flays : TVarFlags;
begin
  Data := TDataBlock.Create as IDataBlock;
  Data.Signature := CallSig or asPlayerInfo;
  WriteVariant(PlayerID, Data);
  Data := FSendDataBlock.Send(Data, True);
  Data.Read(Size, sizeof(Size));
  if Size< sizeof(Result) then
  begin
    FillChar(Result, sizeof(Result), #0);
    Exit;
  end;
  Data.Read(Result, Size);
end;


procedure TrltClientInterpreter.DoBet(const Data: IDataBlock);
var
  VarSize : integer;
  VarFlag : TVarFlags;
  RBet, BBet, GBet : longint;
  Result : boolean;
  PlayerID : String;
  APlayer : TPlayer;
  I : integer;
begin
  PlayerID := ReadVariant(VarFlag, Data);
  Result := ReadVariant(VarFlag, Data);
  RBet := ReadVariant(VarFlag, Data);
  BBet := ReadVariant(VarFlag, Data);
  GBet := ReadVariant(VarFlag, Data);
  APlayer := nil;
  for i := low(Players) to High(Players) do
  begin
    if PlayerID = Players[i].UserID then APlayer := Players[I];
    if APlayer <> nil then
    if not Result then
    begin
      APlayer.RBet := RBet;
      APlayer.GBet := GBet;
      APlayer.BBet := BBet;
      APlayer.Modified := false;
    end;
  end;
end;

function TrltClientInterpreter.CallLogoffPlayer(PlayerID : String): boolean;
var
  Data: IDataBlock;
  Size : integer;
  s : boolean;
  Flays : TVarFlags;
begin
  Data := TDataBlock.Create as IDataBlock;
  Data.Signature := CallSig or asLogoffPlayer;
  WriteVariant(PlayerID, Data);
  Data := FSendDataBlock.Send(Data, True);
  Result :=  ReadVariant(Flays, Data);
end;


procedure TrltClientInterpreter.DoPlayerInfo(const Data: IDataBlock);
var
  PlayInfo : TPlayerInfo;
  Size : integer;
  APlayer : TPlayer;
  I : integer;
begin
  Data.Read(Size, sizeof(Size));
  Data.Read(PlayInfo, Size);
  APlayer := nil;
  for i := low(Players) to High(Players) do
  begin
    if PlayInfo.ID = Players[i].UserID then
    begin
      APlayer := Players[I];
      if APlayer <> nil then
      with PlayInfo do
      begin
        APlayer.money := money;
        APlayer.RBet := Bet[btRed];
        APlayer.GBet := Bet[btBlack];
        APlayer.BBet := Bet[btGreen];
        APlayer.State := State;
        APlayer.Modified := false;
      end;
    end;
  end;
end;

function TrltClientInterpreter.CallGetScore(RoundNo,
  WheelNo: integer): TRoundScord;
var
  Data: IDataBlock;
  Size : integer;
  s : boolean;
  Flays : TVarFlags;
begin
  Data := TDataBlock.Create as IDataBlock;
  Data.Signature := CallSig or asGetRoundScord;
  WriteVariant(RoundNo, Data);
  WriteVariant(WheelNo, Data);
  Data := FSendDataBlock.Send(Data, True);
  Data.Read(Size, sizeof(Size));
  Data.Read(Result, Size);
end;

function TrltClientInterpreter.CallGetWheelParams: TWheelParams;
var
  Data: IDataBlock;
  Size : integer;
  s : boolean;
  Flays : TVarFlags;
begin
  Data := TDataBlock.Create as IDataBlock;
  Data.Signature := CallSig or asWheelParams;
  Data := FSendDataBlock.Send(Data, True);
  Data.Read(Size, sizeof(Size));
  Data.Read(Result, Size);
end;

procedure TrltClientInterpreter.DoWheelParams(const Data: IDataBlock);
var
  Size : integer;
  I : integer;
begin
  Data.Read(Size, sizeof(Size));
  Data.Read(rlt.WheelParams, Size);
  rlt.UpdateWheelParams;
end;

procedure TrltClientInterpreter.DoLogout(const Data: IDataBlock);
var
  CPlayerID : String;
  Flags : TVarFlags;
  I : integer;
begin
  CPlayerID := ReadVariant(Flags, Data);
  for i := 0 to 3 do
  begin
    if Players[i].UserID = CPlayerID then
    begin
      PlayerPanel[i].State := ppsLoginOtherWay;
      PlayerPanel[i].UserName := '';
      with Players[i] do
      begin
        Password := '';
        UserID := '';
        money := 0;
      end;
    end;
  end;
end;

procedure TrltClientInterpreter.DoSetRound(const Data: IDataBlock);
var
  VarSize : integer;
  VarFlag : TVarFlags;
  Round : TRound;
begin
  Data.Read(VarSize, sizeof(VarSize));
  Data.Read(Round, VarSize);
  rlt.SetRound(Round);

end;

end.