หน้าแรก>การเขียนโปรแกรมที่เกี่ยวข้อง>ซอร์สโค้ดอื่น ๆ
ดาวน์โหลด

PokerOddsCalc

PokerOddsCalc เป็นเครื่องมือประเมินมือโป๊กเกอร์ง่ายๆ ที่สามารถจำลองรูปแบบโป๊กเกอร์ Texas Hold'em หรือ Omaha ได้ เครื่องคำนวณอัตราต่อรองโป๊กเกอร์ล้วนๆ ส่วนใหญ่ที่เขียนด้วยภาษา Python ในปัจจุบันใช้แฮชเทเบิลเพื่อจัดเก็บ ข้อมูลการ์ด เป็นบิตเพื่อเพิ่มประสิทธิภาพ หรือใช้การออกแบบ OOP ที่แข็งแกร่ง ซึ่งทำให้ประสิทธิภาพลดลง เป้าหมายการพัฒนา ของโครงการนี้คือเพื่อให้ได้ประสิทธิภาพการจำลองที่ค่อนข้างสูงโดยไม่ต้องใช้แฮชเทเบิล

ลองดู demo.ipynb เพื่อดูฟังก์ชันทั้งหมดที่เครื่องมือรองรับ หรือดำเนินการต่อด้านล่างเพื่อดูตัวอย่างสั้นๆ

สารบัญ

  • การติดตั้ง
  • ออกแบบ
  • ตัวอย่าง
  • ใบอนุญาต

การติดตั้ง

ตั้งค่า

ติดตั้งจาก GitHub 

$ pip install git+https://github.com/johnsoong216/PokerOddsCalc.git

ออกแบบ

เพื่อประมวลผลข้อมูลด้วยความเร็วที่รวดเร็ว ข้อมูลการ์ดทั้งหมดจะถูกแปลงเป็นอาร์เรย์ตัวเลขเพื่อปรับปรุงความเร็ว

อินพุตการ์ดจะอยู่ในรูปแบบของหมายเลข: 23456789TJQKA ตามด้วยชุด: dcsh

ในการจัดอันดับไพ่ เราใช้ระบบเลขฐานสิบหกเพื่อกำหนดความแข็งแกร่งให้กับไพ่จากไพ่ที่สำคัญที่สุดไปยังไพ่ที่มีค่าน้อยที่สุด มีมือโป๊กเกอร์ที่แตกต่างกัน 7,462 มือ ดังนั้นเราจึงสร้างอัลกอริธึมที่แปลงมือให้เป็นค่าจำนวนเต็ม

ประการแรก เราพิจารณาว่าการรวมไพ่ 5 ใบนั้นเหมาะสม/ตรงหรือไม่ ซึ่งสามารถระบุประเภทของมือหลาย ๆ มือได้อย่างรวดเร็ว

จากนั้นเราทำงานกับค่าตัวเลขของไพ่โดยที่ 2 ถึง A แทนด้วยจำนวนเต็มตั้งแต่ 2 ถึง 14

เราจัดเรียงการ์ดเพื่อระบุประเภทการ์ดอย่างรวดเร็ว

ก้าวแรก

  • Four of A Kind มีอยู่ในสองรูปแบบหลังจากเรียงลำดับแล้ว: AAAAB หรือ BAAAA
  • จากนั้นเราจะย้ายค่าในรูปของตัวเลขที่มีค่าที่สุด ดังนั้น AAAAB -> BAAAA
  • ในทำนองเดียวกันสำหรับ Three of a Kind มีสามรูปแบบ: AAABC, ABBBC, ABCCC และเราสามารถย้ายค่าได้

ขั้นตอนที่สอง

  • เราสามารถระบุประเภทไพ่ได้ทั้งหมดและเรากำหนดค่าจำนวนเต็มตั้งแต่ 1 - 8 ให้กับแต่ละประเภทไพ่ (1 คือไพ่สูงและ 8 คือสเตรทฟลัช)
  • ค่าจำนวนเต็มคำนวณเป็น D1 * 1 + D2 * 16 + D3 * 16^2 + D4 * 16^3 + D5 * 16^4 + TYPE * 16^5 โดยที่ Di คือค่าตัวเลขที่มีนัยสำคัญน้อยที่สุดลำดับที่ 8 ของมือ เนื่องจากค่าสูงสุดของหลักใดๆ คือ 14 เราจึงทราบดีว่าการใช้ระบบเลขฐานสิบหกสามารถหลีกเลี่ยงการรวมกลุ่มและกำหนดค่าเฉพาะให้กับแต่ละมือได้สำเร็จ

ขั้นตอนที่สาม

  • การกำหนดค่าให้กับมือช่วยให้สามารถเปรียบเทียบความแข็งแกร่งของมือได้อย่างรวดเร็ว ซึ่งทำให้การจำลองมีประสิทธิภาพมากขึ้น

บทสรุป

  • การนำการออกแบบนี้ไปใช้ เราสามารถบรรลุความเร็วการจำลอง 5M ต่อวินาทีสำหรับ Hold'em และ 1.5M/s สำหรับ Omaha
  • แม้ว่านี่จะไม่เร็วเท่ากับวิธีการระดับบิต/วิธีแฮชเทเบิลบางวิธี ซึ่งสามารถบรรลุความเร็วเหนือ 10M/s ได้ แต่เป็นการปรับปรุงที่ดีกว่าการออกแบบ OOP บางอย่างซึ่งไม่สามารถใช้งานได้เมื่อไม่ได้วาดฟล็อป

ตัวอย่าง

นำเข้าเกม 

 from PokerOddsCalc import HoldemTable , OmahaTable

สร้างเกม ระบุจำนวนผู้เล่นและประเภทสำรับ (สำรับเต็ม หรือสำรับสั้น) 

 ht = HoldemTable ( num_players = 5 , deck_type = 'full' ) # Will Create Three Players: Player 1 - 5

สุ่มแจกไพ่โดยการเรียกฟังก์ชัน next_round() ทุกขั้นตอนในเกม หรือมอบหมายด้วยตนเอง 

 ht . add_to_hand ( 1 , [ 'Td, ' Ad ']) # Assign Player 1
ht . next_round () # Assign all other players randomly

จำลองเพื่อสร้างผลลัพธ์ ระบุจำนวนสถานการณ์และประเภทการคำนวณอัตราต่อรอง (สำหรับรายละเอียดเพิ่มเติม โปรดตรวจสอบ demo.ipynb ) 

 ht . simulate ()
#
{ 'Player 1 Win' : 50.31 ,
 'Player 1 Tie' : 3.84 ,
 'Player 2 Win' : 12.09 ,
 'Player 2 Tie' : 0.41 ,
 'Player 3 Win' : 11.4 ,
 'Player 3 Tie' : 3.84 ,
 'Player 4 Win' : 11.05 ,
 'Player 4 Tie' : 0.41 ,
 'Player 5 Win' : 11.31 ,
 'Player 5 Tie' : 0.41 }

ดูตารางปัจจุบัน มือปัจจุบัน หรือผลการแข่งขันปัจจุบัน (หากเกมจบลง) 

 ht . view_table ()
ht . view_hand ()
ht . view_result ()

ใบอนุญาต

  • ใบอนุญาตเอ็มไอที
  • ลิขสิทธิ์ 2020 ©
ขยาย
ข้อมูลเพิ่มเติม
แอปที่เกี่ยวข้อง
แนะนำสำหรับคุณ
ข้อมูลที่เกี่ยวข้อง ทั้งหมด