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

unit TltLogic; 
{Tlt logic layer} 
interface 
uses Classes, SConnectEx, TltConst, ExtCtrls, Forms, Dialogs, SysUtils, SyncObjs; 
type 
  TServerInfo = record 
    ServerVer : String[255]; 
  end; 
 
  TrltServerInterpreter = class(TDataBlockInterpreter) 
 
 
    FClient : Pointer; 
    FCriticalSection : TCriticalSection; 
 
    procedure CallProc(Proc : TClientProc); 
    function DoCustomAction(Action: Integer; const Data: IDataBlock): Boolean; override; 
  public 
    {Receiving Calls} 
    procedure DoGetServerInfo(const Data: IDataBlock); 
    procedure DoGetCurrentRound(const Data: IDataBlock); 
    procedure DoGetTimeSetting(const Data: IDataBlock); 
    procedure DoLoginPlayer(const Data: IDataBlock); 
    procedure DoLogoffPlay(const Data: IDataBlock); 
    procedure DoGetPlayerInfo(const Data: IDataBlock); 
    procedure DoBet(const Data: IDataBlock); 
    procedure DoGetScore(const Data: IDataBlock); 
    procedure DoGetWheelParams(const Data: IDataBlock); 
    procedure DoGetRoundInfo(const Data: IDataBlock); 
    procedure DoPlayerEdit(const Data:IDataBlock); 
    procedure DoGetPlayerList(const Data: IDataBlock); 
    procedure DoSetRoundResult(const Data: IDataBlock); 
    procedure DoGetGameParams(const Data: IDataBlock); 
    procedure DoSetGameParams(const Data: IDataBlock); 
    procedure DoGetRoundState(const Data: IDataBlock); 
    procedure DoSetRoundState(const Data: IDataBlock); 
    procedure DoGetRoundScordInfo(const Data: IDataBlock); 
    procedure DoUploadPlayerList(const Data: IDataBlock); 
    procedure DoGetRoundInfoLog(const Data: IDataBlock); 
    procedure DoGetPlayerBetInfoLog(const Data: IDataBlock); 
    procedure DoClearRoundInfoLog(const Data: IDataBlock); 
    procedure DoClearPlayerBetInfoLog(const Data: IDataBlock); 
    procedure DoClearPlayerList(const Data: IDataBlock); 
    procedure DoCheckAdmin(const Data: IDataBlock); 
    procedure DoLock(const Data: IDataBlock); 
    {Sending Calls} 
    function CallGetServerInfo : TServerInfo; 
    function CallGetCurrentRoundNo: integer; 
    {Sendto Client} 
    procedure CallSetCountDown; 
    procedure CallSetTimeSetting; 
    procedure CallSetRound; 
    procedure CallSetWheelResult; 
    procedure CallSetPlayerInfo(APlayer : TObject); 
    procedure CallSetWheelParams(WheelParams : TWheelParams); 
    procedure CallLogout(PlayerID: String); 
    procedure DoException(const Data: IDataBlock); override; 
    constructor Create(SendDataBlock: ISendDataBlock; 
      CheckRegValue: String); override; 
    destructor Destroy; override; 
  end; 
 
 
 
 
implementation 
uses ScktCnst, rltSvr; 
 
 
{ TTltInterpreter } 
 
function TrltServerInterpreter.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 TrltServerInterpreter.CallGetCurrentRoundNo: integer; 
var 
  Data: IDataBlock; 
  Size : integer; 
  s : integer; 
begin 
  FCriticalSection.Enter; 
  try 
    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; 
  finally 
    FCriticalSection.Leave; 
  end; 
//  Result := ReadVariant(Flags, Data); 
end; 
 
 
function TrltServerInterpreter.DoCustomAction(Action: Integer; 
  const Data: IDataBlock): Boolean;  
begin 
  FCriticalSection.Enter; 
  try 
    case (Action and asMask) of 
      asGetServerInfo: DoGetServerInfo(Data); 
      asGetCurrentRound : DoGetCurrentRound(Data); 
      asTimeSetting : DoGetTimeSetting(Data); 
      asLoginPlayer : DoLoginPlayer(Data); 
      asLogoffPlayer : DoLogoffPlay(Data); 
      asPlayerInfo : DoGetPlayerInfo(Data); 
      asBet : DoBet(Data); 
      asGetRoundScord : DoGetScore(Data); 
      asWheelParams : DoGetWheelParams(Data); 
      asGetRoundInfo : DoGetRoundInfo(Data); 
      asPlayerEdit : DoPlayerEdit(Data); 
      asPlayerList : DoGetPlayerList(Data); 
      asSetRoundResult : DoSetRoundResult(Data); 
      asGetGameParams : DoGetGameParams(Data); 
      asSetGameParams : DoSetGameParams(Data); 
      asGetRoundState : DoGetRoundState(Data); 
      asSetRoundState : DoSetRoundState(Data); 
      asUploadPlayerList : DoUploadPlayerList(Data); 
      asGetRoundLog : DoGetRoundInfoLog(Data); 
      asGetPlayerBetLog : DoGetPlayerBetInfoLog(Data); 
      asClearPlayerList : DoClearPlayerList(Data); 
      asClearPlayerBetLog : DoClearPlayerBetInfoLog(Data); 
      asClearGameLog : DoClearRoundInfoLog(Data); 
      asCheckAdmin : DoCheckAdmin(Data); 
      asLockServer : DoLock(Data); 
      1 :; 
    else 
      Result := false; 
    end; 
  finally 
    FCriticalSection.Leave; 
  end; 
end; 
 
procedure TrltServerInterpreter.DoGetServerInfo(const Data: IDataBlock); 
var 
  ServerInfo : TServerInfo; 
  VarSize : integer; 
begin 
  Data.Clear; 
  try 
    ServerInfo.ServerVer :='1.0'; 
  finally 
  end; 
  VarSize := sizeof(ServerInfo); 
  Data.Write(VarSize, sizeof(integer)); 
  Data.Write(ServerInfo, VarSize); 
  Data.Signature := ResultSig or asGetServers; 
  FSendDataBlock.Send(Data, False); 
end; 
 
procedure TrltServerInterpreter.DoGetCurrentRound(const Data: IDataBlock); 
var 
  Size : integer; 
begin 
  Data.Clear; 
  Size := SizeOf(TRound); 
  Data.Write(Size, SizeOf(Size)); 
  Data.Write(rltManager.Round,Size); 
  Data.Signature := ResultSig or asGetCurrentRound; 
  FSendDataBlock.Send(Data, False); 
end; 
 
 
procedure TrltServerInterpreter.CallSetCountDown; 
var 
  Data: IDataBlock; 
  Size : integer; 
  s : integer; 
begin 
  FCriticalSection.Enter; 
  try 
    Data := TDataBlock.Create as IDataBlock; 
    WriteVariant(rltManager.CountDown, Data); 
    Data.Signature := CallSig or asSetCountDown; 
 
    Data := FSendDataBlock.Send(Data, false); 
  finally 
    FCriticalSection.Leave; 
  end; 
end; 
 
procedure TrltServerInterpreter.CallProc(Proc: TClientProc); 
begin 
  if Assigned(Proc) then 
  begin 
    Proc; 
  end; 
 
end; 
 
procedure TrltServerInterpreter.CallSetTimeSetting; 
var 
  Data: IDataBlock; 
  Size : integer; 
  s : integer; 
begin 
  FCriticalSection.Enter; 
  try 
    Data := TDataBlock.Create as IDataBlock; 
    Size := Sizeof(rltManager.TimeSetting); 
    Data.Write(Size, Sizeof(Size)); 
    Data.Write(rltManager.TimeSetting, Size); 
    Data.Signature := CallSig or asTimeSetting; 
    Data := FSendDataBlock.Send(Data, false); 
  finally 
    FCriticalSection.Leave; 
  end; 
end; 
 
procedure TrltServerInterpreter.CallSetRound; 
var 
  Data: IDataBlock; 
  Size : integer; 
  s : integer; 
begin 
  FCriticalSection.Enter; 
  try 
    Data := TDataBlock.Create as IDataBlock; 
    Size := Sizeof(rltManager.Round); 
    Data.Write(Size, Sizeof(Size)); 
    Data.Write(rltManager.Round, Size); 
    Data.Signature := CallSig or asSetRound; 
    Data := FSendDataBlock.Send(Data, false); 
  finally 
    FCriticalSection.Leave;   
  end; 
end; 
 
procedure TrltServerInterpreter.DoGetTimeSetting(const Data: IDataBlock); 
var 
  Size : integer; 
  s : integer; 
begin 
  Size := Sizeof(rltManager.TimeSetting); 
  Data.Write(Size, Sizeof(Size)); 
  Data.Write(rltManager.TimeSetting, Size); 
  Data.Signature := ResultSig or asTimeSetting; 
  FSendDataBlock.Send(Data, false); 
end; 
 
procedure TrltServerInterpreter.DoException(const Data: IDataBlock); 
begin 
//  inherited; 
  //do nothing; 
 
end; 
 
procedure TrltServerInterpreter.DoLoginPlayer(const Data: IDataBlock); 
var 
  Size : integer; 
  s : integer; 
  PlayerID : String; 
  Password : String; 
  VarFlag : TVarFlags; 
  ResultValue : Boolean; 
begin 
  PlayerID := ReadVariant(VarFlag, Data); 
  Password := ReadVariant(VarFlag, Data); 
  ResultValue := rltManager.LoginPlayer(PlayerID, password, TTltClient(FClient)); 
  Data.Clear; 
  WriteVariant(ResultValue, Data); 
  Data.Signature := ResultSig or asLoginPlayer; 
  FSendDataBlock.Send(Data, false); 
end; 
 
procedure TrltServerInterpreter.DoLogoffPlay(const Data: IDataBlock); 
var 
  Size : integer; 
  s : integer; 
  PlayerID : String; 
  Password : String; 
  VarFlag : TVarFlags; 
  ResultValue : Boolean; 
begin 
  PlayerID := ReadVariant(VarFlag, Data); 
  rltManager.LogoffPlayer(PlayerID); 
  Data.Clear; 
  WriteVariant(true, Data); 
  Data.Signature := ResultSig or asLogOffPlayer; 
  FSendDataBlock.Send(Data, false); 
end; 
 
constructor TrltServerInterpreter.Create(SendDataBlock: ISendDataBlock; 
  CheckRegValue: String); 
begin 
  inherited; 
  FClient := Pointer(TTltClient.Create(rltManager)); 
  TTltClient(FClient).Interpreter := Self; 
  FCriticalSection := TCriticalSection.Create; 
end; 
 
procedure TrltServerInterpreter.DoGetPlayerInfo(const Data: IDataBlock); 
var 
  Size : integer; 
  s : integer; 
  Player : TPlayer; 
  PlayerID : String; 
  VarFlag : TVarFlags; 
  PlayerInfo : TPlayerInfo; 
begin 
  PlayerID := ReadVariant(VarFlag, Data); 
  Data.Clear; 
  Player := rltManager.GetPlayerByID(PlayerID); 
  if Player <> nil then PlayerInfo := Player.GetPlayerInfo 
  else 
  begin 
    PlayerInfo.ID := PlayerID; 
    PlayerInfo.money := 0; 
    PlayerInfo.State := psLoginError; 
  end; 
  Size := sizeof(PlayerInfo); 
  Data.Write(Size, Sizeof(Size)); 
  Data.Write(PlayerInfo, size); 
  Data.Signature := ResultSig or asPlayerInfo; 
  FSendDataBlock.Send(Data, false); 
 
end; 
 
destructor TrltServerInterpreter.Destroy; 
begin 
  TTltClient(FClient).Free; 
  FCriticalSection.Free;   
  inherited; 
end; 
 
procedure TrltServerInterpreter.DoBet(const Data: IDataBlock); 
var 
  Size : integer; 
  s : integer; 
  Player : TPlayer; 
  PlayerID : String; 
  VarFlag : TVarFlags; 
  Result : boolean; 
  RBet, BBet, GBet:longint; 
begin 
  PlayerID := ReadVariant(VarFlag, Data); 
  RBet := ReadVariant(VarFlag, Data); 
  BBet := ReadVariant(VarFlag, Data); 
  GBet := ReadVariant(VarFlag, Data); 
  Data.Clear; 
  Result := false; 
  Player := rltManager.GetPlayerByID(PlayerID); 
  if Player <> nil then 
  begin 
    Result := true; 
    if (RBet + BBet + GBet)>Player.Money then 
    begin 
      Result := false; 
      with Player do 
      begin 
        RBet := Player.Bet[btRed]; 
        BBet := Player.Bet[btBlack]; 
        GBet := Player.Bet[btGreen]; 
      end; 
 
    end 
    else 
    begin 
      with Player do 
      begin 
        Player.Bet[btRed] := RBet; 
        Player.Bet[btBlack] := BBet; 
        Player.Bet[btGreen]:= GBet; 
      end; 
    end; 
  end 
  else 
  begin 
    Result := false; 
  end; 
  WriteVariant(PlayerID, Data); 
  WriteVariant(Result, Data); 
  WriteVariant(RBet, Data); 
  WriteVariant(BBet, Data); 
  WriteVariant(GBet, Data); 
  Data.Signature := ResultSig or asBet; 
  FSendDataBlock.Send(Data, false); 
end; 
 
procedure TrltServerInterpreter.CallSetWheelResult; 
var 
  Data: IDataBlock; 
  Size : integer; 
  s : integer; 
begin 
  FCriticalSection.Enter; 
  try 
    Data := TDataBlock.Create as IDataBlock; 
    WriteVariant(rltManager.WheelResult, Data); 
    Data.Signature := CallSig or asWheelResult; 
    Data := FSendDataBlock.Send(Data, false); 
  finally 
    FCriticalSection.Leave; 
  end; 
end; 
 
procedure TrltServerInterpreter.CallSetPlayerInfo(APlayer: TObject); 
var 
  Data: IDataBlock; 
  Size : integer; 
  s : integer; 
  PlayerID : String; 
  VarFlag : TVarFlags; 
  PlayerInfo : TPlayerInfo; 
begin 
  FCriticalSection.Enter; 
  try 
    Data := TDataBlock.Create as IDataBlock; 
    with TPlayer(APlayer) do 
    begin 
      PlayerInfo := GetPlayerInfo; 
      Size := sizeof(PlayerInfo); 
      Data.Write(Size, Sizeof(Size)); 
      Data.Write(PlayerInfo, size); 
      Data.Signature := CallSig or asPlayerInfo; 
      Data := FSendDataBlock.Send(Data, false); 
    end; 
  finally 
    FCriticalSection.Leave; 
  end; 
end; 
 
procedure TrltServerInterpreter.DoGetScore(const Data: IDataBlock); 
var 
  Size : integer; 
  s : integer; 
  PlayerID : String; 
  VarFlag : TVarFlags; 
  RoundNo, WheelNo : integer; 
begin 
  RoundNo := ReadVariant(VarFlag, Data); 
  WheelNo := ReadVariant(VarFlag, Data); 
  Data.Clear; 
  Size := sizeof(TRoundScord); 
  Data.Write(Size, Sizeof(Size)); 
  Data.Write(rltManager.RoundScords[RoundNo], size); 
  Data.Signature := ResultSig or asGetRoundScord; 
  FSendDataBlock.Send(Data, false); 
end; 
 
procedure TrltServerInterpreter.DoGetWheelParams(const Data: IDataBlock); 
var 
  Size : integer; 
  s : integer; 
  PlayerID : String; 
  VarFlag : TVarFlags; 
  RoundNo, WheelNo : integer; 
begin 
  Data.Clear; 
  rltManager.UpDateWheelParams; 
  Size := sizeof(TWheelParams); 
  Data.Write(Size, Sizeof(Size)); 
  Data.Write(rltManager.WheelParams, size); 
  Data.Signature := ResultSig or asWheelParams; 
  FSendDataBlock.Send(Data, false); 
end; 
 
procedure TrltServerInterpreter.CallSetWheelParams( 
  WheelParams: TWheelParams); 
var 
  Data: IDataBlock; 
  Size : integer; 
  VarFlag : TVarFlags; 
 
begin 
  FCriticalSection.Enter; 
  try 
    Data := TDataBlock.Create as IDataBlock; 
    Size := sizeof(TWheelParams); 
    Data.Write(Size, Sizeof(Size)); 
    Data.Write(WheelParams, size); 
    Data.Signature := CallSig or asWheelParams; 
    Data := FSendDataBlock.Send(Data, false); 
  finally 
    FCriticalSection.Leave; 
  end; 
end; 
 
type 
  TArrayInteger = array of integer; 
  PArrayInteger = ^TArrayInteger; 
 
procedure TrltServerInterpreter.DoGetRoundInfo(const Data: IDataBlock); 
var 
  Size : integer; 
  s : integer; 
  PlayerID : String; 
  VarFlag : TVarFlags; 
  RoundNo, WheelNo : integer; 
  RoundInfo : TRoundInfo; 
  ExpectedValue :array[TBetType] of longint; 
 
begin 
  Data.Clear; 
  FillChar(RoundInfo, sizeof(RoundInfo), #0); 
 
  RoundInfo.CurrentRound := rltManager.Round; 
  move( rltManager.BetCount,RoundInfo.CurrentBetCount, sizeof(rltManager.BetCount)); 
//  RoundInfo.CurrentBetCount[0] := rltManager.BetCount[btRed]; 
//  RoundInfo.CurrentBetCount[1] := rltManager.BetCount[btBlack]; 
//  RoundInfo.CurrentBetCount[2] := rltManager.BetCount[btGreen]; 
  RoundInfo.TotalBetCount[0] :=0; 
  RoundInfo.TotalBetCount[1] := 0; 
  RoundInfo.TotalBetCount[2] := 0; 
  with rltManager do 
  begin 
    ExpectedValue[btRed] := - BetCount[btRed] + BetCount[btBlack] + BetCount[btGreen]; 
    ExpectedValue[btBlack] :=  BetCount[btRed] - BetCount[btBlack] + BetCount[btGreen]; 
    ExpectedValue[btGreen] :=  BetCount[btRed] + BetCount[btBlack] - BetCount[btGreen] * 35; 
  end; 
 
  RoundInfo.WillValue[0] := ExpectedValue[btRed]; 
  RoundInfo.WillValue[1] := ExpectedValue[btBlack]; 
  RoundInfo.WillValue[2] := ExpectedValue[btGreen]; 
  RoundInfo.WillResult := rltManager.Round.WheelResult; 
  RoundInfo.MaxBetCount[0] := 0; 
  RoundInfo.MaxBetCount[1] := 0; 
  RoundInfo.MaxBetCount[2] := 0; 
  RoundInfo.ObjectValue := rltManager.ObjectValue; 
  RoundInfo.TotalValue := rltManager.TotalValue; 
  if RoundInfo.CurrentRound.No+RoundInfo.CurrentRound.WheelNo>2 then 
  begin 
    if RoundInfo.CurrentRound.WheelNo=1 then 
      RoundInfo.OldResult := rltManager.RoundScords[RoundInfo.CurrentRound.No-1].Number[50] 
    else 
      RoundInfo.OldResult := 
        rltManager.RoundScords[RoundInfo.CurrentRound.No].Number[RoundInfo.CurrentRound.WheelNo-1]; 
  end; 
  Size := sizeof(TRoundInfo); 
  Data.Write(Size, Sizeof(Size)); 
  Data.Write(RoundInfo, size); 
  Data.Signature := ResultSig or asGetRoundInfo; 
  FSendDataBlock.Send(Data, false); 
end; 
 
procedure TrltServerInterpreter.DoPlayerEdit(const Data: IDataBlock); 
var 
  Size : integer; 
  s : integer; 
  PlayerID : String; 
  VarFlag : TVarFlags; 
  RoundNo, WheelNo : integer; 
  PlayerEditInfo : TPlayerEditInfo; 
begin 
  Data.Read(Size, sizeof(Size)); 
  Data.Read(PlayerEditInfo, Size); 
  Data.Clear; 
  PlayerEditInfo := rltManager.DoPlayerEdit(PlayerEditInfo); 
  Size := sizeof(PlayerEditInfo); 
  Data.Write(Size, Sizeof(Size)); 
  Data.Write(PlayerEditInfo, size); 
  Data.Signature := ResultSig or asPlayerEdit; 
  FSendDataBlock.Send(Data, false); 
 
end; 
 
procedure TrltServerInterpreter.CallLogout(PlayerID : String); 
var 
  Data: IDataBlock; 
  Size : integer; 
  VarFlag : TVarFlags; 
 
begin 
  FCriticalSection.Enter; 
  try 
    Data := TDataBlock.Create as IDataBlock; 
    WriteVariant(PlayerID, Data); 
    Data.Signature := CallSig or asLogoffPlayer; 
    Data := FSendDataBlock.Send(Data, false); 
  finally 
    FCriticalSection.Leave;  
  end; 
end; 
 
procedure TrltServerInterpreter.DoGetPlayerList(const Data: IDataBlock); 
var 
  Size : integer; 
  s : integer; 
  PlayerID : String; 
  VarFlag : TVarFlags; 
  PlayerList : TPlayerList; 
  buf : TArrayOfPlayerInfo; 
begin 
  Data.Read(Size, sizeof(Size)); 
  Data.Read(PlayerList, Sizeof(PlayerList)); 
//  SetLength(buf, PlayerList.PlayerCount); 
  Data.Read(buf, PlayerList.Size); 
  PlayerList.Data := @buf; 
  Data.Clear; 
  PlayerList := rltManager.GetPlayerList(PlayerList); 
  Size := sizeof(PlayerList); 
  Data.Write(Size, Sizeof(Size)); 
  Data.Write(PlayerList, sizeof(TPlayerList)); 
  if PlayerList.Data<> nil then 
    Data.Write(PlayerList.Data^, PlayerList.Size); 
  Data.Signature := ResultSig or asPlayerList; 
  try 
    FSendDataBlock.Send(Data, false); 
  finally 
//    SetLength(buf, 0); 
//    if PlayerList.Data<>nil then FreeMem(PlayerList.Data); 
    PlayerList.Data := nil; 
  end; 
end; 
 
procedure TrltServerInterpreter.DoSetRoundResult(const Data: IDataBlock); 
var 
  Size : integer; 
  s : integer; 
  VarFlag : TVarFlags; 
  WheelResult : integer; 
  Result : boolean; 
begin 
  WheelResult := ReadVariant(VarFlag, Data); 
  Data.Clear; 
  Result := rltManager.SetOpenColorIndex(WheelResult); 
  WriteVariant(Result, Data); 
  Data.Signature := ResultSig or asSetRoundResult; 
  FSendDataBlock.Send(Data, false); 
end; 
 
procedure TrltServerInterpreter.DoGetGameParams(const Data: IDataBlock); 
var 
  CGameParams : TGameParams; 
  Size : integer; 
begin 
  Data.Clear; 
  CGameParams := rltManager.GetGameParams; 
  Size := Sizeof(CGameParams); 
  Data.Write(Size, Sizeof(Size)); 
  Data.Write(CGameParams, Size); 
  Data.Signature := ResultSig or asGetGameParams; 
  FSendDataBlock.Send(Data, False); 
end; 
 
procedure TrltServerInterpreter.DoSetGameParams(const Data: IDataBlock); 
var 
  CGameParams : TGameParams; 
  Size : integer; 
  VarFlag : TVarFlags; 
  Result : boolean; 
begin 
  Data.Read(Size, Sizeof(Size)); 
  Data.Read(CGameParams, Size); 
  Result := rltManager.SetGameParams(CGameParams); 
  WriteVariant(Result, Data); 
  Data.Signature := ResultSig or asSetGameParams; 
  FSendDataBlock.Send(Data, False); 
end; 
 
procedure TrltServerInterpreter.DoGetRoundState(const Data: IDataBlock); 
var 
  CRoundState : TRoundState; 
  Size : integer; 
begin 
  Data.Clear; 
  CRoundState := rltManager.Round.State; 
  Size := Sizeof(CRoundState); 
  Data.Write(Size, Sizeof(Size)); 
  Data.Write(CRoundState, Size); 
  Data.Signature := ResultSig or asGetRoundState; 
  FSendDataBlock.Send(Data, False); 
end; 
 
procedure TrltServerInterpreter.DoSetRoundState(const Data: IDataBlock); 
var 
  CRoundState : TRoundState; 
  Size : integer; 
  Result : boolean; 
begin 
  Data.Read(Size, Sizeof(Size)); 
  Data.Read(CRoundState, Size); 
  Result := rltManager.setRoundState(CRoundState); 
  Data.Clear; 
  WriteVariant(Result, Data); 
  Data.Signature := ResultSig or asSetRoundState; 
  FSendDataBlock.Send(Data, False); 
end; 
 
procedure TrltServerInterpreter.DoGetRoundScordInfo( 
  const Data: IDataBlock); 
var 
  CRoundScordInfo : TRoundScordInfos; 
  Size : integer; 
  RoundID : integer; 
  VarFlag : TVarFlags; 
begin 
  RoundID := ReadVariant(VarFlag, Data); 
  Data.Clear; 
  CRoundScordInfo := rltManager.GetRoundScordInfo(RoundID); 
  Size := Sizeof(CRoundScordInfo); 
  Data.Write(Size, Sizeof(Size)); 
  Data.Write(CRoundScordInfo, Size); 
  Data.Signature := ResultSig or asGetRoundScordInfo; 
  FSendDataBlock.Send(Data, False); 
end; 
 
procedure TrltServerInterpreter.DoUploadPlayerList(const Data: IDataBlock); 
var 
  Size : integer; 
  s : integer; 
  PlayerID : String; 
  VarFlag : TVarFlags; 
  PlayerList : TPlayerList; 
  buf : TArrayOfPlayerInfo; 
  Re : boolean; 
begin 
  try 
    Re := false; 
    Data.Read(Size, sizeof(Size)); 
    Data.Read(PlayerList, Sizeof(PlayerList)); 
    Data.Read(buf, PlayerList.Size); 
    PlayerList.Data := @buf; 
    rltManager.SetPlayerList(PlayerList); 
    Re := true; 
    Data.Clear; 
 
    Size := Integer(Re); 
    Data.Write(Size, Sizeof(Size)); 
    Data.Signature := ResultSig or asUploadPlayerList; 
    try 
      FSendDataBlock.Send(Data, false); 
    finally 
      PlayerList.Data := nil; 
    end; 
  except 
  end; 
end; 
 
procedure TrltServerInterpreter.DoGetRoundInfoLog(const Data: IDataBlock); 
var 
  Size : integer; 
  Count : integer; 
  PlayerID : String; 
  VarFlag : TVarFlags; 
  Buf : TArrayofRoundInfo; 
 
begin 
  Data.Clear; 
  Count := rltManager.GetRoundInfoLog(Buf); 
  Size := sizeof(Count); 
  Data.Write(Size, Sizeof(Size)); 
  Data.Write(Count, Size); 
  Size := sizeof(TRoundInfoLog)* Count; 
  Data.Write(Size, Sizeof(Size)); 
  Data.Write(Buf, Size); 
  Data.Signature := ResultSig or asGetRoundLog; 
  FSendDataBlock.Send(Data, false); 
end; 
 
procedure TrltServerInterpreter.DoGetPlayerBetInfoLog( 
  const Data: IDataBlock); 
var 
  Size : integer; 
  Count : integer; 
  PlayerID : String; 
  VarFlag : TVarFlags; 
  Buf : TArrayofPlayerBetInfo; 
begin 
  Data.Clear; 
  Count := rltManager.GetPlayerBetInfoLog(Buf); 
  Size := sizeof(Count); 
  Data.Write(Size, Sizeof(Size)); 
  Data.Write(Count, Size); 
  Size := sizeof(TPlayerBetInfo)* Count; 
  Data.Write(Size, Sizeof(Size)); 
  Data.Write(Buf, Size); 
  Data.Signature := ResultSig or asGetPlayerBetLog; 
  FSendDataBlock.Send(Data, false); 
end; 
 
procedure TrltServerInterpreter.DoClearPlayerBetInfoLog( 
  const Data: IDataBlock); 
var 
  Size : integer; 
  s : integer; 
  VarFlag : TVarFlags; 
  Result : integer; 
begin 
  Data.Clear; 
  Result := Integer(rltManager.ClearPlayerBetInfoLog); 
 
  Size := sizeof(Result); 
 
  Data.Write(Size, Sizeof(Size)); 
  Data.Write(Result, size); 
  Data.Signature := ResultSig or asClearPlayerBetLog; 
  FSendDataBlock.Send(Data, false); 
 
 
end; 
 
procedure TrltServerInterpreter.DoClearRoundInfoLog( 
  const Data: IDataBlock); 
var 
  Size : integer; 
  s : integer; 
  VarFlag : TVarFlags; 
  Result : integer; 
begin 
  Data.Clear; 
  Result := Integer(rltManager.ClearRoundInfoLog); 
 
  Size := sizeof(Result); 
 
  Data.Write(Size, Sizeof(Size)); 
  Data.Write(Result, size); 
  Data.Signature := ResultSig or asClearGameLog; 
  FSendDataBlock.Send(Data, false); 
 
end; 
 
procedure TrltServerInterpreter.DoClearPlayerList(const Data: IDataBlock); 
var 
  Size : integer; 
  s : integer; 
  VarFlag : TVarFlags; 
  Result : integer; 
begin 
  Data.Clear; 
  Result := Integer(rltManager.ClearPlayerList); 
  Size := sizeof(Result); 
  Data.Write(Size, Sizeof(Size)); 
  Data.Write(Result, size); 
  Data.Signature := ResultSig or asClearPlayerBetLog; 
  FSendDataBlock.Send(Data, false); 
end; 
 
procedure TrltServerInterpreter.DoCheckAdmin(const Data: IDataBlock); 
var 
  AdminStr : String; 
  VarFlag : TVarFlags; 
  Result : boolean; 
  Size : integer; 
  ResultInt : integer; 
  tag : integer; 
begin 
  tag := ReadVariant(VarFlag, Data); 
  AdminStr := ReadVariant(VarFlag, Data); 
  Data.Clear; 
  Result := rltManager.CheckAdmin(Tag , AdminStr); 
  ResultInt := Integer(Result); 
  Size := sizeof(integer); 
  Data.Write(Size, Sizeof(Size)); 
  Data.Write(ResultInt, size); 
  Data.Signature := ResultSig or asCheckAdmin; 
  FSendDataBlock.Send(Data, false); 
end; 
 
procedure TrltServerInterpreter.DoLock(const Data: IDataBlock); 
var 
  VarFlag : TVarFlags; 
  Result : boolean; 
  LockValue : boolean; 
  ResultInt : integer; 
  Size : integer; 
begin 
  LockValue := ReadVariant(VarFlag, Data); 
  rltManager.IsLocked := LockValue; 
  Result := true; 
  ResultInt := Integer(Result); 
  Size := sizeof(integer); 
  Data.Write(Size, Sizeof(Size)); 
  Data.Write(ResultInt, size); 
  Data.Signature := ResultSig or asLockServer; 
  FSendDataBlock.Send(Data, false); 
 
end; 
 
end.