एक पोकर बॉट लेखन

ध्यान दें कि सामग्री विशुद्ध रूप से सूचना के प्रयोजनों के लिए है, और लेखक पोकर कमरे द्वारा खातों को बंद करने के लिए जिम्मेदार नहीं है। देशों के कानूनों के तहत, बॉट्स का निर्माण और उपयोग निषिद्ध नहीं है, लेकिन पोकर कमरे के नियमों के अनुसार उन्हें निषिद्ध है।

इस लेख में पूर्ण स्रोत कोड नहीं होंगे, केवल सैद्धांतिक रूप से क्या और कैसे उपयोग किया जा सकता है, और कुछ कार्य। यदि आप इस में रुचि रखते हैं, तो आप एक तस्वीर में सब कुछ इकट्ठा नहीं कर पाएंगे और अपना खुद का लिख ​​सकते हैं। मैं गेम रणनीतियों, शब्दों या रणनीतियों के साथ-साथ नियमों के बारे में भी नहीं सिखाऊंगा, आप इंटरनेट पर बहुत सारी जानकारी पा सकते हैं।

थोड़ा इतिहास।

उन्होंने लगभग 5 साल पहले खेलना शुरू किया था, उस दौरान 1 मिलियन से अधिक हाथ जीते गए थे। यह मुख्य रूप से छोटी मेजों पर कोई सीमा होल्डम (असीमित होल्डम) है (टेबल पर 2 से 6 लोगों से), ओमाहा, एचयू एनएल होल्डम में खेलने का अनुभव है। खेल एक शौक और विश्राम की तरह है। और फिर, मेरे दोस्तों के साथ, एक बॉट लिखने के लिए विचार आया, पहला विचार एक सीमा होल्डम के साथ लिखना था, और जब बॉट आधा लिखा गया था, तो उन्होंने अमेरिकियों को पोकर खेलने से रोकते हुए एक कानून पारित किया, और परिणामस्वरूप उन्होंने बॉट को एक सीमा के साथ गिरा दिया। पहला संस्करण पैटर्न मान्यता के साथ एक तंत्रिका नेटवर्क पर लिखा गया था, जिसका अर्थ है कि उन्होंने बॉट को मानचित्र स्क्रीन शॉट्स से पहचानने के लिए सिखाया है, लेकिन आप खुद को गलत तरीके से समझते हैं, लेकिन काफी अच्छे प्रशिक्षण के साथ इसे 98-99% सटीकता के साथ मान्यता दी है। बाद में, बॉट संस्करण पहले ही काम कर चुके हैं। अपने संसाधनों का उपयोग करते हुए, कमरों की खिड़कियों के साथ प्रत्यक्ष।, खेल के आंकड़ों के विश्लेषण और संग्रह के लिए कार्यक्रमों के साथ मिलकर।

पोकर कमरे में नहीं सोते हैं।

लगभग सभी पोकर कमरों में किसी न किसी तरह की सुरक्षा और पोकर बॉट डिटेक्शन सिस्टम होता है। उनमें से कुछ पर विचार करें। एक लंबा खेल - जब कोई व्यक्ति बहुत अधिक समय तक खेलता है, तो यह संदिग्ध हो जाता है, इसलिए कुछ कमरों में सवालों के साथ खिड़कियां दिखाई दे सकती हैं। के रूप में संरक्षण लंबे खेल सत्र नहीं करते हैं। तालिका में क्रियाएँ - बटन दबाते हुए, खिड़कियों का चयन करते हुए, एक न्यूनतम विंडो में, माउस को स्थानांतरित किए बिना क्रियाएं नहीं होनी चाहिए। माउस रास्तों को थोड़ा नॉनलाइन तरीके से सेट करना बेहतर होता है, बटन के विभिन्न स्थानों पर क्लिक करने से गति की गति भी तात्कालिक होती है। चल रही प्रक्रियाओं और स्क्रीनशॉट के स्कैन - ऊपर बताए अनुसार सुरक्षा, कम से कम खिड़कियों में न खेलें, बॉट प्रक्रिया को पोकर बॉट न कहें, और इसी तरह, स्क्रीन पर अधिकतम बॉट विंडो को न छोड़ें, कुछ समय के बाद प्रक्रिया का नाम बदलें (उदाहरण के लिए, x मिनट के बाद। नई प्रक्रिया नाम के साथ बॉट को पुनरारंभ करें)।

पोकर बॉट योजना।

योजना को 3 भागों में विभाजित किया जा सकता है:

ब्लॉक 1 - पोकर खेलने के लिए क्लाइंट के साथ बातचीत का एक ब्लॉक।
ब्लॉक 2 - निर्णय ब्लॉक।
ब्लॉक 3 एक सांख्यिकी संग्रह ब्लॉक है, मेरी राय में, तीसरे पक्ष के सॉफ़्टवेयर का उपयोग करना बेहतर है, उदाहरण के लिए PokerTracker3, स्क्रीन पर आंकड़े अक्षम करते समय।
अगला, हम प्रत्येक ब्लॉक पर अधिक विस्तार से विचार करते हैं।

ब्लॉक 1 - पोकर खेलने के लिए क्लाइंट के साथ बातचीत का एक ब्लॉक।

इस ब्लॉक का उपयोग गेमिंग टेबल पर जानकारी एकत्र करने और निर्णय ब्लॉक में स्थानांतरित करने के लिए किया जाता है, साथ ही साथ फोल्ड, राइज़, कॉल या ऑल-इन जैसी कार्रवाई करने के निर्णय के साथ प्रतिक्रिया प्राप्त करता है। अब इस ब्लॉक पर विचार करें। इस भाग का हिस्सा कार्यक्रम की मुख्य विंडो के साथ बातचीत है, ये ऐसी क्रियाएं हैं जैसे कि एक सीमा चुनना, एक तालिका चुनना जिसके लिए हम खेलेंगे, यह भी एक बड़ा हिस्सा है, लेकिन हम वहां नहीं रुकेंगे। आइए हम पहले से ही तालिका के साथ और अधिक विस्तार से विचार करें। पहले हमें सभी खुली गेमिंग टेबल (विंडोज़) के हैंडल खोजने की जरूरत है, हम एनुमवॉड फ़ंक्शन का उपयोग करके ऐसा कर सकते हैं।
EnumWindows फ़ंक्शन स्क्रीन पर सभी शीर्ष-स्तरीय विंडो सूचीबद्ध करता है, प्रत्येक विंडो के हैंडल को पास करता है, बदले में, प्रोग्राम द्वारा परिभाषित कॉलबैक फ़ंक्शन के लिए। EnumWindows सक्रिय है जब तक कि अंतिम शीर्ष-स्तरीय विंडो सूचीबद्ध नहीं होती है, या जब तक कॉलबैक फ़ंक्शन FALSE नहीं लौटता है।

वाक्य रचना:

BOOL EnumWindows ( WNDENUMPROC lpEnumFunc, //      LPARAM lParam //    ); 

विकल्प:
lpEnumFunc - प्रोग्राम द्वारा परिभाषित कॉलबैक फ़ंक्शन को इंगित करता है। अधिक जानकारी के लिए, EnumWindowsProc कॉलबैक फ़ंक्शन देखें।
lParam - कॉलबैक फ़ंक्शन को पारित करने के लिए 32-बिट प्रोग्राम-निर्धारित मान सेट करता है।
रिटर्न मान: यदि फ़ंक्शन सफल होता है, तो एक गैर-शून्य मान लौटाया जाता है। यदि फ़ंक्शन विफल हो गया है, तो वापसी मान शून्य है।

यदि फ़ंक्शन सफलतापूर्वक काम करता है, तो हम विंडो का नाम GetWindowText प्राप्त कर सकते हैं, और यह समझने के लिए विश्लेषण करने के बाद कि विंडो आवश्यक है या नहीं, आमतौर पर आपका उपनाम, पोकर रूम का नाम और सीमा विंडो शीर्षक में मौजूद हैं। इसके अलावा, यह सभी पाए गए खिड़कियों के हैंडल को बचाने के लिए चोट नहीं पहुंचाएगा, आगे के उपयोग के लिए, फिर से खोज के बिना, खोज केवल तभी करनी होगी जब कोई नई विंडो खुलती है।

अब जब हमारे पास गेम विंडो के लिए एक हैंडल है, तो हम टेबल की जानकारी निकाल सकते हैं। अधिकांश जानकारी डीलरशिप विंडो में संग्रहीत होती है। इसमें से हम टेबल पर सभी प्रतिभागियों का पता लगा सकते हैं, जो अंदर आए, जिन्होंने टेबल छोड़ दिया, किसने क्या किया, टेबल पर कार्ड और उनके कार्ड। इसके लिए हमें एक पाठ पार्सर की आवश्यकता है, मैंने यह नहीं बताया कि इसे कैसे लिखा जाए, यह एक अलग विषय है, मुख्य बात यह है कि यह विचार स्पष्ट है। लेकिन पहले पार्सर से पहले हमें खिड़की के तत्वों को ढूंढना होगा, और उनमें से डीलरशिप विंडो ढूंढनी होगी। बहुत बार, डीलरशिप विंडो Internet Explorer_Server से प्राप्त एक वर्ग है, इसे खोजने के लिए हम EnumChildWindows फ़ंक्शन और फिर GetClassName का उपयोग करते हैं।

EnumChildWindows प्रोग्राम द्वारा परिभाषित कॉलबैक फ़ंक्शन के लिए प्रत्येक चाइल्ड विंडो के हैंडल को पास करने के बदले, उन चाइल्ड विंडो को सूचीबद्ध करता है जो एक विशेष पैरेंट विंडो से संबंधित हैं। EnumChildWindows फ़ंक्शन तब तक काम करता है जब तक कि अंतिम चाइल्ड विंडो सूचीबद्ध नहीं होती है या कॉलबैक फ़ंक्शन FALSE देता है।

वाक्य-विन्यास

 BOOL EnumChildWindows ( HWND hWndParent, //    WNDENUMPROC lpEnumFunc, //      LPARAM lParam // ,   ); 

विकल्प:
hWndParent - उस पैरेंट विंडो की पहचान करता है, जिसकी चाइल्ड विंडो एनुमरेटेड होनी चाहिए।
lpEnumFunc - प्रोग्राम द्वारा परिभाषित कॉलबैक फ़ंक्शन को इंगित करता है। कॉलबैक फ़ंक्शन के बारे में अधिक जानकारी के लिए, EnumChildProc कॉलबैक फ़ंक्शन देखें।
lParam - कॉलबैक फ़ंक्शन को पारित करने के लिए 32-बिट प्रोग्राम-निर्धारित मान सेट करता है।
रिटर्न मान: यदि फ़ंक्शन सफल होता है, तो एक गैर-शून्य मान लौटाया जाता है। यदि फ़ंक्शन विफल हो गया है, तो वापसी मान शून्य है।

अब आप टेक्स्ट को पार्स करना शुरू कर सकते हैं। हमारी प्रगति का विश्लेषण किया जा सकता है या नहीं, इस आधार पर बटन हमारे लिए उपलब्ध हैं। यह संसाधनों के माध्यम से और बस इस विंडो में स्क्रीन पर बिंदुओं द्वारा किया जा सकता है। इसके अलावा, यदि हमारा कदम है, तो हम ज्ञात डेटा को निर्णय ब्लॉक में स्थानांतरित करते हैं। प्रतिक्रिया मिलने पर, हम उचित कार्रवाई करते हैं। इस भाग में, यह अभी तक बटन दबाने के तरीके पर विचार नहीं किया गया है, लेकिन मुझे लगता है कि यह स्वयं और मास्टर है।

ब्लॉक 2 - निर्णय ब्लॉक

इस ब्लॉक, पूरे बॉट का दिल, क्योंकि वह खेल में कितना सफल है यह उस पर निर्भर करता है, वह कितना सही निर्णय लेता है। जर्नल हैकर 137 दिनांक 06.2010 में, एक उदाहरण पर विचार किया गया था जो पूरी तरह से संभाव्यता सिद्धांत पर आधारित है और यह अच्छा है, लेकिन पर्याप्त रूप से विश्वसनीय परिणाम प्राप्त करने के लिए, बहुत सारे पुनरावृत्तियों का संचालन करना आवश्यक है। प्रतिद्वंद्वी के खिलाफ आत्मविश्वास से खेलने के लिए, हमें उसकी सीमा को जानने की जरूरत है और वह कैसे खेलता है (यह टुकड़ा आंकड़ों से बंधा हुआ है), कुछ निश्चित गेम रणनीतियाँ भी हैं जो आपके पास पैसे की मात्रा पर निर्भर करती हैं, टेबल पर खिलाड़ियों की संख्या और गेम के खेल पर ही। हाथों की शुरुआती सीमा इस सब पर निर्भर करती है, और बाद की सड़कों पर कार्रवाई, उदाहरण के लिए, शॉर्ट स्टैक रणनीति (एसएसएस) पर खेलने वाला व्यक्ति शायद ही कभी नदी पर कोई कदम उठाता है (जब मेज पर 5 कार्ड बिछाए जाते हैं), क्योंकि इस समय तक वह अक्सर एलिन (ऑल-इन) में पहले से ही था। स्थितियों का मूल्यांकन भी बाहरी की गणना में जाता है, बाहरी कार्ड की संख्या है जो बाद की सड़कों पर हमारी स्थिति में सुधार करेगी, जिसमें से संयोजन जैसे कि सीधे ड्रॉ, स्ट्रेट ड्रॉ, स्ट्रेट ड्रॉ आदि। ड्रॉ भी एक संयोजन है और बाहरी की संख्या के आधार पर इसकी कीमत होती है। और एक निश्चित संयोजन होने पर भी, इस समय कोई जीत नहीं है, हम पहले से ही खेल की एक पंक्ति बना रहे हैं। इन अतिरिक्त डेटा के लिए धन्यवाद, हम पहले से ही चुनी गई रणनीति के आधार पर निर्णय ले सकते हैं, अगर हम खिलाड़ी के आंकड़ों में सबसे ऊपर जोड़ते हैं तो वे और भी सटीक होंगे, और यदि आप एक पूर्ण मिसकॉल जोड़ते हैं, तो यह नमूना अभी भी पूरक हो सकता है। मुझे आशा है कि मैंने नमूनों को कम करने और निर्णय लेने के बारे में अपना विचार व्यक्त किया, यह सब खेल और निर्णय लेने के व्यक्तिगत अनुभव पर आधारित है, क्योंकि कुछ वाक्यों में, आप पोकर गेम के सिद्धांत को नहीं बता सकते हैं, जो कई संस्करणों में प्रकाशित होता है, विभिन्न स्थितियों के बारे में, जो अनगिनत है, हालांकि इसे प्रमुख समूहों द्वारा अलग किया जा सकता है ...

पहले हमें मेज पर स्थिति का पता लगाने की जरूरत है, और पता करें कि हमारे पास क्या संयोजन है। यहाँ संयोजन परिभाषा कोड का एक उदाहरण है (अधिक स्पष्ट रूप से लिखा गया है, लेकिन यह इष्टतम नहीं हो सकता है):

 //     ,     int CardToNumber(char Card) { if ((Card>'1')&&(Card<='9'))return (Card-48); if (Card=='T')return 10; if (Card=='J')return 11; if (Card=='Q')return 12; if (Card=='K')return 13; if (Card=='A')return 14; return -1; } //    ,    int MastToNumber(char mast) { if (mast=='h')return 1; if (mast=='d')return 2; if (mast=='c')return 4; if (mast=='s')return 8; return 0; } //    int Hand(char *MyHand_,char *CardsTable_) { int flush_,flush; //0- 1- 2-  3- 4-  (nothing cards) int cards[15][4]; //i- j1--  j2- bits 1,2,3,4-h,d,c,s j3-0/1 - 1-  0- ( ) int straight; //0-, 1-, 2- (2- ) 3- 4-    5-   int readyhand; //0-  , 1-  int i,j, maxi,flag_,flag,flmax,top,pair_,pair,three,four,over,set_,treeps,quad,num,kicker; //         for(i=1;i<=14;i++) for(j=1;j<=3;j++)cards[i][j]=0; cards[CardToNumber(MyHand_[0])][1]++; cards[CardToNumber(MyHand_[0])][2]=cards[CardToNumber(MyHand_[0])][2]| 2*MastToNumber(MyHand_[1])); cards[CardToNumber(MyHand_[0])][2]=cards[CardToNumber(MyHand_[0])][2]|(32*MastToNumber(MyHand_[1])); cards[CardToNumber(MyHand_[0])][3]=1; cards[CardToNumber(MyHand_[3])][1]++; cards[CardToNumber(MyHand_[3])][2]=cards[CardToNumber(MyHand_[3])][2]|(2*MastToNumber(MyHand_[4])); cards[CardToNumber(MyHand_[3])][2]=cards[CardToNumber(MyHand_[3])][2]|(32*MastToNumber(MyHand_[4])); cards[CardToNumber(MyHand_[3])][3]=cards[CardToNumber(MyHand_[3])][3]+1; i=0; while(i<strlen(CardsTable_)) { cards[CardToNumber(CardsTable_[i])][1]++; cards[CardToNumber(CardsTable_[i])][2]=cards[CardToNumber(CardsTable_[i])][2]|(2*MastToNumber(CardsTable_[i+1])); i=i+3; } //  ,      num=0; i=1; maxi=0; flag=0; flmax=0; while(i<15) { if((cards[i][1]>0)&&(i>1)) { num++; if (cards[i][3]==1)flag=i; } else { if (maxi<num) { maxi=num; flmax=flag; } num=0; flag=0; } if(i==1){ if (cards[14][1]>0) { num++; if (cards[i][3]==1)flag=i; } else { if (maxi<num) { maxi=num; flmax=flag; } num=0; flag=0; } } i++; } if(maxi<num){maxi=num;flmax=flag;} num=0; i=0; flag=0; if(flmax>=maxi) { while(i<maxi) { if((cards[flmax-i][3]>0)&&(flmax-i!=1))flag++; if((cards[14][3]>0)&&((flmax-i)==1))flag++; i++; } } straight=0; if((maxi>=5)&&(flmax==14)&&(flag==0)) straight=4; if((maxi>=5)&&(flmax<14)&&(flag==0)) straight=5; if((maxi>=5)&&(flag>0)) straight=1; if((maxi==4)&&(flag>0)&&(flmax<14)) straight=2; if((maxi==4)&&(flag>0)&&(flmax==14)) straight=3; if((maxi==4)&&(flag>0)&&(flmax==4)) straight=3; //   flush_=0; j=2; while(j<=16) { flush=0; flag=0; i=2; num=0; flmax=0; flag_=0; while(i<15){ if ((cards[i][2]& j)==j) { flmax=i;num++;} if ((cards[i][2]& (j*16))==j*16) { flag_++;flag=i;} i++; } if((num==5)&&(flag==0)) flush=4; if((num>=5)&&(flmax==14)&&(flag>=13)) flush=1; if((num>=5)&&(flmax==14)&&((cards[13][2]& j)==j)&&(flag==12)) flush=1; if((num>=5)&&(flmax==14)&&((cards[13][2]& j)==j)&&((cards[12][2]& j)==j)&&(flag==11)) flush=1; if((num>=5)&&(flmax==14)&&((cards[13][2]& j)==j)&&((cards[12][2]& j)==j)&&((cards[11][2]& j)==j)&&(flag==10)) flush=1; if((num>=5)&&(flmax==14)&&((cards[13][2]& j)==j)&&((cards[12][2]& j)==j)&&((cards[11][2]& j)==j)&&((cards[10][2]& j)==j)) flush=1; if((num==5)&&(flag_==2)) flush=1; if((num==4)&&(flag>0)) flush=2; if((num==3)&&(flag==2)) flush=3; if((flush>flush_)&&(flush!=0))flush_=flush; j*=2; } flush=flush_; //  ,  , , , ,  pair=0;three=0;four=0; top=0;over=0;set_=0;treeps=0;quad=0;pair_=0; i=2; while(i<15) { if ((cards[i][1]>=1)&&(cards[i][3]==0)){ top=0;over=0;} if ((cards[i][1]==1)&&(cards[i][3]==0)){ top=0;over=0;} if ((cards[i][1]==2)&&(cards[i][3]==0)){ pair++;} if ((cards[i][1]==2)&&(cards[i][3]==1)){ pair_++;pair++;top=1;} if ((cards[i][1]==2)&&(cards[i][3]==2)){ pair_++;pair++;over=1;} if (cards[i][1]==3){ three++;} if (cards[i][1]==4){ four++;} if ((cards[i][1]==3)&&(cards[i][3]==1)) treeps=1; if ((cards[i][1]==3)&&(cards[i][3]==2)) set_=1; if ((cards[i][1]==4)&&(cards[i][3]>0)) quad=1; if ((cards[i][1]==4)&&(cards[14][3]>0)) quad=1; i++; } kicker=0; if (top>0) for(i=2;i<=14;i++){ if ((cards[i][1]==1)&&(cards[i][3]==1)) kicker=i; } // ':   '- straight // ':   '- flush // '- : '- pair // '-   : '- pair_ // ' : '- top // '' - kicker // ' : '- over // '3 : '- three // ':(2    1  ) '- treeps // ': (2   1  )'- Set_ // '4 : '- four // ': '- quad ……… } 

नतीजतन, प्रासंगिक चर में हमारे पास मौजूदा मामलों की स्थिति के आंकड़े हैं। इसके अलावा, इस बात पर ध्यान दें कि पूरा घर मौजूद नहीं है, यह भाप और थ्रिप्स या सेट का व्युत्पन्न है। यहां हमें अभी भी एक टुकड़ा चाहिए जो हाथ की तत्परता को निर्धारित करता है, अर्थात। तैयार, तैयार नहीं, आधा-समाप्त। उदाहरण के लिए, यह कोड:

...

// हाथ की तत्परता

  readyhand=0; if ((pair==1)&&((top==1)||(over==1))) readyhand=1; if ((pair==1)&&(top==1)&&(kicker<11)&&(over==0)) readyhand=0; if ((pair>=2)&&((top==1)||(over==1))) readyhand=1; if ((pair==2)&&(top==1)&&(kicker<11)&&(over==0)) readyhand=0; if ((pair==2)&&((top==0)||(over==0))&&(pair_==2)) readyhand=1; if ((pair>2)&&((top==0)||(over==0))) readyhand=0; if ((three==1)&&(top==0)&&(over==0)&&(pair_==0)) readyhand=0; if (treeps==1) readyhand=1; if (set_==1) readyhand=1; if (straight==5) readyhand=0; if (straight==4) readyhand=1; if ((straight==2)&&(readyhand==0)) readyhand=2; if (straight==1) readyhand=1; if (flush==4) readyhand=0; if ((flush==2)&&(readyhand==0)) readyhand=2; if (flush==1) readyhand=1; if ((three==1)&&((top==1)||(over==1))) readyhand=1; if ((three==1)&&(top==0)&&(over==0)&&(pair_>0)) readyhand=1; if ((three==1)&&(top==0)&&(over==0)&&(pair_==0)&&(pair>0)) readyhand=0; //   if ((treeps==1)&&(pair>0)) readyhand=1; if ((set_==1)&&(pair>0)) readyhand=1; if (quad==1) readyhand=1; 

...

इन आंकड़ों के आधार पर, हम उस हिस्से पर जाते हैं जो विरोधियों के बारे में आंकड़े प्राप्त करता है, बैंक के अवसरों और अन्य आवश्यक चीजों के बारे में गणना करता है, कार्रवाई के बारे में निर्णय लेता है और कार्रवाई को पूरा करने के लिए पहले ब्लॉक पर जाता है।

ब्लॉक 3 - सांख्यिकी संग्रह ब्लॉक

यह एक महत्वपूर्ण ब्लॉक है जो निर्णय लेने में मदद करता है, आप स्वयं आंकड़े एकत्र कर सकते हैं, तीसरे पक्ष के कार्यक्रमों का उपयोग कैसे करें। मैं पोकरट्रैक 3 के लिए एक अनुरोध के उदाहरण का वर्णन करूंगा, जो खेल के आंकड़ों को इकट्ठा करने और उनका विश्लेषण करने के लिए एक कार्यक्रम है, कार्यक्रम में 100 से अधिक पैरामीटर हैं, लेकिन कम से कम एक उदाहरण हमारे लिए पर्याप्त होगा। PokerTracker3 में, डेटाबेस को डाक डेटाबेस में संग्रहीत किया जाता है। अनुरोध उदाहरण:

 SELECT sites.site_abbrev, p.player_name, COUNT(hhps.id_player) AS hands, AVG (CASE WHEN flg_vpip THEN 1 ELSE 0 END)*100 AS vpip, AVG (CASE WHEN cnt_p_raise >= 1 THEN 1 ELSE 0 END)*100 AS pfr, AVG (CASE WHEN flg_steal_att THEN 1 WHEN flg_steal_opp THEN 0 END)*100 AS ats, AVG (CASE WHEN flg_sb_steal_fold THEN 1 WHEN flg_blind_def_opp and flg_blind_s THEN 0 END)*100 AS fsbtos, AVG (CASE WHEN flg_bb_steal_fold THEN 1 WHEN flg_blind_def_opp and flg_blind_b THEN 0 END)*100 AS fbbtos, AVG (CASE WHEN enum_f_cbet_action='F' THEN 1 WHEN flg_f_cbet_def_opp THEN 0 END)*100 AS fcbetf FROM lookup_sites AS sites INNER JOIN ( player AS p INNER JOIN holdem_hand_player_statistics AS hhps ON (p.player_name = ' ')and(p.id_player = hhps.id_player) ) ON p.id_site = sites.id_site GROUP BY sites.site_abbrev,p.player_name ORDER BY sites.site_abbrev DESC; 

आउटपुट पर, हम एक विशिष्ट खिलाड़ी के लिए चयन प्राप्त करते हैं, जिन साइटों पर इस तरह का उपनाम डेटाबेस में होता है, उन्हें केवल हमारी साइट पर कम किया जा सकता है, प्रतिद्वंद्वी के हाथों की संख्या (सटीक रीडिंग के लिए आवश्यक), वीपीआईपी (गेम में प्रवेश करने वाले हाथों का%), पीएफआर (प्रीफ्लॉप बढ़ा -) Preflop उठाना), ATS (प्रयास स्टील - कितने अंधा preflop चोरी करता है), CBET (फ्लॉप पर सी-बेट - flop पर निरंतरता), BBS (बिग ब्लाइंड स्टील - बिग ब्लाइंड चुराना), SBS (छोटा अंधा स्टील) - छोटा अंधा चोरी करना अंधा)। इन मापदंडों को मुख्य रूप से विस्तारित लघु स्टैक रणनीति में उपयोग किया जाता है, पूर्ण स्टैक के लिए, ये पैरामीटर कुछ कम हैं, लेकिन एक उदाहरण के रूप में, उन्हें कैसे प्राप्त करना पर्याप्त है। इन सभी मापदंडों की आवश्यकता क्यों है और उनका उपयोग कैसे करें मैं आपको उपयुक्त संसाधनों को पढ़ने की सलाह देता हूं।

अतिरिक्त आंकड़े प्राप्त करने के बाद, हम दूसरे ब्लॉक में जाते हैं और खेल के बारे में अपना निर्णय समायोजित करते हैं।

निष्कर्ष में।

इस लेख को लिखने के लिए, हमने हैकर 137 पत्रिका दिनांक 06/06/2010 से लेखों को आगे बढ़ाया "हम नेटवर्क पोकर कमरे खींच रहे हैं" और हैकर 139 दिनांक 08/10/2010 "पोकर पोकर काम करना"। चूंकि मैं लेखक से पूरी तरह सहमत नहीं हूं और मुझे लगता है कि विषय का पूरी तरह से खुलासा नहीं किया गया है और मैं अपनी राय साझा करना चाहता था।

यहाँ कुछ स्क्रीनशॉट हैं जो आपको मिल सकते हैं: