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

unit ManagerInterpreter; 
interface 
uses Classes, SConnectEx, TltConst, ExtCtrls, SysUtils, Forms, Dialogs, Windows; 
type 
  TrltManagerInterpreter = class(TDataBlockInterpreter) 
    function DoCustomAction(Action: Integer; const Data: IDataBlock): Boolean; override; 
  private 
    function CallGetRoundScord: TRoundScord; 
    function CallGetCurrentRoundNo: integer; 
    function CallGetRoundCountDown: integer; 
    function GetRoundScord: TRoundScord; 
  protected 
    procedure DoException(const Data: IDataBlock); override; 
  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 DoWheelParams(const Data: IDataBlock); 
    procedure DoLoginManager(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 ; 
    function CallGetRoundInfo():TRoundInfo; 
    function CallPlayerEdit(APlayerEditInfo : TPlayerEditInfo):TPlayerEditInfo ; 
    function CallGetPlayerList(APlayerList : TPlayerList): TPlayerList; 
    function CallSetRoundResult(AColorIndex : integer):boolean; 
 
    function CallGetGameParams(var AGameParams : TGameParams) : boolean; 
    function CallSetGameParams(AGameParams : TGameParams) : boolean; 
    function CallGetRoundState: TRoundState; 
    function CallSetRoundState(ARoundState : TRoundState): boolean; 
    function CallSetPlayerList(const APlayerList : TPlayerList): boolean; 
    function CallGetRoundInfoLog(var AArrayofRoundInfo : TArrayofRoundInfo) : integer; 
    function CallGetPlayerBetLog(var AArrayofPlayerBetLog : TArrayofPlayerBetInfo) : integer; 
 
    function CallClearRoundInfoLog:boolean; 
    function CallClearPlayerBetInfoLog:boolean; 
    function CallClearPlayerList : boolean; 
    function CallCheckAdmin(Tag : integer; AdminStr: String) : boolean; 
    function CallSetLock(Lock : boolean):boolean; 
 
 
  end; 
 
  TrltSocketConnection = class(TSocketConnection) 
  private 
    FInterpreter : TrltManagerInterpreter; 
  protected 
 
    function GetInterpreter: TCustomDataBlockInterpreter; override; 
    procedure DoError(E: Exception); override; 
  published 
    property Interpreter; 
 
 
  end; 
 
implementation 
uses ScktCnst, Round, main; 
 
 
{ TTltInterpreter } 
 
function TrltManagerInterpreter.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 TrltManagerInterpreter.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 TrltManagerInterpreter.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); 
    asWheelParams : DoWheelParams(Data); 
    asPlayerList:{ShowMessage('error 66')}; 
    1:; 
 
  else 
    Result := false; 
  end; 
end; 
 
 
 
 
 
procedure TrltManagerInterpreter.DoSetCountDown(const Data: IDataBlock); 
var 
  VarSize : integer; 
  VarFlag : TVarFlags; 
begin 
//  rlt.Round.CountDown := ReadVariant(VarFlag, Data); 
end; 
 
{ TrltSocketConnetion } 
 
procedure TrltSocketConnection.DoError(E: Exception); 
begin 
  MessageBox(0, '连接服务器失败!', '', MB_OK); 
 
end; 
 
function TrltSocketConnection.GetInterpreter: TCustomDataBlockInterpreter; 
begin 
  if not Assigned(FInterpreter) then 
  FInterpreter := TrltManagerInterpreter.Create(Self, SSockets); 
  Result := FInterpreter; 
 
end; 
 
 
procedure TrltManagerInterpreter.DoLoginPlayer(const Data: IDataBlock); 
var 
  IsLogined : boolean; 
  VarFlag : TVarFlags; 
  VarSize : integer; 
begin 
  //check is logined 
  IsLogined := ReadVariant(VarFlag, Data); 
  //active player 
  // 
end; 
 
procedure TrltManagerInterpreter.DoLogoffPlayer(const Data: IDataBlock); 
begin 
 
end; 
 
procedure TrltManagerInterpreter.DoResetRound(const Data: IDataBlock); 
begin 
 
end; 
 
procedure TrltManagerInterpreter.DoSetRound(const Data: IDataBlock); 
var 
  VarSize : integer; 
  VarFlag : TVarFlags; 
  Round : TRound; 
begin 
{  Data.Read(VarSize, sizeof(VarSize)); 
  Data.Read(Round, VarSize); 
  rlt.SetRound(Round);} 
//  rlt.Round := ReadVariant(VarFlag, Data); 
end; 
 
function TrltManagerInterpreter.GetRoundScord: TRoundScord; 
begin 
 
end; 
 
 
function TrltManagerInterpreter.CallGetRoundCountDown: integer; 
begin 
 
end; 
 
function TrltManagerInterpreter.CallGetRoundScord: TRoundScord; 
begin 
 
end; 
 
function TrltManagerInterpreter.CallGetRoundState: TRoundState; 
var 
  Data: IDataBlock; 
  VarSize : integer; 
  VarFlag : TVarFlags; 
begin 
  Data := TDataBlock.Create as IDataBlock; 
  Data.Signature := CallSig or asGetRoundState; 
  Data := FSendDataBlock.Send(Data, True); 
  Data.Read(VarSize, sizeof(VarSize)); 
  Data.Read(Result, VarSize); 
end; 
 
function TrltManagerInterpreter.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 TrltManagerInterpreter.DoTimeSetting(const Data: IDataBlock); 
var 
  VarSize : integer; 
  VarFlag : TVarFlags; 
  S : TTimeSetting; 
begin 
  Data.Read(VarSize, sizeof(VarSize)); 
  Data.Read(s, VarSize); 
  TimeSetting := S;   
end; 
 
function TrltManagerInterpreter.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 TrltManagerInterpreter.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 TrltManagerInterpreter.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)); 
  Data.Read(Result, Size); 
end; 
 
 
 
function TrltManagerInterpreter.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 TrltManagerInterpreter.DoPlayerInfo(const Data: IDataBlock); 
var 
  PlayInfo : TPlayerInfo; 
  Size : integer; 
  I : integer; 
begin 
  Data.Read(Size, sizeof(Size)); 
  Data.Read(PlayInfo, Size); 
  APlayer := nil; 
  for i := low(Player) to High(Player) do 
  begin 
    if PlayInfo.ID = Player[i].UserID then 
    begin 
      APlayer := Player[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 TrltManagerInterpreter.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 TrltManagerInterpreter.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 TrltManagerInterpreter.DoWheelParams(const Data: IDataBlock); 
var 
  Size : integer; 
  I : integer; 
begin 
{  Data.Read(Size, sizeof(Size)); 
  Data.Read(rlt.WheelParams, Size); 
  rlt.UpdateWheelParams; 
} 
end; 
 
procedure TrltManagerInterpreter.DoLoginManager(const Data: IDataBlock); 
begin 
 
end; 
 
function TrltManagerInterpreter.CallGetRoundInfo: TRoundInfo; 
var 
  I : integer; 
  RoundInfo : TRoundInfo; 
  Data: IDataBlock; 
  Size : integer; 
  s : boolean; 
  Flays : TVarFlags; 
begin 
  if RoundMonitorForm = nil then Exit; 
  Data := TDataBlock.Create as IDataBlock; 
  Data.Signature := CallSig or asGetRoundInfo; 
  Data := FSendDataBlock.Send(Data, True); 
  Data.Read(Size, sizeof(Size)); 
  Data.Read(Result, Size); 
end; 
 
function TrltManagerInterpreter.CallPlayerEdit( 
  APlayerEditInfo: TPlayerEditInfo): TPlayerEditInfo; 
var 
  I : integer; 
  Data: IDataBlock; 
  Size : integer; 
  s : boolean; 
  Flays : TVarFlags; 
begin 
  Data := TDataBlock.Create as IDataBlock; 
  Size := Sizeof(APlayerEditInfo); 
  Data.Write(Size, Sizeof(Size)); 
  Data.Write(APlayerEditInfo, Size); 
  Data.Signature := CallSig or asPlayerEdit; 
  Data := FSendDataBlock.Send(Data, True); 
  Data.Read(Size, sizeof(Size)); 
  Data.Read(Result, Size); 
end; 
 
function TrltManagerInterpreter.CallGetPlayerList( 
  APlayerList: TPlayerList): TPlayerList; 
var 
  I : integer; 
  Data: IDataBlock; 
  Size : integer; 
  s : boolean; 
  Flays : TVarFlags; 
begin 
  Data := TDataBlock.Create as IDataBlock; 
  Size := Sizeof(TPlayerList); 
  Data.Write(Size, Sizeof(Size)); 
  Data.Write(APlayerList, Size); 
  if APlayerList.Data <> nil then 
    Data.Write(APlayerList.Data^, APlayerList.Size); 
  Data.Signature := CallSig or asPlayerList; 
  Data := FSendDataBlock.Send(Data, True); 
  Data.Read(Size, sizeof(Size)); 
  Data.Read(Result, Size); 
  GetMem(Result.Data, Result.Size); 
  FillChar(Result.Data^, Result.Size, #0); 
  Data.Read(Result.Data^, Result.Size); 
 
end; 
 
function TrltManagerInterpreter.CallSetRoundResult(AColorIndex: integer):boolean; 
var 
  I : integer; 
  Data: IDataBlock; 
  Size : integer; 
  s : boolean; 
  Flays : TVarFlags; 
begin 
  Data := TDataBlock.Create as IDataBlock; 
  WriteVariant(AColorIndex, Data); 
  Data.Signature := CallSig or asSetRoundResult; 
  Data := FSendDataBlock.Send(Data, True); 
  Result := ReadVariant(Flays, Data); 
end; 
 
procedure TrltManagerInterpreter.DoException(const Data: IDataBlock); 
begin 
//  inherited; 
// nothing; 
 
end; 
 
function TrltManagerInterpreter.CallSetGameParams( 
  AGameParams: TGameParams): boolean; 
var 
  I : integer; 
  Data: IDataBlock; 
  Size : integer; 
  Flays : TVarFlags; 
begin 
  Result := false; 
  Data := TDataBlock.Create as IDataBlock; 
  Size := sizeof(AGameParams); 
  Data.Write(Size , sizeof(Size)); 
  Data.Write(AGameParams, Size); 
  Data.Signature := CallSig or asSetGameParams; 
  Data := FSendDataBlock.Send(Data, True); 
  Result := ReadVariant(Flays, Data); 
end; 
 
function TrltManagerInterpreter.CallGetGameParams( 
  var AGameParams: TGameParams): boolean; 
var 
  I : integer; 
  Data: IDataBlock; 
  Size : integer; 
  Flays : TVarFlags; 
begin 
  Result := false; 
  Data := TDataBlock.Create as IDataBlock; 
  Data.Signature := CallSig or asGetGameParams; 
  Data := FSendDataBlock.Send(Data, True); 
  Data.Read(Size , sizeof(Size)); 
  Data.Read(AGameParams, Size); 
  Result := true; 
end; 
 
function TrltManagerInterpreter.CallSetRoundState( 
  ARoundState: TRoundState): boolean; 
var 
  Data: IDataBlock; 
  VarSize : integer; 
  VarFlag : TVarFlags; 
begin 
  Data := TDataBlock.Create as IDataBlock; 
  VarSize := Sizeof(ARoundState); 
  Data.Write(VarSize, Sizeof(VarSize)); 
  Data.Write(ARoundState, VarSize); 
  Data.Signature := CallSig or asSetRoundState; 
  Data := FSendDataBlock.Send(Data, True); 
  Result := ReadVariant(VarFlag, Data); 
end; 
 
function TrltManagerInterpreter.CallSetPlayerList( 
  const APlayerList: TPlayerList): boolean; 
var 
  I : integer; 
  Data: IDataBlock; 
  Size : integer; 
  s : boolean; 
  Flays : TVarFlags; 
begin 
  Data := TDataBlock.Create as IDataBlock; 
  Size := Sizeof(TPlayerList); 
  Data.Write(Size, Sizeof(Size)); 
  Data.Write(APlayerList, Size); 
  if APlayerList.Data <> nil then 
    Data.Write(APlayerList.Data^, APlayerList.Size); 
  Data.Signature := CallSig or asUploadPlayerList; 
  Data := FSendDataBlock.Send(Data, True); 
  Data.Read(Size, sizeof(Size)); 
  Result := boolean(Size); 
//  Result := ReadVariant(Flays, Data); 
end; 
 
function TrltManagerInterpreter.CallGetRoundInfoLog( 
  var AArrayofRoundInfo: TArrayofRoundInfo): integer; 
var 
  I : integer; 
  Data: IDataBlock; 
  Size : integer; 
  s : boolean; 
  Flays : TVarFlags; 
 
begin 
  Data := TDataBlock.Create as IDataBlock; 
  Data.Signature := CallSig or asGetRoundLog; 
  Data := FSendDataBlock.Send(Data, True); 
  Data.Read(Size, sizeof(Size)); 
  if Size > Sizeof(Result) then raise Exception.Create('数据返回格式错误。'); 
  Data.Read(Result, Size); //大小 
  Data.Read(Size, sizeof(Size)); 
  if Size > Sizeof(AArrayofRoundInfo) then raise Exception.Create('数据返回格式错误。'); 
  Data.Read(AArrayofRoundInfo, Size); 
end; 
 
function TrltManagerInterpreter.CallGetPlayerBetLog( 
  var AArrayofPlayerBetLog: TArrayofPlayerBetInfo): integer; 
var 
  I : integer; 
  Data: IDataBlock; 
  Size : integer; 
  s : boolean; 
  Flays : TVarFlags; 
 
begin 
  Data := TDataBlock.Create as IDataBlock; 
  Data.Signature := CallSig or asGetPlayerBetLog; 
  Data := FSendDataBlock.Send(Data, True); 
  Data.Read(Size, sizeof(Size)); 
  Data.Read(Result, Size); //大小 
  Data.Read(Size, sizeof(Size)); 
  Data.Read(AArrayofPlayerBetLog, Size); 
end; 
 
function TrltManagerInterpreter.CallClearPlayerBetInfoLog: boolean; 
var 
  I : integer; 
  Data: IDataBlock; 
  Size : integer; 
  s : boolean; 
  Flays : TVarFlags; 
 
begin 
  Data := TDataBlock.Create as IDataBlock; 
  Data.Signature := CallSig or asClearPlayerBetLog; 
  Data := FSendDataBlock.Send(Data, True); 
  Data.Read(Size, sizeof(Size)); 
  Data.Read(s, Size); //大小 
  Result := boolean(s); 
end; 
 
function TrltManagerInterpreter.CallClearRoundInfoLog: boolean; 
var 
  I : integer; 
  Data: IDataBlock; 
  Size : integer; 
  s : boolean; 
  Flays : TVarFlags; 
 
begin 
  Data := TDataBlock.Create as IDataBlock; 
  Data.Signature := CallSig or asClearGameLog; 
  Data := FSendDataBlock.Send(Data, True); 
  Data.Read(Size, sizeof(Size)); 
  Data.Read(s, Size); //大小 
  Result := boolean(s); 
end; 
 
function TrltManagerInterpreter.CallClearPlayerList: boolean; 
var 
  I : integer; 
  Data: IDataBlock; 
  Size : integer; 
  s : boolean; 
  Flays : TVarFlags; 
begin 
  Data := TDataBlock.Create as IDataBlock; 
  Data.Signature := CallSig or asClearPlayerList; 
  Data := FSendDataBlock.Send(Data, True); 
  Data.Read(Size, sizeof(Size)); 
  Data.Read(s, Size); //大小 
  Result := boolean(s); 
end; 
 
function TrltManagerInterpreter.CallCheckAdmin(Tag: integer; 
  AdminStr: String): boolean; 
var 
  I : integer; 
  Data: IDataBlock; 
  Size : integer; 
  s : integer; 
  Flays : TVarFlags; 
begin 
  Data := TDataBlock.Create as IDataBlock; 
  WriteVariant(Tag, Data); 
  WriteVariant(AdminStr, Data); 
  Data.Signature := CallSig or asCheckAdmin; 
  Data := FSendDataBlock.Send(Data, True); 
  Data.Read(Size, sizeof(Size)); 
  Data.Read(s, Size); //大小 
  Result := boolean(s); 
end; 
 
function TrltManagerInterpreter.CallSetLock(Lock: boolean): boolean; 
var 
 
  I : integer; 
  Data: IDataBlock; 
  Size : integer; 
  s : integer; 
  Flays : TVarFlags; 
begin 
  Data := TDataBlock.Create as IDataBlock; 
  WriteVariant(Lock, Data); 
  Data.Signature := CallSig or asLockServer; 
  Data := FSendDataBlock.Send(Data, True); 
  Data.Read(Size, sizeof(Size)); 
  Data.Read(s, Size); //大小 
  Result := boolean(s); 
end; 
 
end.