www.pudn.com > Roulette.rar > ClientInterpreter.pas

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.