You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
390 lines
15 KiB
390 lines
15 KiB
#!/usr/bin/env python |
|
# -*- coding: utf-8 -*- |
|
|
|
#Copyright 2010-2011 Maxime Grandchamp |
|
#This program is free software: you can redistribute it and/or modify |
|
#it under the terms of the GNU Affero General Public License as published by |
|
#the Free Software Foundation, version 3 of the License. |
|
# |
|
#This program is distributed in the hope that it will be useful, |
|
#but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
#GNU General Public License for more details. |
|
# |
|
#You should have received a copy of the GNU Affero General Public License |
|
#along with this program. If not, see <http://www.gnu.org/licenses/>. |
|
#In the "official" distribution you can find the license in agpl-3.0.txt. |
|
|
|
import L10n |
|
_ = L10n.get_translation() |
|
|
|
|
|
from Hand import * |
|
import Configuration |
|
import Database |
|
import SQL |
|
import fpdb_import |
|
import Filters |
|
import pygtk |
|
pygtk.require('2.0') |
|
import gtk |
|
import math |
|
import gobject |
|
|
|
import pprint |
|
pp = pprint.PrettyPrinter(indent=4) |
|
|
|
|
|
class GuiReplayer: |
|
def __init__(self, config, querylist, mainwin, options = None, debug=True): |
|
self.debug = debug |
|
self.conf = config |
|
self.main_window = mainwin |
|
self.sql = querylist |
|
|
|
# These are temporary variables until it becomes possible |
|
# to select() a Hand object from the database |
|
self.filename="regression-test-files/cash/Stars/Flop/NLHE-FR-USD-0.01-0.02-201005.microgrind.txt" |
|
self.site="PokerStars" |
|
|
|
if options.filename != None: |
|
self.filename = options.filename |
|
if options.sitename != None: |
|
self.site = options.sitename |
|
|
|
self.db = Database.Database(self.conf, sql=self.sql) |
|
|
|
filters_display = { "Heroes" : True, |
|
"Sites" : False, |
|
"Games" : False, |
|
"Limits" : False, |
|
"LimitSep" : False, |
|
"LimitType" : False, |
|
"Type" : False, |
|
"Seats" : False, |
|
"SeatSep" : False, |
|
"Dates" : True, |
|
"Groups" : False, |
|
"GroupsAll" : False, |
|
"Button1" : True, |
|
"Button2" : False |
|
} |
|
|
|
|
|
self.filters = Filters.Filters(self.db, self.conf, self.sql, display = filters_display) |
|
#self.filters.registerButton1Name(_("Import Hand")) |
|
#self.filters.registerButton1Callback(self.importhand) |
|
#self.filters.registerButton2Name(_("temp")) |
|
#self.filters.registerButton2Callback(self.temp()) |
|
|
|
# hierarchy: self.mainHBox / self.hpane / self.replayBox / self.area |
|
|
|
self.mainHBox = gtk.HBox(False, 0) |
|
self.mainHBox.show() |
|
|
|
self.leftPanelBox = self.filters.get_vbox() |
|
|
|
self.hpane = gtk.HPaned() |
|
self.hpane.pack1(self.leftPanelBox) |
|
self.mainHBox.add(self.hpane) |
|
|
|
self.replayBox = gtk.VBox(False, 0) |
|
self.replayBox.show() |
|
|
|
self.hpane.pack2(self.replayBox) |
|
self.hpane.show() |
|
|
|
self.area=gtk.DrawingArea() |
|
self.pangolayout = self.area.create_pango_layout("") |
|
self.area.connect("expose-event", self.area_expose) |
|
self.style = self.area.get_style() |
|
self.gc = self.style.fg_gc[gtk.STATE_NORMAL] |
|
self.area.show() |
|
|
|
self.replayBox.pack_start(self.area) |
|
|
|
gobject.timeout_add(1000,self.draw_action) |
|
|
|
self.MyHand = self.importhand() |
|
self.table = Table(self.area, self.MyHand).table |
|
|
|
if self.MyHand.gametype['currency']=="USD": #TODO: check if there are others .. |
|
self.currency="$" |
|
elif self.MyHand.gametype['currency']=="EUR": |
|
self.currency="€" |
|
|
|
self.actions=[] #create list with all actions |
|
|
|
if isinstance(self.MyHand, HoldemOmahaHand): |
|
if self.MyHand.gametype['category'] == 'holdem': |
|
self.play_holdem() |
|
|
|
self.action_number=0 |
|
self.action_level=0 |
|
self.pot=0 |
|
|
|
|
|
def area_expose(self, area, event): |
|
self.style = self.area.get_style() |
|
self.gc = self.style.fg_gc[gtk.STATE_NORMAL] |
|
|
|
playerid='999' #makes sure we have an error if player is not recognised |
|
for i in range(0,len(self.table)): #surely there must be a better way to find the player id in the table... |
|
if self.table[i]['name']==self.actions[self.action_number][1]: |
|
playerid=i |
|
|
|
if self.actions[self.action_number][2]=="folds": |
|
self.table[playerid]["status"]="folded" |
|
|
|
if self.actions[self.action_number][3]: |
|
self.table[playerid]["stack"] -= Decimal(self.actions[self.action_number][3]) #decreases stack if player bets |
|
self.pot += Decimal(self.actions[self.action_number][3]) #increase pot |
|
self.table[playerid]["chips"] += Decimal(self.actions[self.action_number][3]) #increase player's chips on table |
|
|
|
|
|
cm = self.gc.get_colormap() #create colormap toi be able to play with colours |
|
|
|
color = cm.alloc_color("black") #defaults to black |
|
self.gc.set_foreground(color) |
|
|
|
self.area.window.draw_arc(self.gc, 0, 125, 125, 300, 300, 0, 360*64) #table |
|
|
|
for i in self.table: |
|
if self.table[i]["status"]=="folded": |
|
color = cm.alloc_color("grey") #player has folded => greyed out |
|
self.gc.set_foreground(color) |
|
else: |
|
color = cm.alloc_color("black") #player is live |
|
self.gc.set_foreground(color) |
|
self.pangolayout.set_text(self.table[i]["name"]+self.table[i]["holecards"]) #player names + holecards |
|
self.area.window.draw_layout(self.gc, self.table[i]["x"],self.table[i]["y"], self.pangolayout) |
|
self.pangolayout.set_text('$'+str(self.table[i]["stack"])) #player stacks |
|
self.area.window.draw_layout(self.gc, self.table[i]["x"]+10,self.table[i]["y"]+20, self.pangolayout) |
|
|
|
color = cm.alloc_color("green") |
|
self.gc.set_foreground(color) |
|
|
|
self.pangolayout.set_text(self.currency+str(self.pot)) #displays pot |
|
self.area.window.draw_layout(self.gc,270,270, self.pangolayout) |
|
|
|
if self.actions[self.action_number][0]>1: #displays flop |
|
self.pangolayout.set_text(self.MyHand.board['FLOP'][0]+" "+self.MyHand.board['FLOP'][1]+" "+self.MyHand.board['FLOP'][2]) |
|
self.area.window.draw_layout(self.gc,210,240, self.pangolayout) |
|
if self.actions[self.action_number][0]>2: #displays turn |
|
self.pangolayout.set_text(self.MyHand.board['TURN'][0]) |
|
self.area.window.draw_layout(self.gc,270,240, self.pangolayout) |
|
if self.actions[self.action_number][0]>3: #displays river |
|
self.pangolayout.set_text(self.MyHand.board['RIVER'][0]) |
|
self.area.window.draw_layout(self.gc,290,240, self.pangolayout) |
|
|
|
color = cm.alloc_color("red") #highlights the action |
|
self.gc.set_foreground(color) |
|
|
|
self.pangolayout.set_text(self.actions[self.action_number][2]) #displays action |
|
self.area.window.draw_layout(self.gc, self.table[playerid]["x"]+10,self.table[playerid]["y"]+35, self.pangolayout) |
|
if self.actions[self.action_number][3]: #displays amount |
|
self.pangolayout.set_text(self.currency+self.actions[self.action_number][3]) |
|
self.area.window.draw_layout(self.gc, self.table[playerid]["x"]+10,self.table[playerid]["y"]+55, self.pangolayout) |
|
|
|
color = cm.alloc_color("black") #we don't want to draw the filters and others in red |
|
self.gc.set_foreground(color) |
|
|
|
def play_holdem(self): |
|
actions=('BLINDSANTES','PREFLOP','FLOP','TURN','RIVER') |
|
for action in actions: |
|
for i in range(0,len(self.MyHand.actions[action])): |
|
player=self.MyHand.actions[action][i][0] |
|
act=self.MyHand.actions[action][i][1] |
|
try: |
|
amount=str(self.MyHand.actions[action][i][2]) |
|
except: |
|
amount='' #no amount |
|
self.actions.append([actions.index(action),player,act,amount]) #create table with all actions |
|
|
|
|
|
def draw_action(self): |
|
if self.action_number==len(self.actions)-1: #no more actions, we exit the loop |
|
return False |
|
|
|
if self.actions[self.action_number][0]!=self.action_level: #have we changed street ? |
|
self.action_level=self.actions[self.action_number][0] #record the new street |
|
if self.action_level>1: #we don't want to refresh if simply moving from antes/blinds to preflop action |
|
alloc = self.area.get_allocation() |
|
rect = gtk.gdk.Rectangle(0, 0, alloc.width, alloc.height) |
|
self.area.window.invalidate_rect(rect, True) #make sure we refresh the whole screen |
|
|
|
self.action_number+=1 |
|
if self.area.window: |
|
playerid='999' #makes sure we have an error if player is not recognised |
|
for i in range(0,len(self.table)): #surely there must be a better way to find the player id in the table... |
|
if self.table[i]['name']==self.actions[self.action_number][1]: |
|
playerid=i |
|
rect = gtk.gdk.Rectangle(self.table[playerid]["x"],self.table[playerid]["y"],100,100) |
|
self.area.window.invalidate_rect(rect, True) #refresh player area of the screen |
|
rect = gtk.gdk.Rectangle(270,270,100,50) |
|
self.area.window.invalidate_rect(rect, True) #refresh pot area |
|
self.area.window.process_updates(True) |
|
print "draw action: ",self.action_number,self.actions[self.action_number][1],self.actions[self.action_number][2],self.actions[self.action_number][3] |
|
return True |
|
|
|
|
|
def get_vbox(self): |
|
"""returns the vbox of this thread""" |
|
return self.mainHBox |
|
|
|
def importhand(self, handnumber=1): |
|
"""Temporary function that grabs a Hand object from a specified file. Obviously this will |
|
be replaced by a function to select a hand from the db in the not so distant future. |
|
This code has been shamelessly stolen from Carl |
|
""" |
|
if False: |
|
settings = {} |
|
settings.update(self.conf.get_db_parameters()) |
|
settings.update(self.conf.get_import_parameters()) |
|
settings.update(self.conf.get_default_paths()) |
|
|
|
importer = fpdb_import.Importer(False, settings, self.conf, None) |
|
importer.setDropIndexes("don't drop") |
|
importer.setFailOnError(True) |
|
importer.setThreads(-1) |
|
importer.setCallHud(False) |
|
importer.setFakeCacheHHC(True) |
|
|
|
print "DEBUG: self.filename: '%s' self.site: '%s'" %(self.filename, self.site) |
|
importer.addBulkImportImportFileOrDir(self.filename, site=self.site) |
|
(stored, dups, partial, errs, ttime) = importer.runImport() |
|
|
|
hhc = importer.getCachedHHC() |
|
handlist = hhc.getProcessedHands() |
|
|
|
return handlist[0] |
|
else: |
|
# Fetch hand info |
|
# We need at least sitename, gametype, handid |
|
# for the Hand.__init__ |
|
|
|
####### Shift this section in Database.py for all to use ###### |
|
handid = 1 |
|
q = self.sql.query['get_gameinfo_from_hid'] |
|
q = q.replace('%s', self.sql.query['placeholder']) |
|
|
|
c = self.db.get_cursor() |
|
|
|
c.execute(q, (handid,)) |
|
res = c.fetchone() |
|
gametype = {'category':res[1],'base':res[2],'type':res[3],'limitType':res[4],'hilo':res[5],'sb':res[6],'bb':res[7], 'currency':res[10]} |
|
#FIXME: smallbet and bigbet are res[8] and res[9] respectively |
|
###### End section ######## |
|
print "DEBUG: gametype: %s" % gametype |
|
if gametype['base'] == 'hold': |
|
h = HoldemOmahaHand(config = self.conf, hhc = None, sitename=res[0], gametype = gametype, handText=None, builtFrom = "DB", handid=handid) |
|
h.select(self.db, handid) |
|
elif gametype['base'] == 'stud': |
|
print "DEBUG: Create stud hand here" |
|
elif gametype['base'] == 'draw': |
|
print "DEBUG: Create draw hand here" |
|
return h |
|
|
|
def temp(self): |
|
pass |
|
|
|
class Table: |
|
def __init__(self, darea, hand): |
|
self.darea = darea |
|
self.hand = hand |
|
self.players = [] |
|
#self.pixmap = gtk.gdk.Pixmap(darea, width, height, depth=-1) |
|
|
|
# tmp var while refactoring |
|
self.table = {} |
|
i = 0 |
|
for seat, name, chips in hand.players: |
|
self.players.append(Player(hand, name, chips, seat)) |
|
self.table[i] = self.players[i].get_hash() |
|
i += 1 |
|
|
|
pp.pprint(self.table) |
|
|
|
def draw(self): |
|
draw_players() |
|
draw_pot() |
|
draw_community_cards() |
|
|
|
class Player: |
|
def __init__(self, hand, name, stack, seat): |
|
self.status = 'live' |
|
self.stack = Decimal(stack) |
|
self.chips = 0 |
|
self.seat = seat |
|
self.name = name |
|
self.holecards = hand.join_holecards(name) |
|
self.x = int (round(250+200*math.cos(2*self.seat*math.pi/hand.maxseats))) |
|
self.y = int (round(250+200*math.sin(2*self.seat*math.pi/hand.maxseats))) |
|
|
|
def get_hash(self): |
|
return { 'chips': 0, |
|
'holecards': self.holecards, |
|
'name': self.name, |
|
'stack': self.stack, |
|
'status': self.status, |
|
'x': self.x, |
|
'y': self.y, |
|
} |
|
|
|
def draw(self): |
|
draw_name() |
|
draw_stack() |
|
draw_cards() |
|
|
|
class Pot: |
|
def __init__(self, hand): |
|
self.total = 0.0 |
|
|
|
def draw(self): |
|
pass |
|
|
|
class CommunityCards: |
|
def __init__(self, hand): |
|
self.pixbuf = self.gen_pixbuf_from_file(PATH_TO_THE_FILE) |
|
|
|
def draw(self): |
|
pass |
|
|
|
|
|
def main(argv=None): |
|
"""main can also be called in the python interpreter, by supplying the command line as the argument.""" |
|
if argv is None: |
|
argv = sys.argv[1:] |
|
|
|
def destroy(*args): # call back for terminating the main eventloop |
|
gtk.main_quit() |
|
|
|
import Options |
|
|
|
(options, argv) = Options.fpdb_options() |
|
|
|
if options.usage == True: |
|
#Print usage examples and exit |
|
sys.exit(0) |
|
|
|
if options.sitename: |
|
options.sitename = Options.site_alias(options.sitename) |
|
if options.sitename == False: |
|
usage() |
|
|
|
config = Configuration.Config(file = "HUD_config.test.xml") |
|
db = Database.Database(config) |
|
sql = SQL.Sql(db_server = 'sqlite') |
|
|
|
main_window = gtk.Window() |
|
main_window.connect('destroy', destroy) |
|
|
|
replayer = GuiReplayer(config, sql, main_window, options=options, debug=True) |
|
|
|
main_window.add(replayer.get_vbox()) |
|
main_window.set_default_size(800,800) |
|
main_window.show() |
|
gtk.main() |
|
|
|
if __name__ == '__main__': |
|
sys.exit(main())
|
|
|