tltlogic.pas

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

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.