2066 lines
50 KiB
C++
2066 lines
50 KiB
C++
//---------------------------------------------------------------------------
|
|
#include <System.StrUtils.hpp>
|
|
#include "GameUnit.h"
|
|
#include "GlobalUnit.h"
|
|
#include "UtilityUnit.h"
|
|
|
|
#pragma hdrstop
|
|
|
|
//---------------------------------------------------------------------------
|
|
#pragma package(smart_init)
|
|
|
|
TSettings g_settings; //基本设置
|
|
TGameArray g_aGames;
|
|
|
|
int g_iRoad = 0; //全局路单/默认为六珠路
|
|
double g_fBalance = 0; //账户余额
|
|
bool g_bSimulate = true,
|
|
g_bShowSetting = true,
|
|
g_bGameOn = false,
|
|
g_bDeadPause = false, //全局爆缆暂停
|
|
g_bBetPause = false; //总体止赢止损暂停
|
|
|
|
int g_MinOnBet = 20, //最小注码
|
|
g_MaxOnBet = 50000; //最大注码
|
|
|
|
int g_nRBReport = 0; //实打流水上报
|
|
|
|
vector<TDot> g_aDots[4]; //资金图表数据 总赢利/模拟本金/账户余额
|
|
TIPGameArray g_aIPGames;
|
|
|
|
//---------------------------------------------------------------------------
|
|
int __fastcall Vid2Gid(String vid)
|
|
{
|
|
int id = 0;
|
|
|
|
if(g_iPlatform==PF_PA){
|
|
String sNum = vid.SubString(2,vid.Length()-1);
|
|
TryStrToInt(sNum, id);
|
|
|
|
if(id>0){
|
|
if(vid[1]=='D') id += 100;
|
|
else if(vid[1]=='M') id += 200;
|
|
else if(vid[1]=='P') id += 300;
|
|
else if(vid[1]=='E') id += 400;
|
|
else if(vid[1]!='N') id += (vid[1]-'A'+5) * 100;
|
|
}
|
|
}
|
|
else{
|
|
id = vid.ToInt();
|
|
}
|
|
|
|
return id;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// TRankChip
|
|
TRankChip::TRankChip()
|
|
{
|
|
bWait = iType = 0;
|
|
pPolicy = NULL;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall TRankChip::SetPolicy(TChipPolicy* pCP)
|
|
{
|
|
if(pPolicy!=pCP){
|
|
pPolicy = pCP;
|
|
Reset();
|
|
}
|
|
}
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// TTierChip
|
|
TTierChip::TTierChip()
|
|
{
|
|
iType = KIND_CHIP_HAN;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall TTierChip::Reset()
|
|
{
|
|
if(pPolicy){
|
|
TTierRow* pRow = (TTierRow*)pPolicy->aRows[0];
|
|
nRnkChip = pRow->chip;
|
|
nCount = pRow->hands;
|
|
iRank = nWLDiff = nAccChip = nLos = 0;
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
int __fastcall TTierChip::HandleResult(int res, double wl)
|
|
{
|
|
if(res==1){
|
|
nWLDiff++;
|
|
nLos -= nRnkChip;
|
|
}
|
|
else if(res==2){
|
|
nWLDiff--;
|
|
nLos += nRnkChip;
|
|
}
|
|
else return iRank;
|
|
|
|
if(((TTierPolicy*)pPolicy)->bTierWinRet && iRank>0 && nWLDiff>0){ //高层赢回基
|
|
Reset();
|
|
}
|
|
else{
|
|
nCount--;
|
|
|
|
if(nCount==0){
|
|
TTierRow* pRow = (TTierRow*)pPolicy->aRows[iRank];
|
|
if(nWLDiff==0){//输赢平手 重打
|
|
nWLDiff = nLos = 0;
|
|
nCount = pRow->hands;
|
|
nRnkChip = nAccChip + pRow->chip;
|
|
return iRank;
|
|
}
|
|
|
|
if(nWLDiff>0){ //赢走向
|
|
iRank = pRow->iWin - 1;
|
|
nAccChip = 0; //净输累计清零
|
|
}
|
|
else{ //输走向
|
|
iRank = pRow->iLos - 1;
|
|
if(iRank>=0 && ((TTierPolicy*)pPolicy)->bTierAccChip){
|
|
if(iRank==0)
|
|
nAccChip = 0;
|
|
else{
|
|
nAccChip += nLos; //净输累加到下一层
|
|
if(nAccChip<0)
|
|
nAccChip = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(iRank>=0){
|
|
pRow = (TTierRow*)pPolicy->aRows[iRank];
|
|
nRnkChip = nAccChip + pRow->chip;
|
|
nCount = pRow->hands;
|
|
nWLDiff = nLos = 0;
|
|
}
|
|
}
|
|
else if(((TTierPolicy*)pPolicy)->bTierLos0){
|
|
if(nWLDiff<0) //输打0
|
|
nRnkChip = 0;
|
|
else{
|
|
TTierRow* pRow = (TTierRow*)pPolicy->aRows[iRank];
|
|
nRnkChip = nAccChip + pRow->chip;
|
|
}
|
|
}
|
|
}
|
|
|
|
return iRank;
|
|
}
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// TLevelChip
|
|
TLevelChip::TLevelChip(bool bG)
|
|
{
|
|
iType = KIND_CHIP_LEV;
|
|
bGlobal = bG;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall TLevelChip::CalcChip()
|
|
{
|
|
TLevelRow* pRow = (TLevelRow*)pPolicy->aRows[iRank];
|
|
nRnkChip = pRow->chip;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall TLevelChip::Reset()
|
|
{
|
|
if(pPolicy){
|
|
bWait = fWLDiff = iRank = 0;
|
|
CalcChip();
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
int __fastcall TLevelChip::HandleResult(int res, double wl)
|
|
{
|
|
if(iRank<0 || res==3 && !bWait)
|
|
return iRank;
|
|
|
|
fWLDiff += wl;
|
|
|
|
bool bLevel = false;
|
|
TLevelRow* pRow = (TLevelRow*)pPolicy->aRows[iRank];
|
|
if(bGlobal && !g_aGames.bFloat && !((TLevelPolicy*)pPolicy)->bInstant){//非立即升降
|
|
if(fWLDiff >= pRow->nCondWin || fWLDiff <= -pRow->nCondLos){ //达到升降条件
|
|
g_aGames.AllBetOff();
|
|
bWait = g_aGames.nBetted[2]>0; //等待结算
|
|
DebugPrint("wait count: %d", g_aGames.nBetted[2]);
|
|
}
|
|
else if(bWait){
|
|
bWait = false;
|
|
DebugPrint("恢复下注 %.2f", fWLDiff);
|
|
}
|
|
}
|
|
|
|
if(!bWait){
|
|
if(fWLDiff >= pRow->nCondWin){ //赢走向
|
|
iRank = pRow->iWin - 1;
|
|
bLevel = true;
|
|
}
|
|
else if(fWLDiff <= -pRow->nCondLos){ //输走向
|
|
iRank = pRow->iLos - 1;
|
|
bLevel = true;
|
|
}
|
|
}
|
|
else{
|
|
DebugPrint("等待结算 %.2f", fWLDiff);
|
|
}
|
|
|
|
if(bLevel && bGlobal && !g_aGames.bFloat && ((TLevelPolicy*)pPolicy)->bInstant)
|
|
g_aGames.AllBetOff();
|
|
|
|
CalcLevelChip(bLevel, res);
|
|
|
|
return iRank;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall TLevelChip::CalcLevelChip(bool bLevel, int res)
|
|
{
|
|
if(bLevel && iRank>=0){
|
|
fWLDiff = 0;
|
|
CalcChip();
|
|
|
|
if(bGlobal && !g_aGames.bFloat){
|
|
PostMessage(Application->MainFormHandle, UM_GLOBAL_BET, 0, 0);
|
|
DebugPrint("升降阶梯 %d", iRank);
|
|
}
|
|
}
|
|
}
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// TComboChip
|
|
TComboChip::TComboChip(bool bG)
|
|
{
|
|
iType = KIND_CHIP_COM;
|
|
pRnkPolicy = NULL;
|
|
bGlobal = bG;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall TComboChip::CalcChip()
|
|
{
|
|
int nBaseChip = 0;
|
|
if(pRnkPolicy->kind==KIND_CHIP_RAN){
|
|
int mi = g_RandomChip.minChip,
|
|
ma = g_RandomChip.maxChip+1; //包含最大值
|
|
nBaseChip = mi + Random(ma - mi);
|
|
}
|
|
else
|
|
nBaseChip = ((TChipRow*)pRnkPolicy->aRows[iRnkSeq])->chip;
|
|
|
|
nRnkChip = nBaseChip * nRnkMul;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall TComboChip::Reset()
|
|
{
|
|
if(pPolicy){
|
|
bWait = false;
|
|
|
|
fWLDiff = iRank = iRnkSeq = 0;
|
|
|
|
TComboRow* pRow = (TComboRow*)pPolicy->aRows[iRank];
|
|
CheckComboRow(pRow);
|
|
|
|
pRnkPolicy = (TChipPolicy*)g_aChipPolicies[pRow->iPolicy];
|
|
|
|
nRnkMul = pRow->chip;
|
|
|
|
if(!bGlobal || g_aGames.bFloat)
|
|
CalcChip();
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall TComboChip::CalcLevelChip(bool bLevel, int res)
|
|
{
|
|
if(bLevel){
|
|
if(iRank>=0){
|
|
TComboRow* pRow = (TComboRow*)pPolicy->aRows[iRank];
|
|
CheckComboRow(pRow);
|
|
|
|
pRnkPolicy = (TChipPolicy*)g_aChipPolicies[pRow->iPolicy];
|
|
|
|
nRnkMul = pRow->chip;
|
|
fWLDiff = iRnkSeq = 0;
|
|
|
|
if(bGlobal && !g_aGames.bFloat){
|
|
g_aGames.ResetRankSeq();
|
|
PostMessage(Application->MainFormHandle, UM_GLOBAL_BET, 0, 0);
|
|
DebugPrint("升降阶梯 %d", iRank);
|
|
}
|
|
else{
|
|
CalcChip();
|
|
}
|
|
}
|
|
}
|
|
else if(!bGlobal || g_aGames.bFloat){
|
|
if(pRnkPolicy->kind!=KIND_CHIP_RAN){
|
|
TChipRow* pCR = (TChipRow*)pRnkPolicy->aRows[iRnkSeq];
|
|
if(res==1)
|
|
iRnkSeq = pCR->iWin - 1;
|
|
else if(res==2)
|
|
iRnkSeq = pCR->iLos - 1;
|
|
|
|
if(iRnkSeq<0) //立即重置
|
|
iRnkSeq = 0;
|
|
}
|
|
|
|
CalcChip();
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
int __fastcall TComboChip::GetComboChip(int& iRnk, int& iSeq)
|
|
{
|
|
if(bWait || iRank<0)
|
|
return -1;
|
|
|
|
if(iRnk!=iRank){
|
|
iRnk = iRank;
|
|
iSeq = 0;
|
|
}
|
|
|
|
int nBaseChip = 0;
|
|
if(pRnkPolicy->kind==KIND_CHIP_RAN){
|
|
int mi = g_RandomChip.minChip,
|
|
ma = g_RandomChip.maxChip+1; //包含最大值
|
|
nBaseChip = mi + Random(ma - mi);
|
|
}
|
|
else
|
|
nBaseChip = ((TChipRow*)pRnkPolicy->aRows[iSeq])->chip;
|
|
|
|
return nBaseChip * nRnkMul;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
int __fastcall TComboChip::GetRankSeq(int res, int iRnk, int iSeq)
|
|
{
|
|
if(res!=3 && iRnk==iRank && pRnkPolicy->kind!=KIND_CHIP_RAN){
|
|
TChipRow* pCR = (TChipRow*)pRnkPolicy->aRows[iSeq];
|
|
if(res==1)
|
|
iSeq = pCR->iWin - 1;
|
|
else
|
|
iSeq = pCR->iLos - 1;
|
|
|
|
if(iSeq<0) //立即重置
|
|
iSeq = 0;
|
|
}
|
|
|
|
return iSeq;
|
|
}
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// TWLDiffChip
|
|
TWLDiffChip::TWLDiffChip(bool bG)
|
|
{
|
|
iType = KIND_CHIP_WLD;
|
|
bGlobal = bG;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall TWLDiffChip::CalcChip()
|
|
{
|
|
TLevelRow* pRow = (TLevelRow*)pPolicy->aRows[iRank];
|
|
nRnkChip = pRow->chip;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall TWLDiffChip::Reset()
|
|
{
|
|
if(pPolicy){
|
|
bWait = nWLDiff = iRank = 0;
|
|
CalcChip();
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
int __fastcall TWLDiffChip::HandleResult(int res, double wl)
|
|
{
|
|
if(iRank<0 || res==3 && !bWait)
|
|
return iRank;
|
|
|
|
if(res==1)
|
|
nWLDiff++;
|
|
else if(res==2)
|
|
nWLDiff--;
|
|
|
|
bool bLevel = false;
|
|
TLevelRow* pRow = (TLevelRow*)pPolicy->aRows[iRank];
|
|
if(bGlobal && !g_aGames.bFloat && !((TLevelPolicy*)pPolicy)->bInstant){//非立即升降
|
|
if(nWLDiff >= pRow->nCondWin || nWLDiff <= pRow->nCondLos){ //达到升降条件
|
|
g_aGames.AllBetOff();
|
|
bWait = g_aGames.nBetted[2]>0; //等待结算
|
|
DebugPrint("wait count: %d", g_aGames.nBetted[2]);
|
|
}
|
|
else if(bWait){
|
|
bWait = false;
|
|
DebugPrint("恢复下注 %d", nWLDiff);
|
|
}
|
|
}
|
|
|
|
if(!bWait){
|
|
if(nWLDiff >= pRow->nCondWin){ //赢走向
|
|
iRank = pRow->iWin - 1;
|
|
bLevel = true;
|
|
}
|
|
else if(nWLDiff <= pRow->nCondLos){ //输走向
|
|
iRank = pRow->iLos - 1;
|
|
bLevel = true;
|
|
}
|
|
}
|
|
else{
|
|
DebugPrint("等待结算 %d", nWLDiff);
|
|
}
|
|
|
|
if(bLevel){
|
|
if(bGlobal && !g_aGames.bFloat && ((TLevelPolicy*)pPolicy)->bInstant)
|
|
g_aGames.AllBetOff();
|
|
|
|
if(iRank>=0){
|
|
if(((TWLDiffPolicy*)pPolicy)->bIndie) //立即清零
|
|
nWLDiff = 0;
|
|
|
|
CalcChip();
|
|
|
|
if(bGlobal && !g_aGames.bFloat){
|
|
PostMessage(Application->MainFormHandle, UM_GLOBAL_BET, 0, 0);
|
|
DebugPrint("升降层级 %d", iRank);
|
|
}
|
|
}
|
|
}
|
|
|
|
return iRank;
|
|
}
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// TGame
|
|
TGame::TGame(int iG)
|
|
{
|
|
iGame = iG;
|
|
hTable = NULL;
|
|
pRankChip = NULL;
|
|
|
|
Reset();
|
|
|
|
char name[16];
|
|
sprintf(name, "%04d", iG);
|
|
pSema = new CSema(name, 1);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
TGame::~TGame()
|
|
{
|
|
for(int i=0; i<4; i++)
|
|
aMap[i].Clear();
|
|
|
|
ClearRankChip();
|
|
delete pSema;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall TGame::ClearRankChip()
|
|
{
|
|
if(pRankChip){
|
|
delete pRankChip;
|
|
pRankChip = NULL;
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
TRankChip* __fastcall TGame::GetRankChip(int type)
|
|
{
|
|
if(pRankChip && !pRankChip->IsTypeOf(type))
|
|
ClearRankChip();
|
|
|
|
if(!pRankChip){
|
|
pRankChip = type==KIND_CHIP_HAN ? (TRankChip*)new TTierChip
|
|
: type==KIND_CHIP_LEV ? (TRankChip*)new TLevelChip
|
|
: type==KIND_CHIP_WLD ? (TRankChip*)new TWLDiffChip
|
|
: (TRankChip*)new TComboChip;
|
|
}
|
|
|
|
return pRankChip;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall TGame::ClearResults()
|
|
{
|
|
aRes.clear();
|
|
|
|
for(int i=0; i<4; i++){
|
|
aRoad[i].clear();
|
|
lastRoad[i] = 0;
|
|
aMap[i].Clear(); //清理图数据
|
|
}
|
|
memset(winCount, 0, sizeof(winCount));
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
void __fastcall TGame::Reset()
|
|
{
|
|
profit = iState = iBet = nChip = iBetSeq = iChipSeq = 0;
|
|
gmstatus = timeout = countdown = 0;
|
|
bcard = pcard = "";
|
|
memset(seqCount, 0, sizeof(seqCount));
|
|
|
|
ClearResults();
|
|
aManBets.clear();
|
|
|
|
bRun = bRev = bReset = bBreak = bPause
|
|
= bReal = bIndPolicy = false;
|
|
nChipMul = iRoad = iBetPolicy = iChipPolicy = -1;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
void __fastcall TGame::ResetBet()
|
|
{
|
|
ClearBets();
|
|
|
|
iState = iBet = nChip = iBetSeq = iChipSeq = 0;
|
|
bReal = bReset = false;
|
|
aBets.clear();
|
|
|
|
if(pRankChip)
|
|
pRankChip->Reset();
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
int __fastcall TGame::Color2Bet(TBetPolicy* pBP, char clr)
|
|
{
|
|
int bet = 0;
|
|
|
|
int s0 = aRoad[0].back(), //大路最后1列个数(假设为断)
|
|
sR = aRoad[0][aRoad[0].size() - pBP->road];
|
|
char c = s0==sR ? 1 : 2; //齐脚跳红
|
|
if(c==clr) //此处为红蓝
|
|
bet = lastRoad[0] ^ 0x3; //大路断
|
|
else
|
|
bet = lastRoad[0]; //大路连
|
|
|
|
return bet;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
void __fastcall TGame::CalcBet()
|
|
{
|
|
iBet = nChip = 0; //默认不下注
|
|
|
|
int iBP = iBetPolicy>=0 ? iBetPolicy : g_iBetPolicy;
|
|
TBetPolicy* pBP = (TBetPolicy*)g_aBetPolicies[iBP];
|
|
|
|
int uBP = iBetSeq >> 16,
|
|
uSeq = 0;
|
|
if(uBP!=pBP->id){ //改用ID判断避免方案删除带来问题
|
|
uBP = pBP->id;
|
|
aBets.clear();
|
|
}
|
|
|
|
if(!aBets.empty()){ //连续下注项
|
|
if(aBets[0]==0 || aBets[0]==4){
|
|
iBet = aBets[0];
|
|
}
|
|
else if(pBP->road<=1 || aBets[0]==3){ //珠盘/大路或打和
|
|
iBet = aBets[0]; //此处为庄闲和
|
|
}
|
|
else if(aRoad[0].size() >= pBP->road){//下三路
|
|
iBet = Color2Bet(pBP, aBets[0]);
|
|
}
|
|
}
|
|
else if(pBP->road==0){ //珠盘路
|
|
if(aRes.empty())
|
|
return;
|
|
|
|
if(pBP->kind==KIND_BET_DIF){ //庄闲差
|
|
int diff = winCount[0] - winCount[1];
|
|
int i = diff>=g_BPDiffBet.diff[0] ? 0
|
|
: diff<=-g_BPDiffBet.diff[1] ? 1
|
|
: -1;
|
|
if(i>=0){
|
|
vector<char> bets = TBetPolicy::ParseBet(g_BPDiffBet.bets[i]);
|
|
|
|
iBet = bets[0];
|
|
if(bets.size()>1){
|
|
for(int j=0; j<bets.size(); j++)
|
|
aBets.push_back(bets[j]);
|
|
}
|
|
}
|
|
}
|
|
else{
|
|
for(int i=0; i<pBP->aRows.size(); i++){ //按从上往下的顺序匹配
|
|
TBetRow* pRow = (TBetRow*)pBP->aRows[i];
|
|
|
|
bool bAllMatched = true;
|
|
int pos = aRes.size()-1; //最后一个位置开始
|
|
for(int j=pRow->cond.size()-1; j>=0; j--){ //从后往前匹配
|
|
int item = pRow->cond[j];
|
|
bool up = item & 0x80;
|
|
char ch = item & 0x3;
|
|
int num = (item & 0x7C) >> 2;
|
|
|
|
if(pos<0 || ch!=aRes[pos--]){ //个数不足或颜色不匹配
|
|
bAllMatched = false;
|
|
break;
|
|
}
|
|
|
|
bool bMatched = true;
|
|
for(int k=1; k<num; k++){
|
|
if(pos<0 || ch!=aRes[pos--]){//个数不足或颜色不匹配
|
|
bMatched = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(!bMatched){
|
|
bAllMatched = false;
|
|
break;
|
|
}
|
|
|
|
if(up){ //不定长
|
|
while(ch==aRes[pos]) pos--; //一直找到不同颜色
|
|
}
|
|
}
|
|
|
|
if(bAllMatched){ //匹配成功
|
|
iBet = pRow->bets[0];
|
|
if(pRow->bets.size()>1){
|
|
for(int j=0; j<pRow->bets.size(); j++)
|
|
aBets.push_back(pRow->bets[j]);
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else{
|
|
vector<char>& road = aRoad[pBP->road-1];
|
|
if(road.empty())
|
|
return;
|
|
|
|
if(pBP->kind==KIND_BET_ASK){ //庄闲问路
|
|
int size0 = aRoad[0].size();
|
|
if(size0<4) return; //不够列数
|
|
|
|
if(size0>=4){
|
|
char cl[3], sR,
|
|
s0 = aRoad[0].back(); //大路最后1列个数(假设为断)
|
|
for(int i=0; i<3; i++){
|
|
sR = aRoad[0][size0 - i - 2];
|
|
cl[i] = s0==sR ? 1 : 2;
|
|
}
|
|
|
|
if(cl[0]!=cl[1] || cl[1]!=cl[2]) //不同色
|
|
return;
|
|
|
|
if(lastRoad[0]==2 && cl[0]==1 || lastRoad[0]==1 && cl[0]==2) //庄全红/闲全蓝
|
|
iBet = g_BPAskBet.bet[0];
|
|
else if(lastRoad[0]==1 && cl[0]==1 || lastRoad[0]==2 && cl[0]==2) //闲全红/庄全蓝
|
|
iBet = g_BPAskBet.bet[1];
|
|
}
|
|
}
|
|
else{
|
|
for(int i=0; i<pBP->aRows.size(); i++){ //按从上往下的顺序匹配
|
|
TBetRow* pRow = (TBetRow*)pBP->aRows[i];
|
|
if(road.size()<pRow->cond.size()) //列数不足
|
|
continue;
|
|
|
|
bool bAllMatched = true;
|
|
char last = lastRoad[pBP->road-1];
|
|
int col = road.size()-1; //最后一列开始
|
|
for(int j=pRow->cond.size()-1; j>=0 && bAllMatched; j--){ //从后往前匹配
|
|
int item = pRow->cond[j];
|
|
bool up = item & 0x80;
|
|
char ch = item & 0x3;
|
|
int num = (item & 0x7C) >> 2;
|
|
|
|
if(ch==last && (up && road[col]>=num || !up && road[col]==num)){ //该列成功
|
|
col--; //匹配下一列
|
|
last ^= 0x3; //下一列的颜色
|
|
}
|
|
else
|
|
bAllMatched = false;;
|
|
}
|
|
|
|
if(bAllMatched){ //匹配成功
|
|
if(pRow->bets[0]==0 || pRow->bets[0]==4){
|
|
iBet = pRow->bets[0];
|
|
}
|
|
if(pBP->road==1 || pRow->bets[0]==3){
|
|
iBet = pRow->bets[0]; //此处为庄闲和
|
|
}
|
|
else if(aRoad[0].size() >= pBP->road){//下三路
|
|
iBet = Color2Bet(pBP, pRow->bets[0]);
|
|
}
|
|
|
|
if(pRow->bets.size()>1){
|
|
for(int j=0; j<pRow->bets.size(); j++)
|
|
aBets.push_back(pRow->bets[j]);
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
iBetSeq = (uBP<<16) + aRes.size()+1;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
void __fastcall TGame::CalcChip()
|
|
{
|
|
int iCP = iChipPolicy>=0 ? iChipPolicy : g_iChipPolicy;
|
|
TChipPolicy* pCP = (TChipPolicy*)g_aChipPolicies[iCP];
|
|
bool bGlobalChip = !bIndPolicy && (g_aGames.bFloat || pCP->kind>=KIND_CHIP_LEV
|
|
&& pCP->kind<=KIND_CHIP_WLD
|
|
&& ((TLevelPolicy*)pCP)->bTotalDiff);
|
|
int& iCS = !bIndPolicy && g_aGames.bFloat ? g_aGames.iChipSeq : iChipSeq;
|
|
|
|
int uCP = iCS >> 20,
|
|
uCRnk = (iCS & 0xFF000) >> 12,
|
|
uCSeq = iCS & 0xFFF;
|
|
if(uCP!=pCP->id){ //改用ID判断避免方案删除带来问题
|
|
uCRnk = uCSeq = 0;
|
|
iCS = (pCP->id<<20);
|
|
|
|
if(pCP->kind>=KIND_CHIP_HAN && pCP->kind<=KIND_CHIP_WLD){
|
|
TRankChip* pRC = bGlobalChip ? g_aGames.GetRankChip(pCP->kind)
|
|
: GetRankChip(pCP->kind);
|
|
pRC->SetPolicy(pCP);
|
|
}
|
|
else{
|
|
if(bGlobalChip && g_aGames.pRankChip)
|
|
g_aGames.ClearRankChip();
|
|
else
|
|
ClearRankChip();
|
|
}
|
|
}
|
|
|
|
if(pCP->kind>=KIND_CHIP_HAN && pCP->kind<=KIND_CHIP_WLD){
|
|
TRankChip* pRC = bGlobalChip ? g_aGames.GetRankChip(pCP->kind)
|
|
: GetRankChip(pCP->kind);
|
|
if(pCP->kind==KIND_CHIP_COM && bGlobalChip && !g_aGames.bFloat){
|
|
nChip = ((TComboChip*)pRC)->GetComboChip(uCRnk, uCSeq);
|
|
if(nChip>=0)
|
|
iCS = (pCP->id<<20) + (uCRnk<<12) + uCSeq;
|
|
}
|
|
else
|
|
nChip = pRC->GetChip();
|
|
|
|
if(nChip>0 && pCP->kind!=KIND_CHIP_COM)
|
|
nChip *= nChipMul<0 ? g_nChipMul : nChipMul;
|
|
}
|
|
else if(pCP->kind==KIND_CHIP_RAN){
|
|
int mi = g_RandomChip.minChip,
|
|
ma = g_RandomChip.maxChip+1; //包含最大值
|
|
nChip = mi + Random(ma - mi);
|
|
}
|
|
else{
|
|
TChipRow* pRow = (TChipRow*)pCP->aRows[uCSeq];
|
|
nChip = pRow->chip * (bIndPolicy ? nChipMul : g_nChipMul); //乘上倍数
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
int __fastcall TGame::CalcResult(int op)
|
|
{
|
|
int uBP = iBetSeq >> 16,
|
|
uBSeq = iBetSeq & 0xFFFF;
|
|
|
|
if(!iBet || !uBSeq)// || uBSeq>aRes.size() && op!=2)// || !nChip) 允许注码为0
|
|
return 0;
|
|
|
|
int dType = 0; //是否爆缆
|
|
int ret = 3;
|
|
double wl = 0;
|
|
|
|
if(op<2){ //非超时
|
|
int res = aRes[uBSeq-1];
|
|
|
|
if(!aBets.empty() && (!g_settings.bBetsNoTie || res!=3 || iBet==3) ){ //连续下注，不忽略和|结果非和|下注和，删除本项
|
|
aBets.erase(aBets.begin());
|
|
}
|
|
|
|
if(iBet==res){ //赢
|
|
ret = 1;
|
|
if(iBet==1)
|
|
wl = nChip * 0.95;
|
|
else if(iBet==2)
|
|
wl = nChip;
|
|
else
|
|
wl = nChip * 8;
|
|
}
|
|
else if(res!=3){ //输
|
|
ret = 2;
|
|
wl = -nChip;
|
|
}
|
|
else if(nChip>0){ //有效流水不计和
|
|
g_aGames.betData.amounts[0] -= nChip;
|
|
|
|
if(bReal){ //和 实打统计
|
|
g_aGames.betData.amounts[1] -= nChip; //实打流水
|
|
g_nRBReport -= nChip;
|
|
}
|
|
|
|
PostMessage(Application->MainFormHandle, UM_STATE_UPDATE, STATE_AMOUNT, 0);
|
|
}
|
|
|
|
TBetLog* pLog = NewBetLog();
|
|
pLog->ev = LOGEVT_RES;
|
|
pLog->op = ret;
|
|
pLog->num = wl;
|
|
SendMessage(Application->MainFormHandle, UM_LOG_UPDATE, 0, (long)pLog);
|
|
}
|
|
else if(op==3){//注单撤销
|
|
g_aGames.betData.amounts[0] -= nChip;
|
|
|
|
if(bReal){ //实打统计
|
|
g_aGames.betData.amounts[1] -= nChip; //实打流水
|
|
g_nRBReport -= nChip;
|
|
}
|
|
|
|
PostMessage(Application->MainFormHandle, UM_STATE_UPDATE, STATE_AMOUNT, 0);
|
|
|
|
TBetLog* pLog = NewBetLog();
|
|
pLog->ev = LOGEVT_QUASH;
|
|
SendMessage(Application->MainFormHandle, UM_LOG_UPDATE, 0, (long)pLog);
|
|
}
|
|
else if(op==2 && (g_aGames.bFloat || !g_aGames.pRankChip)){ //超时仅处理总体组合阶梯
|
|
return ret;
|
|
}
|
|
|
|
//处理注码步骤
|
|
int iCP = iChipPolicy>=0 ? iChipPolicy : g_iChipPolicy;
|
|
TChipPolicy* pCP = (TChipPolicy*)g_aChipPolicies[iCP];
|
|
bool bGlobalChip = !bIndPolicy && (g_aGames.bFloat || pCP->kind>=KIND_CHIP_LEV
|
|
&& pCP->kind<=KIND_CHIP_WLD
|
|
&& ((TLevelPolicy*)pCP)->bTotalDiff);
|
|
int& iCS = !bIndPolicy && g_aGames.bFloat ? g_aGames.iChipSeq : iChipSeq;
|
|
int uCP = iCS >> 20,
|
|
uCRnk = (iCS & 0xFF000) >> 12,
|
|
uCSeq = iCS & 0xFFF;
|
|
if(uCP!=pCP->id){
|
|
uCRnk = uCSeq = 0;
|
|
|
|
if(pCP->kind>=KIND_CHIP_HAN && pCP->kind<=KIND_CHIP_WLD){
|
|
TRankChip* pRC = bGlobalChip ? g_aGames.GetRankChip(pCP->kind)
|
|
: GetRankChip(pCP->kind);
|
|
pRC->SetPolicy(pCP);
|
|
}
|
|
else{
|
|
if(bGlobalChip && g_aGames.pRankChip)
|
|
g_aGames.ClearRankChip();
|
|
else
|
|
ClearRankChip();
|
|
}
|
|
}
|
|
else if(pCP->kind>=KIND_CHIP_HAN && pCP->kind<=KIND_CHIP_WLD){
|
|
TRankChip* pRC = bGlobalChip ? g_aGames.GetRankChip(pCP->kind) : GetRankChip(pCP->kind);
|
|
|
|
if(pCP->kind==KIND_CHIP_COM && bGlobalChip && !g_aGames.bFloat && op<2)
|
|
uCSeq = ((TComboChip*)pRC)->GetRankSeq(ret, uCRnk, uCSeq);
|
|
|
|
int rnk = (g_aGames.bFloat && g_aGames.iFloatGame!=iGame) ? uCRnk
|
|
: pRC->HandleResult(ret, wl);
|
|
if(rnk!=uCRnk){
|
|
uCRnk = rnk;
|
|
uCSeq = 0;
|
|
}
|
|
}
|
|
else if(pCP->kind==KIND_CHIP_NOR && (!g_aGames.bFloat || g_aGames.iFloatGame==iGame)){
|
|
TChipRow* pRow = (TChipRow*)pCP->aRows[uCSeq];
|
|
if(ret==1)
|
|
uCSeq = pRow->iWin - 1;
|
|
else if(ret==2)
|
|
uCSeq = pRow->iLos - 1;
|
|
}
|
|
|
|
if(uCSeq<0 || uCRnk<0){
|
|
dType = pCP->dead + 1;
|
|
uCRnk = uCSeq = 0;
|
|
|
|
g_aGames.betData.dead++;
|
|
|
|
if(!bGlobalChip){
|
|
TBetLog* pLog = NewBetLog();
|
|
pLog->ev = LOGEVT_DEAD;
|
|
pLog->op = pCP->dead;
|
|
pLog->num = pCP->deadPause;
|
|
SendMessage(Application->MainFormHandle, UM_LOG_UPDATE, 0, (long)pLog);
|
|
}
|
|
|
|
PostMessage(Application->MainFormHandle, UM_STATE_UPDATE, STATE_MISC, 0);
|
|
}
|
|
|
|
if(op<=2) //撤销不更新iCS
|
|
iCS = (pCP->id<<20) + (uCRnk<<12) + uCSeq;
|
|
|
|
if(wl!=0){
|
|
profit += wl;
|
|
|
|
//模拟实打赢利统计
|
|
if(bReal){
|
|
g_aGames.betData.profits[4] += wl;
|
|
g_aGames.betData.profits[7] += wl;
|
|
}
|
|
else
|
|
g_aGames.betData.profits[6] += wl;
|
|
|
|
//当期赢利
|
|
g_aGames.betData.profits[3] += wl;
|
|
|
|
if(wl>0 && g_aGames.fCurrProfitPeak < g_aGames.betData.profits[3]) //更新当期赢利峰值
|
|
g_aGames.fCurrProfitPeak = g_aGames.betData.profits[3];
|
|
|
|
//总赢利及峰谷值
|
|
double profit = g_aGames.betData.profits[0] + wl;
|
|
g_aGames.betData.profits[0] = profit;
|
|
if(profit>g_aGames.betData.profits[1]){
|
|
g_aGames.betData.profits[1] = profit;
|
|
PostMessage(Application->MainFormHandle, UM_STATE_UPDATE, STATE_PEAK, 1);
|
|
}
|
|
else if(profit<g_aGames.betData.profits[2]){
|
|
g_aGames.betData.profits[2] = profit;
|
|
PostMessage(Application->MainFormHandle, UM_STATE_UPDATE, STATE_PEAK, 2);
|
|
}
|
|
}
|
|
|
|
if(op!=2 && wl>=0 && nChip>0){
|
|
if(g_settings.bSimAccOn){
|
|
bool bUpdate = false;
|
|
if(!bReal || g_settings.bSyncReal){ //赢跟和都要加本金
|
|
g_settings.fSimAcc += wl + nChip;
|
|
bUpdate = true;
|
|
}
|
|
|
|
if(bReal && g_bTesting){
|
|
g_fBalance += wl + nChip;
|
|
bUpdate = true;
|
|
}
|
|
|
|
if(bUpdate)
|
|
PostMessage(Application->MainFormHandle, UM_STATE_UPDATE, STATE_BALANCE, 0);
|
|
}
|
|
}
|
|
|
|
if(ret==1){
|
|
g_aGames.betData.counts[0]++;
|
|
PostMessage(Application->MainFormHandle, UM_STATE_UPDATE, STATE_COUNT, 0);
|
|
|
|
int* seq = g_aGames.bFloat ? g_aGames.seqCount : seqCount;
|
|
seq[0]++;
|
|
if(seq[0] > g_aGames.betData.counts[2]){
|
|
g_aGames.betData.counts[2] = seq[0];
|
|
PostMessage(Application->MainFormHandle, UM_STATE_UPDATE, STATE_COUNT, 2);
|
|
}
|
|
seq[1] = 0;//连输终止
|
|
}
|
|
else if(ret==2){
|
|
g_aGames.betData.counts[1]++;
|
|
PostMessage(Application->MainFormHandle, UM_STATE_UPDATE, STATE_COUNT, 1);
|
|
|
|
int* seq = g_aGames.bFloat ? g_aGames.seqCount : seqCount;
|
|
seq[1]++;
|
|
if(seq[1] > g_aGames.betData.counts[3]){
|
|
g_aGames.betData.counts[3] = seq[1];
|
|
PostMessage(Application->MainFormHandle, UM_STATE_UPDATE, STATE_COUNT, 3);
|
|
}
|
|
seq[0] = 0;//连赢终止
|
|
}
|
|
|
|
if(wl!=0)
|
|
PostMessage(Application->MainFormHandle, UM_STATE_UPDATE, STATE_BET_R, ret);
|
|
|
|
if(dType) ret += dType<<16;
|
|
return ret;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
void __fastcall TGame::HandleResult(int op)
|
|
{
|
|
timeout = 0;
|
|
|
|
if(!aManBets.empty()){ //处理手工下注
|
|
if(op==0){ //正常结算
|
|
int res = aRes.back();
|
|
double wl = 0;
|
|
for(int i=aManBets.size()-1; i>=0; i--){
|
|
TManBet& rMB = aManBets[i];
|
|
if(rMB.state==ST_BETTED){
|
|
if(res==1)
|
|
wl += rMB.chips[0] * 0.95 - rMB.chips[1] - rMB.chips[2];
|
|
else if(res==2)
|
|
wl += rMB.chips[1] - rMB.chips[0] - rMB.chips[2];
|
|
else if(res==3){ //和
|
|
wl += rMB.chips[2] * 8; // - rMB.chips[0] - rMB.chips[1];
|
|
|
|
int refund = rMB.chips[0] + rMB.chips[1]; //有效投注不计和
|
|
if(refund){
|
|
g_nRBReport -= refund;
|
|
g_aGames.betData.amounts[2] -= refund; //手工流水
|
|
PostMessage(Application->MainFormHandle, UM_STATE_UPDATE, STATE_MAN, 1);
|
|
}
|
|
}
|
|
}
|
|
aManBets.pop_back();
|
|
}
|
|
|
|
if(hTable) PostMessage(hTable, UM_TAB_UPDATE, UPDATE_MANRES, wl);
|
|
|
|
if(wl!=0){
|
|
g_aGames.betData.profits[5] += wl;
|
|
PostMessage(Application->MainFormHandle, UM_STATE_UPDATE, STATE_MAN, 0);
|
|
}
|
|
}
|
|
else if(op==1){ //数据异常
|
|
aManBets.clear();
|
|
}
|
|
else if(op==3){ //注单撤销
|
|
for(int i=aManBets.size()-1; i>=0; i--){
|
|
TManBet& rMB = aManBets[i];
|
|
if(rMB.state==ST_BETTED){
|
|
int refund = rMB.chips[0] + rMB.chips[1] + rMB.chips[2]; //有效投注不计和
|
|
if(refund){
|
|
g_nRBReport -= refund;
|
|
g_aGames.betData.amounts[2] -= refund; //手工流水
|
|
PostMessage(Application->MainFormHandle, UM_STATE_UPDATE, STATE_MAN, 1);
|
|
}
|
|
}
|
|
aManBets.pop_back();
|
|
}
|
|
}
|
|
}
|
|
|
|
if((iState==ST_BETTED || iState==ST_EXPIRED) && ((iBetSeq & 0xFFFF)<=aRes.size() || op>=2)){
|
|
if(iState==ST_BETTED){
|
|
if(g_aGames.nBetted[bReal]>0)
|
|
g_aGames.nBetted[bReal]--; //减少下注个数
|
|
if(!bIndPolicy && g_aGames.nBetted[2]>0)
|
|
g_aGames.nBetted[2]--; //全局计算下注个数
|
|
}
|
|
|
|
if(op==2)
|
|
iState = ST_EXPIRED;
|
|
else if(op==3)
|
|
iState = ST_QUASH;
|
|
else
|
|
iState = ST_PAID;
|
|
|
|
int ret = CalcResult(op);
|
|
|
|
if(g_bGameOn){
|
|
int dead = ret >> 16;
|
|
|
|
if(bRun && (op<2 || dead)){
|
|
int wl = ret & 0xFF;
|
|
|
|
//止赢止损
|
|
bool stop = false;
|
|
if(wl==1 && g_settings.bTableStopWin && profit>=g_settings.nTableStopWin //单桌止赢
|
|
|| wl==2 && g_settings.bTableStopLos && profit<=-g_settings.nTableStopLos){ //单桌止赢
|
|
stop = true;
|
|
|
|
TBetLog* pLog = NewBetLog();
|
|
pLog->ev = wl==1 ? LOGEVT_STOPWIN : LOGEVT_STOPLOS;
|
|
pLog->op = wl==1 ? g_settings.iTableWinOp : g_settings.iTableLosOp;
|
|
pLog->num = wl==1 ? g_settings.nTableWinPause : g_settings.nTableLosPause;
|
|
SendMessage(Application->MainFormHandle, UM_LOG_UPDATE, 0, (long)pLog);
|
|
}
|
|
|
|
//处理游台
|
|
bool bFloat = false;
|
|
if(g_aGames.bFloat && g_aGames.iFloatGame==iGame){
|
|
if((g_settings.iFloatMode & 1) && aBets.empty() //连续下注项结束换台
|
|
|| (g_settings.iFloatMode & 4) && wl==2 //输换台
|
|
|| (g_settings.iFloatMode & 8) && wl==1 //赢换台
|
|
|| (g_settings.iFloatMode & 16) && wl==3 //和换台
|
|
|| g_settings.bHaltBet && aRes.size()>=g_settings.nHaltBet){//开局X手后停止下注
|
|
aBets.clear();
|
|
g_aGames.SetSwitchable(true, iGame);
|
|
bFloat = true;
|
|
}
|
|
|
|
if(dead && g_bGameOn){
|
|
int pause = dead==3 ? ((TChipPolicy*)g_aChipPolicies[g_iChipPolicy])->deadPause : 0;
|
|
SendMessage(Application->MainFormHandle, UM_FLOAT_DEAD, dead-1, pause);
|
|
}
|
|
}
|
|
|
|
//处理爆缆
|
|
if(dead && (bIndPolicy || !g_aGames.bFloat)){
|
|
if(!bIndPolicy && g_aGames.pRankChip){
|
|
// DebugPrint("总体阶梯爆缆");
|
|
int pause = dead==3 ? ((TChipPolicy*)g_aChipPolicies[g_iChipPolicy])->deadPause : 0;
|
|
SendMessage(Application->MainFormHandle, UM_GLOBAL_DEAD, dead-1, pause);
|
|
}
|
|
else{
|
|
bReset = true;
|
|
if(dead==2) //新局重启
|
|
bBreak = true;
|
|
}
|
|
}
|
|
|
|
//处理止盈止损
|
|
if(stop){
|
|
bReset = true;
|
|
|
|
int iOp = wl==1 ? g_settings.iTableWinOp : g_settings.iTableLosOp;
|
|
ret += (iOp+1)<<24;
|
|
if(iOp==1) //新局重启
|
|
bBreak = true;
|
|
}
|
|
|
|
if(bFloat && !dead)
|
|
PostMessage(Application->MainFormHandle, UM_FLOAT_BET, 0, 0);
|
|
}
|
|
else if(g_aGames.bFloat && g_aGames.iFloatGame==iGame){
|
|
g_aGames.SetSwitchable(true, 0); //非强制换台
|
|
PostMessage(Application->MainFormHandle, UM_FLOAT_BET, 0, 0);
|
|
}
|
|
}
|
|
|
|
if(op!=2)
|
|
if(hTable) PostMessage(hTable, UM_LOG_UPDATE, iState, ret);
|
|
}
|
|
else if(iState==ST_PAID || iState==ST_NOBET){
|
|
iState = ST_INIT;
|
|
if(hTable) PostMessage(hTable, UM_LOG_UPDATE, iState, 0);
|
|
}
|
|
|
|
if(op<2){
|
|
iBetSeq &= 0xFFFF0000;
|
|
|
|
if(hTable) PostMessage(hTable, UM_TAB_UPDATE, UPDATE_ROAD, 0);
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
void __fastcall TGame::ClearBets()
|
|
{
|
|
aManBets.clear();
|
|
|
|
if(iState==ST_BETTED || iState==ST_EXPIRED){
|
|
if(iState==ST_BETTED){
|
|
if(g_aGames.nBetted[bReal]>0)
|
|
g_aGames.nBetted[bReal]--; //减少下注个数
|
|
if(!bIndPolicy && g_aGames.nBetted[2]>0)
|
|
g_aGames.nBetted[2]--; //全局计算下注个数
|
|
}
|
|
|
|
iState = iBetSeq = 0;
|
|
timeout = 0;
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
bool __fastcall TGame::CanBet()
|
|
{
|
|
return bRun && g_bGameOn && !bPause && !g_bBetPause && (bIndPolicy || !g_bDeadPause);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
void __fastcall TGame::GameOn()
|
|
{
|
|
if(g_settings.bInitBetChipByStart || g_aGames.bFloat) //挂机初始化/游台也要初始化
|
|
bReset = true;
|
|
|
|
if(g_settings.bInitTabProfitByStart){ //开始挂机重置台桌赢利
|
|
profit = 0;
|
|
PostMessage(hTable, UM_TAB_UPDATE, UPDATE_RESET, 0);
|
|
}
|
|
|
|
if(g_settings.bInitClearTabLog) //开始挂机清空台桌下注记录
|
|
SendMessage(hTable, UM_LOG_UPDATE, -1, 0);
|
|
|
|
if(g_settings.bWaitNew && aRes.size()>0){ //挂机等待新局
|
|
bBreak = true;
|
|
}
|
|
else{
|
|
bBreak = false;
|
|
|
|
if(bRun && gmstatus==1 && timeout>4)
|
|
AutoBetOn();
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
void __fastcall TGame::GameOff()
|
|
{
|
|
AutoBetOff();
|
|
bReset = bBreak = false;
|
|
|
|
if(bPause){
|
|
bPause = false;
|
|
PostMessage(hTable, UM_TAB_UPDATE, UPDATE_RESET, 3);
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
void __fastcall TGame::AutoBetOn(bool bR)
|
|
{
|
|
CMutexLock mutex(pSema);
|
|
|
|
if(iState>=ST_NOBET && iState<=ST_BETTED) //已下注
|
|
return;
|
|
|
|
if((iState==ST_PAID || iState==ST_QUASH) && gmstatus!=0 && gmstatus!=2){
|
|
iState = ST_INIT;
|
|
if(hTable) PostMessage(hTable, UM_LOG_UPDATE, iState, 0);
|
|
}
|
|
|
|
if(bR) bReset = true;
|
|
|
|
if(aRes.empty() && bRun && g_bGameOn && (gmstatus==1 || gmstatus==12)){ //新局上报，不受暂停影响
|
|
bBreak = false;
|
|
|
|
if(iState!=ST_ROUND){
|
|
iState = ST_ROUND;
|
|
if(hTable) PostMessage(hTable, UM_LOG_UPDATE, iState, 0);
|
|
TBetLog* pLog = NewBetLog();
|
|
pLog->ev = LOGEVT_ROUND;
|
|
SendMessage(Application->MainFormHandle, UM_LOG_UPDATE, 0, (long)pLog);
|
|
|
|
if(g_settings.bInitBetByGame){ //新局重置打法
|
|
iBet = iBetSeq = 0;
|
|
aBets.clear();
|
|
}
|
|
|
|
if(g_settings.bInitChipByGame){ //新局重置注码
|
|
nChip = iChipSeq = 0;
|
|
}
|
|
|
|
if(g_settings.bInitProfitByGame && profit!=0 //新局重置赢利
|
|
|| g_settings.bTableStopWin && profit>=g_settings.nTableStopWin //止赢重置
|
|
|| g_settings.bTableStopLos && profit<=-g_settings.nTableStopLos){ //止损重置
|
|
profit = 0;
|
|
PostMessage(hTable, UM_TAB_UPDATE, UPDATE_RESET, 0);
|
|
}
|
|
}
|
|
|
|
if(aBets.empty()) //连续下注可从新局开始
|
|
return;
|
|
}
|
|
|
|
if(bBreak || gmstatus!=1 || !CanBet() || !g_bSimulate && timeout<3){ //非下注状态/暂停中/实打时间太短，放弃
|
|
return;
|
|
}
|
|
|
|
if(g_settings.bHoldBet && aRes.size()<g_settings.nHoldBet //开局X手后开始下注
|
|
|| g_settings.bHaltBet && aRes.size()>=g_settings.nHaltBet){ //开局X手后停止下注
|
|
return;
|
|
}
|
|
|
|
if(g_aGames.bFloat && !bIndPolicy && !g_aGames.CanFloatBet(iGame)){//游台是否能下注
|
|
return;
|
|
}
|
|
|
|
if(bReset)
|
|
ResetBet();
|
|
CalcBet();
|
|
|
|
if(g_aGames.bFloat && !bIndPolicy){
|
|
if(!g_aGames.CanFloatBet(iGame)){ //游台是否能下注
|
|
iBet = iBetSeq = bBreak = 0;
|
|
aBets.clear();
|
|
}
|
|
else if(iBet>0 && iBet<4){
|
|
g_aGames.SetSwitchable(false, iGame); //游台下注
|
|
}
|
|
else if(!g_aGames.bSwitchable && g_aGames.iFloatGame==iGame
|
|
&& aBets.size()==1 && (g_settings.iFloatMode & 1)){ //最后一项不打，强制换台
|
|
g_aGames.SetSwitchable(true, iGame);
|
|
}
|
|
}
|
|
|
|
if(iBet==0 || iBet==4){
|
|
if(!aBets.empty()){//连续下注 不打/局停不可取消
|
|
aBets.erase(aBets.begin()); //删除本项
|
|
|
|
iState = ST_NOBET;
|
|
if(hTable) PostMessage(hTable, UM_LOG_UPDATE, iState, 0);
|
|
|
|
// TBetLog* pLog = NewBetLog();
|
|
// pLog->ev = LOGEVT_BET;
|
|
// pLog->op = iBet;
|
|
// SendMessage(Application->MainFormHandle, UM_LOG_UPDATE, 0, (long)pLog);
|
|
}
|
|
|
|
if(iBet==4)
|
|
bBreak = true;
|
|
|
|
return;
|
|
}
|
|
|
|
CalcChip();
|
|
if(nChip>=0){
|
|
iState = ST_BETSET;
|
|
if(hTable) PostMessage(hTable, UM_LOG_UPDATE, iState, 0);
|
|
PostMessage(Application->MainFormHandle, UM_SETBET, iGame, 0);
|
|
|
|
if(nChip>g_aGames.betData.maxChip){ //最大下注金额
|
|
g_aGames.betData.maxChip = nChip;
|
|
PostMessage(Application->MainFormHandle, UM_STATE_UPDATE, STATE_MISC, 0);
|
|
}
|
|
}
|
|
|
|
//止赢止损后需重置赢利
|
|
if(g_settings.bTableStopWin && profit>=g_settings.nTableStopWin
|
|
|| g_settings.bTableStopLos && profit<=-g_settings.nTableStopLos){
|
|
profit = 0;
|
|
PostMessage(hTable, UM_TAB_UPDATE, UPDATE_RESET, 0);
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
void __fastcall TGame::AutoBetOff(bool bB)
|
|
{
|
|
CMutexLock mutex(pSema);
|
|
|
|
if(iState==ST_BETSET || iState==ST_BETTING){ //下注超时或取消
|
|
iState = ST_CANCELED;
|
|
iBet = nChip = 0;
|
|
// iBetSeq &= 0xFFFF0000;
|
|
|
|
// aBets.clear();
|
|
if(hTable) PostMessage(hTable, UM_LOG_UPDATE, iState, 0);
|
|
}
|
|
// else if(!bRun)
|
|
// aBets.clear();
|
|
|
|
if(iState!=ST_BETTED && g_bGameOn && g_aGames.bFloat && !g_aGames.bSwitchable
|
|
&& g_aGames.iFloatGame==iGame){ //游台取消下注标志，以免阻塞下注
|
|
if(!bRun || (g_settings.iFloatMode & 1) && aBets.empty()){ //每注换台或本台停止
|
|
g_aGames.SetSwitchable(true, 0); //非强制换台
|
|
PostMessage(Application->MainFormHandle, UM_FLOAT_BET, 0, 0);
|
|
}
|
|
}
|
|
|
|
// if(iState==ST_NOBET){
|
|
// iState = ST_INIT;
|
|
// if(hTable) PostMessage(hTable, UM_LOG_UPDATE, iState, 0);
|
|
// }
|
|
|
|
if(bB && aRes.size()>0) bBreak = true;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
void __fastcall TGame::BetResp(int res, int chips[])
|
|
{
|
|
if(chips){ //ABThread返回时仅手工下注会携带chips
|
|
for(int i=aManBets.size()-1; i>=0; i--){ //先匹配手工下注
|
|
TManBet& rMB = aManBets[i];
|
|
|
|
if(rMB.state==ST_BETTING){
|
|
if(g_iPlatform==PF_DB && res){ //DB平台下注失败无法匹配金额
|
|
bool bMatch = true;
|
|
if(chips[0] || chips[1] || chips[2]){
|
|
for(int c=0; c<3; c++){
|
|
if(!chips[c] && rMB.chips[c] || chips[c] && !rMB.chips[c]){
|
|
bMatch = false;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(!bMatch)
|
|
continue;
|
|
}
|
|
else if(memcmp(chips, rMB.chips, sizeof(rMB.chips))) //非DB平台或下注成功 需确认金额匹配
|
|
continue;
|
|
|
|
if(res==0){
|
|
rMB.state = ST_BETTED;
|
|
|
|
int amo = chips[0] + chips[1] + chips[2];
|
|
g_aGames.betData.amounts[2] += amo; //手工流水
|
|
g_nRBReport += amo;
|
|
|
|
PostMessage(Application->MainFormHandle, UM_STATE_UPDATE, STATE_MAN, 1);
|
|
}
|
|
else
|
|
aManBets.erase(aManBets.begin()+i); //失败删除
|
|
|
|
if(hTable) PostMessage(hTable, UM_TAB_UPDATE, UPDATE_MANBET, res);
|
|
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
//未匹配到手工下注，再处理自动下注
|
|
if(iState==ST_BETTING){
|
|
iState = res==0 ? ST_BETTED : ST_FAILED;
|
|
if(hTable) PostMessage(hTable, UM_LOG_UPDATE, iState, res);
|
|
|
|
if(res==0){
|
|
g_aGames.nBetted[bReal]++; //增加下注个数
|
|
if(!bIndPolicy)
|
|
g_aGames.nBetted[2]++; //全局计算下注
|
|
|
|
TBetLog* pLog = NewBetLog();
|
|
pLog->ev = LOGEVT_BET;
|
|
pLog->op = iBet;
|
|
pLog->num = nChip;
|
|
SendMessage(Application->MainFormHandle, UM_LOG_UPDATE, 0, (long)pLog);
|
|
|
|
if(nChip>0){
|
|
g_aGames.betData.amounts[0] += nChip;
|
|
|
|
if(bReal){
|
|
g_aGames.betData.amounts[1] += nChip; //实打流水
|
|
g_nRBReport += nChip;
|
|
}
|
|
|
|
if(g_settings.bSimAccOn){
|
|
bool bUpdate = false;
|
|
if(!bReal || g_settings.bSyncReal){
|
|
g_settings.fSimAcc -= nChip;
|
|
bUpdate = true;
|
|
}
|
|
|
|
if(bReal && g_bTesting){
|
|
g_fBalance -= nChip;
|
|
bUpdate = true;
|
|
}
|
|
|
|
if(bUpdate)
|
|
PostMessage(Application->MainFormHandle, UM_STATE_UPDATE, STATE_BALANCE, 0);
|
|
}
|
|
|
|
PostMessage(Application->MainFormHandle, UM_STATE_UPDATE, STATE_AMOUNT, 0);
|
|
}
|
|
}
|
|
else{
|
|
if(g_bGameOn && g_aGames.bFloat && g_aGames.iFloatGame==iGame){ //游台取消下注标志，以免阻塞下注
|
|
g_aGames.SetSwitchable(true, 0); //非强制换台
|
|
PostMessage(Application->MainFormHandle, UM_FLOAT_BET, 0, 0);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
void __fastcall TGame::Shuffle()
|
|
{
|
|
ClearResults();
|
|
|
|
bBreak = false;
|
|
|
|
if(bReset)
|
|
ResetBet();
|
|
else{
|
|
if(g_settings.bInitBetByGame){ //新局重置打法
|
|
iBet = iBetSeq = 0;
|
|
aBets.clear();
|
|
}
|
|
if(g_settings.bInitChipByGame){ //新局重置注码
|
|
nChip = iChipSeq = 0;
|
|
}
|
|
|
|
iState = ST_INIT;
|
|
}
|
|
|
|
if(g_settings.bInitProfitByGame && profit!=0 //新局重置赢利
|
|
|| g_settings.bTableStopWin && profit>=g_settings.nTableStopWin //止赢重置
|
|
|| g_settings.bTableStopLos && profit<=-g_settings.nTableStopLos){ //止损重置
|
|
profit = 0;
|
|
PostMessage(hTable, UM_TAB_UPDATE, UPDATE_RESET, 0);
|
|
}
|
|
|
|
if(hTable){
|
|
PostMessage(hTable, UM_TAB_UPDATE, UPDATE_ROAD, 0);
|
|
PostMessage(hTable, UM_LOG_UPDATE, iState, 0);
|
|
}
|
|
|
|
if(g_bGameOn && g_aGames.bFloat && g_aGames.iFloatGame==iGame
|
|
&& ((g_settings.iFloatMode & 2) //洗牌换台
|
|
|| (g_settings.iFloatMode & 1) && aBets.empty())){ //连注完换台被重置
|
|
aBets.clear();
|
|
g_aGames.SetSwitchable(true, iGame);
|
|
PostMessage(Application->MainFormHandle, UM_FLOAT_BET, 0, 0);
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
int __fastcall TGame::ParseCard(int c)
|
|
{
|
|
if(!c) return -1;
|
|
|
|
int n = c & 15;
|
|
if( n>=10 ) n = 0;
|
|
return n;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
void __fastcall TGame::BuildRoadmap(char wt)
|
|
{
|
|
//大路
|
|
int size0 = aRoad[0].size();
|
|
if(wt!=3){
|
|
if(lastRoad[0]!=wt){ aRoad[0].push_back(1); size0++;}
|
|
else aRoad[0].back()++;
|
|
}
|
|
|
|
aMap[0].DrawMap(wt, lastRoad[0]);
|
|
|
|
if(wt!=3)
|
|
lastRoad[0] = wt;
|
|
else
|
|
return;
|
|
|
|
//下三路
|
|
int rc[5];
|
|
rc[0] = aRoad[0].back(); //最后1列个数
|
|
for(int i=1; i<5; i++)
|
|
rc[i] = size0>i ? aRoad[0][size0-i-1] : 0;
|
|
|
|
for(int i=1; i<4; i++){
|
|
if(!rc[i] || rc[0]==1 && !rc[i+1]) return;
|
|
|
|
char cl = rc[0]==1 ? (rc[1]==rc[i+1] ? 1 : 2) //齐脚跳画红、突脚跳画蓝
|
|
: (rc[0]<=rc[i] || rc[0]>=rc[i]+2 ? 1 : 2); //有对画红、无对画蓝、突脚连画红
|
|
if(lastRoad[i]!=cl) aRoad[i].push_back(1), size0++;
|
|
else aRoad[i].back()++;
|
|
aMap[i].DrawMap(cl, lastRoad[i]);
|
|
lastRoad[i] = cl;
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
TBetLog* __fastcall TGame::NewBetLog()
|
|
{
|
|
TBetLog* pLog = new TBetLog;
|
|
pLog->ts = DateTimeToUnix(Now(), false);
|
|
strcpy(pLog->tno, ((AnsiString)vid).c_str());
|
|
return pLog;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
void __fastcall TGame::ManualBetOn(int chips[])
|
|
{
|
|
TManBet mb;
|
|
memcpy(mb.chips, chips, sizeof(mb.chips));
|
|
aManBets.push_back(mb);
|
|
|
|
PostMessage(Application->MainFormHandle, UM_SETBET, iGame, 0);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
void __fastcall TGame::ManualBetOff()
|
|
{
|
|
for(int i=aManBets.size()-1; i>=0; i--){
|
|
TManBet& mb = aManBets[i];
|
|
if(mb.state!=ST_BETTED){
|
|
aManBets.erase(aManBets.begin()+i);
|
|
}
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
void __fastcall TGame::ResetIP()
|
|
{
|
|
if(bIndPolicy){
|
|
bIndPolicy = false;
|
|
nChipMul = iRoad = iBetPolicy = iChipPolicy = -1;
|
|
|
|
if(hTable)
|
|
PostMessage(hTable, UM_TAB_UPDATE, UPDATE_IP, 0);
|
|
|
|
// g_aIPGames.DelGame(this);
|
|
}
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//TRoadmap
|
|
TRoadmap::TRoadmap()
|
|
{
|
|
Clear();
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
void __fastcall TRoadmap::Clear()
|
|
{
|
|
for(int i=0; i<aCols.size(); i++)
|
|
delete aCols[i];
|
|
aCols.clear();
|
|
|
|
iRoot = iRow = iCol = -1;
|
|
bBend = false;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
void __fastcall TRoadmap::CheckColumn()
|
|
{
|
|
if(iCol==aCols.size()){
|
|
char* col = new char[6];
|
|
memset(col, 0, 6);
|
|
aCols.push_back(col);
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
void __fastcall TRoadmap::DrawMap(char curr, char last)
|
|
{
|
|
bool bCheck = false;
|
|
if(curr==3){
|
|
if(iRoot<0){
|
|
iRoot = iCol = iRow = 0;
|
|
curr = 0x04;
|
|
bCheck = true;
|
|
}
|
|
else
|
|
curr = aCols[iCol][iRow] + 0x04;
|
|
}
|
|
else if(!last && iRoot>=0){ //前面只有和
|
|
curr += aCols[iCol][iRow];
|
|
}
|
|
else if(curr!=last){ //新列
|
|
++iRoot;
|
|
if(iCol<iRoot)
|
|
bCheck = true;
|
|
|
|
iCol = iRoot;
|
|
iRow = 0;
|
|
bBend = false;
|
|
}
|
|
else{
|
|
if(bBend){ //继续横向绘制
|
|
++iCol;
|
|
bCheck = true;
|
|
}
|
|
else{
|
|
if(iRow==5 || aCols[iCol][iRow+1]){ //转为横向绘制
|
|
++iCol;
|
|
bBend = true;
|
|
bCheck = true;
|
|
}
|
|
else
|
|
++iRow;
|
|
}
|
|
}
|
|
|
|
if(bCheck)
|
|
CheckColumn();
|
|
|
|
aCols[iCol][iRow] = curr;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//TGameArray
|
|
TGameArray::TGameArray()
|
|
{
|
|
bFloat = iFloatGame = iChipSeq = runTime = 0;
|
|
fCurrProfitPeak = -1E20;
|
|
bSwitchable = true;
|
|
memset(seqCount, 0, sizeof(seqCount));
|
|
memset(nBetted, 0, sizeof(nBetted));
|
|
|
|
pRankChip = NULL;
|
|
pSema = new CSema("GameArray", 1);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
TGameArray::~TGameArray()
|
|
{
|
|
ClearAllGames();
|
|
ClearRankChip();
|
|
delete pSema;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
void __fastcall TGameArray::ClearAllGames()
|
|
{
|
|
if(!empty()){
|
|
int s = size();
|
|
for( int i=0; i<s; i++ ){
|
|
delete at(i);
|
|
}
|
|
clear();
|
|
}
|
|
|
|
memset(nBetted, 0, sizeof(nBetted));
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall TGameArray::ClearRankChip()
|
|
{
|
|
CMutexLock mutex(pSema);
|
|
|
|
if(pRankChip){
|
|
delete pRankChip;
|
|
pRankChip = NULL;
|
|
}
|
|
|
|
iChipSeq = 0;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
TRankChip* __fastcall TGameArray::GetRankChip(int type)
|
|
{
|
|
CMutexLock mutex(pSema);
|
|
|
|
if(pRankChip && !pRankChip->IsTypeOf(type)){
|
|
delete pRankChip;
|
|
pRankChip = NULL;
|
|
}
|
|
|
|
if(!pRankChip){
|
|
pRankChip = type==KIND_CHIP_HAN ? (TRankChip*)new TTierChip
|
|
: type==KIND_CHIP_LEV ? (TRankChip*)new TLevelChip(true)
|
|
: type==KIND_CHIP_WLD ? (TRankChip*)new TWLDiffChip(true)
|
|
: (TRankChip*)new TComboChip(true);
|
|
}
|
|
|
|
return pRankChip;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall TGameArray::Reset()
|
|
{
|
|
int s = size();
|
|
for( int i=0; i<s; i++ ){
|
|
at(i)->Reset();
|
|
}
|
|
|
|
betData.Reset();
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
void __fastcall TGameArray::GameOn()
|
|
{
|
|
if(g_settings.bInitCurProfitByStart)//重置当期赢利
|
|
fCurrProfitPeak = betData.profits[3] = betData.profits[6] = betData.profits[7] = 0;
|
|
else if(fCurrProfitPeak < betData.profits[3]) //重置当期赢利峰值
|
|
fCurrProfitPeak = betData.profits[3];
|
|
|
|
if(bFloat = g_settings.iFloatMode>0){
|
|
bSwitchable = true;
|
|
iChipSeq = iFloatGame = 0;
|
|
memset(seqCount, 0, sizeof(seqCount));
|
|
|
|
TChipPolicy* pCP = (TChipPolicy*)g_aChipPolicies[g_iChipPolicy];
|
|
if(pCP->kind>=KIND_CHIP_HAN && pCP->kind<=KIND_CHIP_WLD){
|
|
GetRankChip(pCP->kind)->SetPolicy(pCP);
|
|
|
|
if(g_settings.bInitBetChipByStart)
|
|
pRankChip->Reset();
|
|
}
|
|
}
|
|
else if(g_settings.bInitBetChipByStart){
|
|
ClearRankChip();
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
void __fastcall TGameArray::GameOff()
|
|
{
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
void __fastcall TGameArray::AllBetOff()
|
|
{
|
|
int s = size();
|
|
for( int i=0; i<s; i++ ){
|
|
TGame* pG = at(i);
|
|
if(pG->bRun && !pG->bIndPolicy)
|
|
pG->AutoBetOff();
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
void __fastcall TGameArray::ResetRankSeq()
|
|
{
|
|
int s = size();
|
|
for( int i=0; i<s; i++ ){
|
|
TGame* pG = at(i);
|
|
if(pG->bRun && !pG->bIndPolicy)
|
|
pG->iChipSeq &= 0xFFFFF000;
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
void __fastcall TGameArray::ResetRankChip()
|
|
{
|
|
iChipSeq = 0;
|
|
|
|
if(pRankChip){
|
|
pRankChip->Reset();
|
|
|
|
if(!bFloat)
|
|
ResetRankSeq();
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
void __fastcall TGameArray::ResetFloat()
|
|
{
|
|
bFloat = g_settings.iFloatMode>0;
|
|
iChipSeq = iFloatGame = 0;
|
|
bSwitchable = true;
|
|
memset(seqCount, 0, sizeof(seqCount));
|
|
|
|
if(pRankChip)
|
|
pRankChip->Reset();
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
void __fastcall TGameArray::SetSwitchable(bool bS, int iG)
|
|
{
|
|
CMutexLock mutex(pSema);
|
|
|
|
bSwitchable = bS;
|
|
iFloatGame = iG;
|
|
|
|
//检查是否仅一台在运行
|
|
if(bS && iG){
|
|
int nRun = 0;
|
|
for(int i=0; i<size(); i++){
|
|
if(!at(i)->bIndPolicy && at(i)->bRun){
|
|
nRun++;
|
|
if(nRun>=2)
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(nRun<2) //只有一台，则允许下注
|
|
iFloatGame = 0;
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
bool __fastcall TGameArray::CanFloatBet(int iG)
|
|
{
|
|
CMutexLock mutex(pSema);
|
|
|
|
return bSwitchable && iFloatGame!=iG //可换台非强制
|
|
|| !bSwitchable && iFloatGame==iG; //不可换台当前台
|
|
};
|
|
//---------------------------------------------------------------------------
|
|
|
|
void __fastcall TGameArray::Init(String sRooms)
|
|
{
|
|
ClearAllGames();
|
|
|
|
TStringDynArray arr = SplitString( sRooms, ";" );
|
|
|
|
for( int i=0; i<arr.Length; i++ ){
|
|
if(!arr[i].Length()) continue;
|
|
|
|
TStringDynArray subs = SplitString( arr[i], "," );
|
|
|
|
int iG = Vid2Gid(subs[0]);
|
|
if( iG>0 ){
|
|
TGame* pG = NULL;
|
|
int ind = FindGame(iG, pG );
|
|
if( !pG ){
|
|
pG = NewGame(iG, subs[g_iPlatform==PF_PA ? 0 : 1], ind);
|
|
|
|
pG->gmcode = subs[2];
|
|
pG->gmstatus = subs[3].ToInt(); //先设为结算，避免重复
|
|
if(pG->gmstatus==1)
|
|
pG->gmstatus = 2;
|
|
// else if(pG->gmstatus==2)
|
|
// pG->gmstatus = 0;
|
|
|
|
for(int i=1; i<=subs[4].Length(); i++){
|
|
int wt = subs[4][i]-'0';
|
|
if(wt==0) wt = 3;
|
|
pG->aRes.push_back(wt);
|
|
pG->winCount[wt-1]++;
|
|
pG->BuildRoadmap(wt);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
TGame* __fastcall TGameArray::NewGame(int iG, String vid, int ind)
|
|
{
|
|
CMutexLock mutex(pSema);
|
|
|
|
TGame* pGame = new TGame(iG);
|
|
pGame->vid = vid;
|
|
|
|
if(g_aIPGames.iPlatform!=g_iPlatform){
|
|
g_aIPGames.ClearAll();
|
|
}
|
|
else{
|
|
TIPGame* pIG = NULL;
|
|
g_aIPGames.FindGame(vid, pIG);
|
|
|
|
if(pIG){
|
|
pGame->bIndPolicy = true;
|
|
pGame->iBetPolicy = pIG->iBetPolicy;
|
|
pGame->iChipPolicy = pIG->iChipPolicy;
|
|
pGame->nChipMul = pIG->nChipMul;
|
|
pGame->iRoad = ((TBetPolicy*)g_aBetPolicies[pIG->iBetPolicy])->road;
|
|
pIG->pGame = pGame;
|
|
}
|
|
}
|
|
|
|
insert( begin()+ind, pGame );
|
|
|
|
return pGame;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
void __fastcall TGameArray::SetCountDown(String s)
|
|
{
|
|
TStringDynArray arr = SplitString( s, ";" );
|
|
|
|
for( int i=0; i<arr.Length; i++ ){
|
|
if(arr[i].IsEmpty()) continue;
|
|
|
|
TStringDynArray subs = SplitString( arr[i], "," );
|
|
|
|
int iG = subs[0].ToInt();
|
|
int cd = subs[1].ToInt();
|
|
if( iG>0 && cd>=0 ){
|
|
TGame* pG = NULL;
|
|
int ind = FindGame(iG, pG );
|
|
if(pG){
|
|
int st = subs[2].ToInt();
|
|
if(pG->countdown<st){
|
|
pG->countdown = st;
|
|
|
|
if(pG->gmstatus==1){
|
|
pG->timeout = cd ? cd + 2 : 0;
|
|
if(pG->hTable) PostMessage(pG->hTable, UM_TAB_UPDATE, UPDATE_TIME, 0);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
TGame* __fastcall TGameArray::GetGame(int iG)
|
|
{
|
|
TGame * pG = NULL;
|
|
|
|
FindGame( iG, pG );
|
|
|
|
return pG;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
int __fastcall TGameArray::FindGame(int iG, TGame*& pGame)
|
|
{
|
|
CMutexLock mutex(pSema);
|
|
|
|
int middle, front=0, rear=size()-1;
|
|
int index = -1;
|
|
|
|
while( front<=rear ){
|
|
if( at(front)->iGame == iG ){
|
|
index = front;
|
|
pGame = at(front);
|
|
break;
|
|
}
|
|
if( at(rear)->iGame == iG ){
|
|
index = rear;
|
|
pGame = at(rear);
|
|
break;
|
|
}
|
|
|
|
middle = (front+rear)/2;
|
|
if( at(middle)->iGame == iG ){
|
|
index = middle;
|
|
pGame = at(middle);
|
|
break;
|
|
}
|
|
else if( at(middle)->iGame < iG )
|
|
front=middle+1;
|
|
else
|
|
rear=middle-1;
|
|
}
|
|
|
|
if( front>rear )
|
|
index = front;
|
|
|
|
return index;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//TIPGameArray
|
|
TIPGameArray::~TIPGameArray()
|
|
{
|
|
ClearAll();
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
void __fastcall TIPGameArray::ClearAll()
|
|
{
|
|
if(!empty()){
|
|
int s = size();
|
|
for( int i=0; i<s; i++ ){
|
|
delete at(i);
|
|
}
|
|
clear();
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
int __fastcall TIPGameArray::FindGame(String vid, TIPGame*& pIG)
|
|
{
|
|
int middle, front=0, rear=size()-1;
|
|
int index = -1;
|
|
|
|
while( front<=rear ){
|
|
if( at(front)->vid == vid ){
|
|
index = front;
|
|
pIG = at(front);
|
|
break;
|
|
}
|
|
if( at(rear)->vid == vid ){
|
|
index = rear;
|
|
pIG = at(rear);
|
|
break;
|
|
}
|
|
|
|
middle = (front+rear)/2;
|
|
if( at(middle)->vid == vid ){
|
|
index = middle;
|
|
pIG = at(middle);
|
|
break;
|
|
}
|
|
else if( at(middle)->vid < vid )
|
|
front=middle+1;
|
|
else
|
|
rear=middle-1;
|
|
}
|
|
|
|
if( front>rear )
|
|
index = front;
|
|
|
|
return index;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
void __fastcall TIPGameArray::AddGame(TGame* pG)
|
|
{
|
|
if(iPlatform!=g_iPlatform)
|
|
iPlatform = g_iPlatform;
|
|
|
|
TIPGame* pIG = NULL;
|
|
int ind = FindGame(pG->vid, pIG);
|
|
if(!pIG){
|
|
insert(begin()+ind, new TIPGame(pG));
|
|
}
|
|
else{
|
|
pIG->iBetPolicy = pG->iBetPolicy;
|
|
pIG->iChipPolicy = pG->iChipPolicy;
|
|
pIG->nChipMul = pG->nChipMul;
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
void __fastcall TIPGameArray::DelGame(TGame* pG)
|
|
{
|
|
TIPGame* pIG = NULL;
|
|
int ind = FindGame(pG->vid, pIG);
|
|
if(pIG){
|
|
delete pIG;
|
|
erase(begin()+ind);
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
void __fastcall TIPGameArray::AddIPGame(String v, int b, int c, int m)
|
|
{
|
|
if(iPlatform!=g_iPlatform)
|
|
iPlatform = g_iPlatform;
|
|
|
|
TIPGame* pIG = NULL;
|
|
int ind = FindGame(v, pIG);
|
|
if(!pIG){
|
|
insert(begin()+ind, new TIPGame(v, b, c, m));
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|