def __init__ (self, password, from_address, to_address): PyChess.__init__(self) self.ports = (23, 5000) if not password: self.username = "******" else: self.username = "******" self.owner = "Lobais" self.password = password self.from_address = "The PyChess Bot <%s>" % from_address self.to_address = "Thomas Dybdahl Ahle <%s>" % to_address # Possible start times self.minutes = (1,2,3,4,5,6,7,8,9,10) self.gains = (0,5,10,15,20) # Possible colors. None == random self.colors = (WHITE, BLACK, None) # The amount of random challenges, that PyChess sends with each seek self.challenges = 10 enableEGTB() self.sudos = set() self.ownerOnline = False self.waitingForPassword = None self.log = [] self.acceptedTimesettings = [] self.worker = None repeat_sleep(self.sendChallenges, 60*1)
def __zerolistener(self, *args): # If we are called by a sleeper (rather than a signal) we need to pop # at least one time, as we might otherwise end up with items in the # heap, but no sleepers. if len(args) == 0 and self.heap: self.heap.pop() # Pop others (could this give a problem where too many are popped?) # No I don't think so. If a sleeper is too slow, so a later sleeper # comes before him and pops him, then it is most secure not to rely on # mr late, and start a new one. # We won't be 'one behind' always, because the previous pop doesnt # happen if the heap is empty. while self.heap and self.heap[-1] <= time(): self.heap.pop() if self.getPlayerTime(WHITE) <= 0: #print 'emit for white' self.emit('zero_reached', WHITE) if self.getPlayerTime(BLACK) <= 0: #print 'emit for black' self.emit('zero_reached', BLACK) #print 'heap is now', self.heap t1 = time() + self.getPlayerTime(WHITE) t2 = time() + self.getPlayerTime(BLACK) t = min(t1, t2) if not self.heap or t < self.heap[-1]: s = t - time() + 0.01 if s > 0: self.heap.append(t) # Because of recur, we wont get callback more than once. repeat.repeat_sleep(self.__zerolistener, s, recur=True)
def __init__(self, password, from_address, to_address): PyChess.__init__(self) self.ports = (23, 5000) if not password: self.username = "******" else: self.username = "******" self.owner = "Lobais" self.password = password self.from_address = "The PyChess Bot <%s>" % from_address self.to_address = "Thomas Dybdahl Ahle <%s>" % to_address # Possible start times self.minutes = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10) self.gains = (0, 5, 10, 15, 20) # Possible colors. None == random self.colors = (WHITE, BLACK, None) # The amount of random challenges, that PyChess sends with each seek self.challenges = 10 enableEGTB() self.sudos = set() self.ownerOnline = False self.waitingForPassword = None self.log = [] self.acceptedTimesettings = [] self.worker = None repeat_sleep(self.sendChallenges, 60 * 1)
def __zerolistener(self, *args): # If we are called by a sleeper (rather than a signal) we need to pop # at least one time, as we might otherwise end up with items in the # heap, but no sleepers. if len(args) == 0 and self.heap: self.heap.pop() # Pop others (could this give a problem where too many are popped?) # No I don't think so. If a sleeper is too slow, so a later sleeper # comes before him and pops him, then it is most secure not to rely on # mr late, and start a new one. # We won't be 'one behind' always, because the previous pop doesnt # happen if the heap is empty. while self.heap and self.heap[-1] <= time(): self.heap.pop() if self.getPlayerTime(WHITE) <= 0: #print 'emit for white' self.emit('zero_reached', WHITE) if self.getPlayerTime(BLACK) <= 0: #print 'emit for black' self.emit('zero_reached', BLACK) #print 'heap is now', self.heap t1 = time() + self.getPlayerTime(WHITE) t2 = time() + self.getPlayerTime(BLACK) t = min(t1,t2) if not self.heap or t < self.heap[-1]: s = t-time()+0.01 if s > 0: self.heap.append(t) # Because of recur, we wont get callback more than once. repeat.repeat_sleep(self.__zerolistener, s, recur=True)
def setModel (self, model): self.model = model self.model.connect("time_changed", self.time_changed) self.model.connect("player_changed", self.player_changed) self.formatedCache = [formatTime ( self.model.getPlayerTime (self.model.movingColor or WHITE))] * 2 if model.secs!=0 or model.gain!=0: repeat_sleep(self.update, 0.1)
def __init__(self, width, height): gtk.DrawingArea.__init__(self) self.connect("expose_event", self.__expose) self.surface = self.__loadSvg(addDataPrefix("glade/throbber.svg"), width, height) self.width = width self.height = height self.started = False repeat_sleep(self.redraw, 1. / MAX_FPS)
def __init__(self, width, height): gtk.DrawingArea.__init__(self) self.connect("expose_event", self.__expose) self.surface = self.__loadSvg(addDataPrefix("glade/throbber.svg"), width, height) self.width = width self.height = height self.started = False repeat_sleep(self.redraw, 1./MAX_FPS)
def __init__(self, width, height): GObject.GObject.__init__(self) self.connect("draw", self.__expose) self.surface = self.__loadSvg(addDataPrefix("glade/throbber.svg"), width, height) self.width = width self.height = height self.started = False self.stopped = False repeat_sleep(self.redraw, 1./MAX_FPS)
def __init__(self, width, height): GObject.GObject.__init__(self) self.connect("draw", self.__expose) self.surface = self.__loadSvg(addDataPrefix("glade/throbber.svg"), width, height) self.width = width self.height = height self.started = False self.stopped = False repeat_sleep(self.redraw, 1. / MAX_FPS)
def setModel (self, model): self.model = model if model != None: self.model.connect("time_changed", self.time_changed) self.model.connect("player_changed", self.player_changed) self.formatedCache = [self.formatTime ( self.model.getPlayerTime (self.model.movingColor or WHITE))] * 2 repeat_sleep(self.update, 0.1) else: self.formatedCache = None
def __zerolistener(self, *args): # If we are called by a sleeper (rather than a signal) we need to pop # at least one time, as we might otherwise end up with items in the # heap, but no sleepers. if len(args) == 0 and self.heap: self.heap.pop() # Pop others (could this give a problem where too many are popped?) # No I don't think so. If a sleeper is too slow, so a later sleeper # comes before him and pops him, then it is most secure not to rely on # mr late, and start a new one. # We won't be 'one behind' always, because the previous pop doesnt # happen if the heap is empty. while self.heap and self.heap[-1] <= time(): self.heap.pop() if self.getPlayerTime(WHITE) <= 0: #print 'emit for white' #self.emit('zero_reached', WHITE) if self.getPlayerTime(BLACK) <= 0: #print 'emit for black' #self.emit('zero_reached', BLACK) #print 'heap is now', self.heap t1 = time() + self.getPlayerTime(WHITE) t2 = time() + self.getPlayerTime(BLACK) t = min(t1,t2) if not self.heap or t < self.heap[-1]: s = t-time()+0.01 if s > 0: self.heap.append(t) # Because of recur, we wont get callback more than once. repeat.repeat_sleep(self.__zerolistener, s, recur=True) #print 'repeat on', s ############################################################################ # Interacting # ############################################################################ def setMovingColor (self, movingColor): self.movingColor = movingColor #self.emit("player_changed") def tap (self): if self.paused: return if self.started: t = self.intervals[self.movingColor][-1] + self.gain if self.counter != None: t -= time() - self.counter self.intervals[self.movingColor].append(t) else: self.intervals[self.movingColor].append ( self.intervals[self.movingColor][-1] ) if len(self.intervals[0]) + len(self.intervals[1]) >= 4: self.started = True self.movingColor = 1-self.movingColor if self.started: self.counter = time() #self.emit("time_changed") #self.emit("player_changed") def start (self): if self.started: return self.started = True self.counter = time() #self.emit("time_changed") def end (self): self.pause() self.ended = True def pause (self): log.debug("TimeModel.pause: self=%s\n" % self) if self.paused: return self.paused = True if self.counter != None: self.pauseInterval = time()-self.counter self.counter = None #self.emit("time_changed") #self.emit("pause_changed", True) def resume (self): log.debug("TimeModel.resume: self=%s\n" % self) if not self.paused: return self.paused = False self.counter = time() - self.pauseInterval #self.emit("pause_changed", False) ############################################################################ # Undo and redo in TimeModel # ############################################################################ def undoMoves (self, moves): """ Sets time and color to move, to the values they were having in the beginning of the ply before the current. his move. Example: White intervals (is thinking): [120, 130, ...] Black intervals: [120, 115] Is undoed to: White intervals: [120, 130] Black intervals (is thinking): [120, ...] """ if not self.started: self.start() for i in xrange(moves): self.movingColor = 1-self.movingColor del self.intervals[self.movingColor][-1] if len(self.intervals[0]) + len(self.intervals[1]) >= 4: self.counter = time() else: self.started = False self.counter = None #self.emit("time_changed") #self.emit("player_changed") ############################################################################ # Updating # ############################################################################ def updatePlayer (self, color, secs): if color == self.movingColor and self.started: self.counter = secs + time() - self.intervals[color][-1] else: self.intervals[color][-1] = secs #self.emit("time_changed") def syncClock (self, wsecs, bsecs): """ Syncronize clock to e.g. fics time """ if self.movingColor == WHITE: if self.started: self.counter = wsecs + time() - self.intervals[WHITE][-1] else: self.intervals[WHITE][-1] = wsecs self.intervals[BLACK][-1] = bsecs else: if self.started: self.counter = bsecs + time() - self.intervals[BLACK][-1] else: self.intervals[BLACK][-1] = bsecs self.intervals[WHITE][-1] = wsecs #self.emit("time_changed") ############################################################################ # Info # ############################################################################ def getPlayerTime (self, color): if color == self.movingColor and self.started: if self.paused: return self.intervals[color][-1] - self.pauseInterval elif self.counter: return self.intervals[color][-1] - (time() - self.counter) return self.intervals[color][-1] def getInitialTime (self): return self.intervals[WHITE][0] def getElapsedMoveTime (self, ply): movecount, color = divmod(ply, 2) return self.intervals[1-color][movecount-1] - self.intervals[1-color][movecount] if movecount > 0 else 0 @property def display_text (self): t = ("%d " % self.minutes) + _("min") if self.gain != 0: t += (" + %d " % self.gain) + _("sec") return t