rltsvr.pas

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

unit rltSvr;

interface
uses Classes, SConnectEx, TltConst, ExtCtrls, MMSystem, Types, windows, TltLogic
  , SysUtils;

type
  TTltClient = class;
  TPlayer  = class;
  {自动状态机，以时间为脉冲

  }
  TTltManager = class(TComponent)
  private
    FTickCount : DWord;
    FStartTickCount : DWord;
//    FWheelCounter : integer;
    FWheelStartTickCount : DWord;
    FCountDown: integer;


    FBetTimeSetting : DWord;
    FBeforeWheelTimeSetting : DWord;
    FWheelingTimeSetting : DWord;
    FScoreTimeSetting : DWord;
    FRoundMain : DWord;
    FState: TRoundState;
    FTimeSettingModified : boolean;

    FFlag : array [0..31] of byte;
    FBaseValue, FTotalValue, FObjectValue, FRate, FBleed : longint;

    AllBetTotle : longint;
    Level2 : integer;

    FBallTheta, FWheelTheta : single;
    FSpecialNum : boolean;

    FLastWheelParamGetTime : integer;
    FPauseAtRoundEnd : boolean;

    function GetResult : integer;

    function GetCountDown: integer;


    procedure UpdateCounter;
    procedure UpdateLogic;
    procedure Update;
    procedure Log;
    procedure UpdateCountDown;
    procedure ResetWheel;
    procedure UpdateTimeSetting;

    procedure DoBeting;
    procedure DoBeforeWheel;
    procedure DoWheeling;
    procedure DoScore;
    procedure DoWheelEnd;
    procedure DoStop;
    procedure DoPaused;
    function GetState: TRoundState;
    function GetClientByPlayer(Player: TPlayer): TTltClient;
    function GetColorIndex(Num: integer): integer;

    function GetWheelParams(State: TRoundState):TWheelParams;
    function GetRandomNumByColor(ColorIndex: integer): integer;
    procedure ResetPlayerBet;
  public
    TimeSetting : TTimeSetting;
    FTltClients : TList;
    FPlayerList : TList;
    Round : TRound;
    NeedResetPlayerBet : boolean;

    PauseOnNewRound : boolean;

    RoundID : integer;
    WheelResult : integer;
    WheelParams : TWheelParams;

    RoundScords : array [0..99] of TRoundScord;
    RoundScordInfosArray : array [0..99] of TRoundScordInfos;
    BetCount : array [TBetType] of longint;
//    FState : TRoundState;
    Timer : TTimer;

    procedure UpdateClients(Proc : TClientProc);
    function DoPlayerEdit(APlayerEditInfo : TPlayerEditInfo): TPlayerEditInfo;
    function GetPlayerList(APlayerList : TPlayerList) : TPlayerList;
    function SetPlayerList(APlayerList : TPlayerList) : TPlayerList;
    function GetRoundInfoLog(var AArrayofRoundInfo : TArrayofRoundInfo) : integer;
    function GetPlayerBetInfoLog(var AArrayofPlayerBetInfo : TArrayofPlayerBetInfo) : integer;
    function ClearRoundInfoLog : boolean;
    function ClearPlayerBetInfoLog : boolean;
    function ClearPlayerList : boolean;     

    procedure StartRound;
    procedure DoTimer(Sender : TObject);
    function CreatePlayer : TPlayer;
    function LoginPlayer( APlayer : TPlayer):boolean;overload;
    function LoginPlayer(PlayerID , Password : String; AClient: TtltClient) : boolean;overload;
    procedure LogoffPlayer(PlayerID : String);
    procedure DeletePlayer(ID : String);
    function GetOpenNumber :  integer;
    function SetOpenNumber(ANum: integer) : integer;
    function SetOpenColorIndex(AColorIndex : integer) :boolean;
    function GetBetCount : TBatArray;
    function NextState : TRoundState;
    function GetPlayerByID(PlayerID : String) : TPlayer;
    destructor Destroy; override;
    procedure AddClient(Client : TTltClient);
    procedure RemoveClient(Client : TTltClient);

    function GetGameParams : TGameParams;
    function SetGameParams(AGameParams : TGameParams) : boolean;
    function SetRoundState(const Value: TRoundState): boolean;
    procedure ResetRound;
    function GetRoundScordInfo(RoundID : integer) : TRoundScordInfos;

    function CheckAdmin(Tag : integer; AdminStr : String):boolean;


  published
    property BaseValue : integer read FBaseValue;
    property TotalValue: integer read FTotalValue write FTotalValue;
    property ObjectValue : integer read FObjectValue write FObjectValue;
    property Rate:integer read FRate write FRate;
    property Bleed: integer read FBleed write FBleed;
    property CountDown : integer read GetCountDown write Round.CountDown;
    property State : TRoundState read GetState;
  public
    procedure UpDateWheelParams;
    procedure Dafultsetting;
    procedure InitRound;
    constructor Create(AOwner: TComponent); override;
    procedure DoInit;



  end;
  TPlayer = class
    ID : String;
    Password : String;
    HadLogin : String;
    UserName : String;
    Memo : String;
    Client : TTltClient;
    Money : integer;
    TimeOut : integer;
    LastActiveTime : TDateTime;
    Bet : array [TBetType] of integer;
    Modified : boolean;
    State : TPlayerState;
    function GetPlayerInfo : TPlayerInfo;
    procedure SetPlayerInfo(PlayerInfo : TPlayerInfo);
    constructor Create;
  end;
  TTltClient = class
    FManager : TTltManager;
    PlayerList : TList;
    Interpreter : TrltServerInterpreter;
  public
    constructor Create(manager : TTltManager);
    destructor Destroy; override;
    function HasPlayer(Player : TPlayer) : boolean;
    procedure AddPlayer(Player : TPlayer);
    procedure RemovePlayer(Player : TPlayer);
  end;


var
  rltManager : TTltManager;


implementation

uses ScktMain, DAU;

{ TTltClient }



{ TTltManager }



procedure TTltManager.AddClient(Client: TTltClient);
begin
  if not Assigned(Client) then Exit;
  FTltClients.Add(Client);
end;

constructor TTltManager.Create(AOwner: TComponent);
begin
  inherited;
  FSpecialNum := false;
  PauseOnNewRound := true;

//init
  Dafultsetting;
  UpdateTimeSetting;
  //read setting;

//timer
  Timer := TTimer.Create(self);
  Timer.OnTimer := DoTimer;
  Timer.Enabled := true;
  FPlayerList := TList.Create;
  FTltClients := TList.Create;
//new Round
  DoInit;
  inc(Round.CountDown);
  InitRound;
  Round.State := rsPaused;
  NeedResetPlayerBet := false;

end;

function TTltManager.CreatePlayer: TPlayer;
begin
  // No user;
end;

procedure TTltManager.Dafultsetting;
begin
  Round.Main := 1;
  Round.No := 1;
  Round.WheelNo := 0;

  FRate := 1;
  Round.State := rsPaused;
  Level2 := 1;

  FBetTimeSetting := 50;
  FBeforeWheelTimeSetting := 10;
  FWheelingTimeSetting := 15;
  FScoreTimeSetting := 5;
  UpdateTimeSetting;

end;

procedure TTltManager.DeletePlayer(ID: String);
begin

end;

destructor TTltManager.Destroy;
var
  I : integer;
begin
  while FPlayerList.Count >0 do
  begin
    LogoffPlayer(TPlayer(FPlayerList[0]).ID);
  end;
  while FTltClients.Count >0 do
  begin
    RemoveClient(TTltClient(FTltClients[0]));
  end;
  FPlayerList.Free;
  FTltClients.free;
  inherited;
end;

procedure TTltManager.DoBeforeWheel;
var
  I : integer;
  rltInterpreter : TrltServerInterpreter;
begin
  if Level2 = 1 then
  begin //
    if not FSpecialNum then
      Round.WheelResult := GetResult;
    FSpecialNum := false; 

    Level2 := 2;
    WheelParams := GetWheelParams(State);

    for I := 0 to SocketForm.ConnectionList.Items.Count -1 do
    begin
      rltInterpreter := SocketForm.GetrltInterpreter(I);
      rltInterpreter.CallSetWheelParams(WheelParams);
    end;
    
  end;
  if Level2 = 2 then
  begin
    for I := 0 to SocketForm.ConnectionList.Items.Count -1 do
    begin
      rltInterpreter := SocketForm.GetrltInterpreter(I);
      rltInterpreter.CallSetRound;
    end;
  end;

//最终核算结果
//拒绝客户端下注
//接收管理端的结果更改,将结果数据发送到客户端
//将正确接收到数据的客户端用户记录在案,如果本局顺利完成,将完成结算
//同步客户端时间

end;

procedure TTltManager.DoBeting;
var
  I : integer;
  rltInterpreter : TrltServerInterpreter;
  WheelParams : TWheelParams;
  SendTimeSetting : boolean;

begin
//sent betCountChange
//sent RoundStart
  SendTimeSetting := FTimeSettingModified;
  if Level2 = 1 then
  begin
    inc(Round.WheelNo);
    if Round.WheelNo>50 then
    begin
      Round.WheelNo := 1;
      inc(Round.No);
      Round.Scord.Count := 0;
      if PauseOnNewRound then SetRoundState(rsStop);
    end;
    Round.WheelResult := -1;
    Level2 := 2;
    //轮子慢速旋转
    WheelParams := GetWheelParams(State);
    if FTimeSettingModified then UpdateTimeSetting;

    if SocketForm <> nil then
    for I := 0 to SocketForm.ConnectionList.Items.Count -1 do
    begin
      rltInterpreter := SocketForm.GetrltInterpreter(I);
      rltInterpreter.CallSetWheelParams(WheelParams);
      if SendTimeSetting then rltInterpreter.CallSetTimeSetting;
    end;
    Round.Auto := true;

  end;
  if SocketForm <> nil then
  for I := 0 to SocketForm.ConnectionList.Items.Count -1 do
  begin
    rltInterpreter := SocketForm.GetrltInterpreter(I);
    rltInterpreter.CallSetRound;
  end;
//同步下注时间一次
//下注
//统计下注量
//计算开出结果
//通知客户端
//计算状态变更;
end;

procedure TTltManager.DoScore;
var
  I : integer;
  rltInterpreter : TrltServerInterpreter;
  ColorIndex : integer;
  Lost, Win : integer;
  BetTotle : integer;
  CPlayerBetInfo : TPlayerBetInfo;
begin
  if Level2 = 1 then
  begin
    ColorIndex := GetColorIndex(Round.WheelResult);
    for I := 0 to FPlayerList.Count -1 do
    begin
      with TPlayer(FPlayerList[i]) do
      begin
        CPlayerBetInfo.PreMoney := Money;
        Lost := Bet[btRed] + Bet[btBlack] + Bet[btGreen];
        Win := 0;
        case ColorIndex of
        0 : Win := Bet[btRed]*2;
        1 : Win := Bet[btBlack]*2;
        2 : Win := Bet[btGreen]*36;
        end;

        Money := Money - Lost + Win;
        Modified := true;
        if Lost <> 0 then
        begin
          CPlayerBetInfo.PlayerID := ID;
          CPlayerBetInfo.r := bet[btRed];
          CPlayerBetInfo.b := bet[btBlack];
          CPlayerBetInfo.g := Bet[btGreen];
          CPlayerBetInfo.Settlement := Money;
          CPlayerBetInfo.Datetime := now;
          CPlayerBetInfo.RoundNo := Round.No;
          CPlayerBetInfo.RoundMain := Round.Main;
          CPlayerBetInfo.WheelNo := Round.WheelNo;
          CPlayerBetInfo.Result := Round.WheelResult;
          CPlayerBetInfo.ResultColor := ColorIndex;
          DASavePlayerBetInfo(CPlayerBetInfo);
        end;
        
        //if Lost - Win <> 0 then DAEditPlayer(TPlayer(FPlayerList[i]));

        FillChar(Bet, sizeof(Bet), #0);
        rltInterpreter := Client.Interpreter;
        rltInterpreter.CallSetPlayerInfo(TPlayer(FPlayerList[i]));
      end;
      DASavePlayer(TPlayer(FPlayerList[i]));
    end;
    BetTotle := BetCount[btRed] + BetCount[btBlack] + BetCount[btGreen];
    FTotalValue :=FTotalValue + BetTotle;
    case ColorIndex of
    0 : dec(FTotalValue, BetCount[btRed]*2);
    1 : dec(FTotalValue, BetCount[btBlack]*2);
    2 : dec(FTotalValue, BetCount[btGreen]*36);
    end;
    //利润期望

    FObjectValue := (BetTotle) * FRate div 100 + FObjectValue;
    Round.Scord.Number[Round.WheelNo] := Round.WheelResult;
    Round.Scord.Count := Round.WheelNo;
    RoundScords[Round.No] := Round.Scord;

    RoundScordInfosArray[Round.No].RoundMain := Round.No;
    RoundScordInfosArray[Round.No].WheelCount := Round.WheelNo;
    RoundScordInfosArray[Round.No].WheelInfos[Round.WheelNo].RoundID := Round.No;
    RoundScordInfosArray[Round.No].WheelInfos[Round.WheelNo].WheelID := Round.WheelNo;
    RoundScordInfosArray[Round.No].WheelInfos[Round.WheelNo].RedBet := BetCount[btRed];
    RoundScordInfosArray[Round.No].WheelInfos[Round.WheelNo].BlackBet := BetCount[btBlack];
    RoundScordInfosArray[Round.No].WheelInfos[Round.WheelNo].GreenBet := BetCount[btGreen];
    RoundScordInfosArray[Round.No].WheelInfos[Round.WheelNo].Result := Round.WheelResult;
    RoundScordInfosArray[Round.No].WheelInfos[Round.WheelNo].ResultColor := ColorIndex;
    RoundScordInfosArray[Round.No].WheelInfos[Round.WheelNo].Settment := TotalValue;
    RoundScordInfosArray[Round.No].WheelInfos[Round.WheelNo].DateTime := Now;
    RoundScordInfosArray[Round.No].WheelInfos[Round.WheelNo].AutoValue := Round.Auto;
    DASaveRoundScordInfo(RoundScordInfosArray[Round.No].WheelInfos[Round.WheelNo]);

    WheelParams := GetWheelParams(State);

    for I := 0 to SocketForm.ConnectionList.Items.Count -1 do
    begin
      rltInterpreter := SocketForm.GetrltInterpreter(I);
      rltInterpreter.CallSetWheelParams(WheelParams);
    end;
    Level2 := 2;

  end;
  for I := 0 to SocketForm.ConnectionList.Items.Count -1 do
  begin
    rltInterpreter := SocketForm.GetrltInterpreter(I);
    rltInterpreter.CallSetRound;
  end;
//统计,结算分值
//记录到数据库
//改变记录到管理端
//改变各个客户端玩家的分数

end;

procedure TTltManager.DoTimer(Sender: TObject);
var
  I : integer;
  rltInterpreter : TrltServerInterpreter;
begin
  //状态机入口
  //更新当前时间
  //检测时间有效性(忽略)
  //改变游戏全局数据

  //更新客户端数据
{  FCountDown := (FTickCount - GetTickCount) div 1000;
  if (CountDown>=0) and (CountDown<=FBetTimeSet) then
  begin
    DoBeting;
  end else
  if (CountDown>FBetTimeSet) and (CountDown<= FBeforeWheelTimeSet) then
  begin
    DoBeforeWheel;
  end else
  if (CountDown>FBeforeWheelTimeSet) and (CountDown<= FWheelingTimeSet) then
  begin
    DoWheeling;
  end else
  if (CountDown>FWheelingTimeSet) and (CountDown<= FWheelEndSet) then
  begin
    DoScore;
  end;
  if (CountDown> FWheelEndSet) then
  begin
    DoWheelEnd;
  end;
}

//  UpdateCountDown;
  Update;
{    for I := 0 to SocketForm.ConnectionList.Items.Count -1 do
    begin
      rltInterpreter := SocketForm.GetrltInterpreter(I);
      rltInterpreter.CallSetCountDown;
    end;}

end;

procedure TTltManager.DoWheelEnd;
var
  I : integer;
  rltInterpreter : TrltServerInterpreter;
begin
  if FPauseAtRoundEnd then SetRoundState(rsStop)
  else InitRound;
  for I := 0 to SocketForm.ConnectionList.Items.Count -1 do
  begin
    rltInterpreter := SocketForm.GetrltInterpreter(I);
    rltInterpreter.CallSetRound;
  end;
// 重置局状态
//  CountDown
end;

procedure TTltManager.DoWheeling;
var
  I : integer;
  rltInterpreter : TrltServerInterpreter;
begin
  if Level2 = 1 then
  begin
    WheelParams := GetWheelParams(State);
    for I := 0 to SocketForm.ConnectionList.Items.Count -1 do
    begin
      rltInterpreter := SocketForm.GetrltInterpreter(I);
      rltInterpreter.CallSetWheelParams(WheelParams);
    end;
    Level2 := 2;
  end;

  for I := 0 to SocketForm.ConnectionList.Items.Count -1 do
  begin
    rltInterpreter := SocketForm.GetrltInterpreter(I);
    rltInterpreter.CallSetRound;
  end;
//提示客户端进入轮盘显示
//等待客户端完成轮盘旋转
end;

function TTltManager.GetBetCount: TBatArray;
begin

end;

function TTltManager.GetCountDown: integer;
begin
  Result := Round.CountDown;
end;

function TTltManager.GetOpenNumber: integer;
begin
  Result := Round.WheelResult;
end;