Exemplo n.º 1
0
 def do_button(self, bu):
     if bu == 'back':
         self.pages_on()
         return
     if bu == 'try':
         value = self.ctry.try1()
         return value
     if bu == 'clear':
         self.ctry.clear()
         return
     if bu == 'replay':
         self.ctry.setup()
         return
     if bu == 'minus':
         self.do_key(pygame.K_MINUS)
         return
     if bu == 'space':
         self.do_key(pygame.K_SPACE)
         return
     if bu == 'fd':
         self.pages.fd()
         return
     if bu == 'bk':
         self.pages.bk()
         return
     if bu == 'blue':
         g.pages = False
         buttons.on(('clear', 'try', 'minus', 'space', 'replay'))
         buttons.off(('fd', 'blue', 'bk'))
Exemplo n.º 2
0
 def do_button(self, bu):
     if bu == 'reset':
         self.board.reset()
         buttons.off('reset')
     if bu == 'new':
         self.board.setup()
         buttons.off('reset')
Exemplo n.º 3
0
 def click(self):
     if self.aim.running:
         return False
     if g.wrong:
         return False
     ind = self.which()
     if ind == -1:
         return False
     if len(self.aim.list1) == 0:
         return False
     self.player.glow_start(ind)
     if self.sugar:
         self.back_button.set_sensitive(False)
     else:
         buttons.off('back')
     if ind == self.aim.list1[g.player_n]:
         g.player_n += 1
         if g.player_n > g.score:
             g.score = g.player_n
         if g.player_n == len(self.aim.list1):  # all correct - add another
             self.aim.inc()
             g.player_n = 0
     else:
         g.wrong = True
         g.wrong_ind = ind
         g.right_ind = self.aim.list1[g.player_n]
         if self.sugar:
             self.green_button.set_sensitive(True)
         else:
             buttons.on('green')
     return True  # click processed
Exemplo n.º 4
0
 def click(self):
     if self.aim.running:
         return False
     if g.wrong:
         return False
     ind = self.which()
     if ind == -1:
         return False
     if len(self.aim.list1) == 0:
         return False
     self.player.glow_start(ind)
     if self.sugar:
         self.back_button.set_sensitive(False)
     else:
         buttons.off('back')
     if ind == self.aim.list1[g.player_n]:
         g.player_n += 1
         if g.player_n > g.score:
             g.score = g.player_n
         if g.player_n == len(self.aim.list1):  # all correct - add another
             self.aim.inc()
             g.player_n = 0
     else:
         g.wrong = True
         g.wrong_ind = ind
         g.right_ind = self.aim.list1[g.player_n]
         if self.sugar:
             self.green_button.set_sensitive(True)
         else:
             buttons.on('green')
     return True  # click processed
Exemplo n.º 5
0
 def display(self):
     g.screen.fill(utils.WHITE)
     if g.toc_showing:
         g.screen.blit(self.toc.surf, (g.offset, 0))
         buttons.draw()
         return
     g.screen.blit(self.layout.surf, (g.offset, 0))
     if g.jig:
         self.jig.draw()
     if g.mouse_locn:
         x, y = pygame.mouse.get_pos()
         m = '(' + str(x) + ',' + str(y) + ')'
         cxy = (g.sx(29), g.sy(1.2))
         utils.message(g.screen, g.font1, m, cxy, 5)
     if g.colors:
         g.screen.blit(g.colors_img, g.colors_xy)
         if utils.mouse_on_img(g.colors_img, g.colors_xy):
             c = g.screen.get_at(pygame.mouse.get_pos())
             r, g1, b = '0', '0', '0'
             if c[0] > 200: r = '255'
             if c[1] > 200: g1 = '255'
             if c[2] > 200: b = '255'
             m = '(' + r + ',' + g1 + ',' + b + ')'
             cxy = (g.sx(5.3), g.sy(19.5))
             utils.message(g.screen, g.font1, m, cxy, 5)
     if self.layout.movie != None: self.layout.movie.draw()
     buttons.on(['fd', 'back'])
     if g.page == 1: buttons.off('back')
     elif g.page == g.last_page: buttons.off('fd')
     buttons.draw()
     if g.rect_on:
         pygame.draw.rect(g.screen, utils.GREEN, g.rect)
     if self.popup != None:
         surf, x, y = self.popup
         g.screen.blit(surf, (x, y))
Exemplo n.º 6
0
 def reset(self):
     g.state = 1
     g.top = utils.copy_list(g.nos)
     g.buffr = []
     buttons.off(['plus', 'times', 'equals'])
     buttons.off('back')
     self.mouse_init()
Exemplo n.º 7
0
 def reset(self):
     g.state = 1
     g.top = utils.copy_list(g.nos)
     g.buffr = []
     buttons.off(['plus', 'times', 'equals'])
     buttons.off('back')
     self.mouse_init()
Exemplo n.º 8
0
 def do_key(self, key):
     if key in g.SQUARE:
         g.state = 0
         g.grid.setup()
         buttons.off("cyan")
         return
     if key == pygame.K_v:
         g.version_display = not g.version_display
         return
Exemplo n.º 9
0
 def fast_start(self):
     #self.start_ms=pygame.time.get_ticks()
     self.cg()
     self.home()
     self.n = self.poly_n
     self.a = 360 / self.n
     self.i = 0
     self.j = 0
     buttons.off('turtle')
Exemplo n.º 10
0
    def run(self):
        g.init()
        if not self.journal: utils.load()
        self.board = sud.Board()
        self.board.setup()
        load_save.retrieve()
        self.board.check()
        self.buttons_setup()
        if self.journal:  # Sugar only
            a, b, c, d = pygame.cursors.load_xbm('my_cursor.xbm',
                                                 'my_cursor_mask.xbm')
            pygame.mouse.set_cursor(a, b, c, d)
        going = True
        while going:
            # Pump GTK messages.
            while gtk.events_pending():
                gtk.main_iteration()

            # Pump PyGame messages.
            for event in pygame.event.get():
                if event.type == pygame.QUIT:  # only in standalone version
                    if not self.journal: utils.save()
                    going = False
                elif event.type == pygame.MOUSEMOTION:
                    g.redraw = True
                    if self.canvas <> None: self.canvas.grab_focus()
                elif event.type == pygame.MOUSEBUTTONDOWN:
                    g.redraw = True
                    if event.button == 2:  # centre button
                        if not self.journal:
                            g.version_display = not g.version_display
                    if event.button == 1:
                        bu = buttons.check()
                        if bu != '':
                            self.do_button(bu)
                        elif not g.finished:
                            if not self.help_check():
                                self.board.click()
                                if g.finished:
                                    buttons.on('new')
                                    buttons.off('reset')
                    if event.button == 3:
                        if not g.finished:
                            self.board.right_click()
            if not going: break
            if g.redraw:
                self.display()
                if g.version_display: utils.version_display()
                #g.screen.blit(g.pointer,(g.mx,g.my))
                pygame.display.flip()
                g.redraw = False
            self.count = g.count
            tf = False
            if pygame.mouse.get_focused(): tf = True
            pygame.mouse.set_visible(tf)
            g.clock.tick(40)
Exemplo n.º 11
0
 def buttons_setup(self):
     cx=g.sx(30.25); cy=g.sy(6.5); dy=g.sy(2)
     buttons.Button('save',(cx,cy)); cy+=dy
     y1=cy; cy+=2*dy
     buttons.Button('load',(cx,cy)); cy+=dy
     y2=cy; cy+=2*dy
     buttons.Button('clear',(cx,cy)); cy+=dy
     self.save_c=(cx,y1); self.load_c=(cx,y2)
     if g.saves_n==0: buttons.off('load')
     self.load_d=g.sy(.5) # half size of number for clicking
Exemplo n.º 12
0
 def do_button(self, bu):
     if bu == 'new':
         if g.state == 3:
             if self.jigsaw.complete():
                 n = self.jigsaw.pic_n
                 if g.level > g.best[n - 1]: g.best[n - 1] = g.level
         g.state = 2
         buttons.off('new')
         self.menu.orange = None
         self.menu.orange_set()
Exemplo n.º 13
0
 def display(self):
     g.screen.fill((0, 0, 120))
     self.som.draw()
     if self.som.complete():
         buttons.off(['cream', 'yellow'])
         buttons.on('black')
     else:
         buttons.on(['cream', 'yellow'])
         buttons.off('black')
     buttons.draw()
Exemplo n.º 14
0
 def new1(self):
     g.nos = self.gen_nos()
     g.aim = self.gen_aim()
     g.top = utils.copy_list(g.nos)
     g.buffr = []
     buttons.off(['plus', 'times', 'equals'])
     buttons.off('back')
     g.state = 1
     self.mouse_init()
     self.anim_start()
     self.scored = False
Exemplo n.º 15
0
 def new1(self):
     g.nos = self.gen_nos()
     g.aim = self.gen_aim()
     g.top = utils.copy_list(g.nos)
     g.buffr = []
     buttons.off(['plus', 'times', 'equals'])
     buttons.off('back')
     g.state = 1
     self.mouse_init()
     self.anim_start()
     self.scored = False
Exemplo n.º 16
0
    def run(self):
        g.init()
        self.rects=rects.Rects()
        if not self.journal:
            utils.load()
        else:
            g.level=self.level
        self.slider=slider.Slider(g.sx(16),g.sy(20.5),10,utils.GREEN)
        self.new1()
        bx=g.sx(29.5); by=g.sy(12)
        buttons.Button("cyan",(bx,by),True)
        by=g.sy(16)
        buttons.Button("black",(bx,by),True)
        if self.journal: # Sugar only
            a,b,c,d=pygame.cursors.load_xbm('my_cursor.xbm','my_cursor_mask.xbm')
            pygame.mouse.set_cursor(a,b,c,d)
        going=True
        while going:
            # Pump GTK messages.
            while gtk.events_pending():
                gtk.main_iteration()

            # Pump PyGame messages.
            for event in pygame.event.get():
                if event.type==pygame.QUIT:
                    if not self.journal: utils.save()
                    going=False
                elif event.type == pygame.MOUSEMOTION:
                    g.redraw=True
                elif event.type == pygame.MOUSEBUTTONDOWN:
                    g.redraw=True
                    if event.button==2: # centre button
                        if not self.journal:
                            g.version_display=not g.version_display; break
                    bu=buttons.check()
                    if bu<>'': self.button(bu); break
                    if self.slider.mouse(): self.new1(); break
                    if self.rects.click():
                        if not g.magic_show:
                            if self.rects.correct():
                                g.score+=g.level; g.magic_show=True
                                buttons.off("black")
            if not going: break
            if g.redraw:
                self.display()
                if g.version_display: utils.version_display()
                pygame.display.flip()
                g.redraw=False
            tf=False
            if pygame.mouse.get_focused(): tf=True
            pygame.mouse.set_visible(tf)
            g.clock.tick(40)
            # be ready for xo quit at any time
            self.level=g.level
Exemplo n.º 17
0
 def draw(self):
     g.screen.fill((100, 0, 100))
     if self.current == None: self.current = 1
     if self.img == None:
         file1 = str(self.current) + '.png'
         self.img = utils.load_image(file1, False, 'pages')
     g.screen.blit(self.img, self.xy)
     buttons.on(('fd', 'bk'))
     if self.current == 1: buttons.off('bk')
     if self.current == 10: buttons.off('fd')
     s = 'The Flags of the World page ' + str(self.current)
     utils.text_blit1(g.screen, s, g.font1, self.textxy, utils.CREAM, False)
Exemplo n.º 18
0
 def buttons_control(self):
     if g.button_display:
         buttons.on(['back', 'fd'])
         if g.tess_n == 1: buttons.off('back')
         if g.tess_n > g.max_n: buttons.off('fd')
         if g.tess_n == len(g.tesses): buttons.off('fd')
         if g.tess_n > g.max_n or self.tessl.complete():
             buttons.off('solve')
         else:
             buttons.on('solve')
     else:
         buttons.off(['back', 'fd', 'solve'])
Exemplo n.º 19
0
def do_button(bu):
    if bu == 'green':
        player_start()
        g.checked = False
    elif bu == 'red':
        player.stop()
    elif bu == 'cyan':
        next1()
        buttons.off('cyan')
    elif bu == 'white':
        player.clear()
    elif bu == 'turtle':
        player.toggle_turtle()
Exemplo n.º 20
0
 def buttons_setup(self):
     d = g.d + g.space
     x = g.xc
     y = g.y0 + d
     dy = d
     buttons.Button('reset', (x, y), True)
     y += dy
     buttons.Button('new', (x, y), True)
     y += dy
     g.yc = y + d + d  # for count
     if g.count == 0: buttons.off('new')
     if g.started == 0:
         buttons.off('reset')  # turned on when tile placed by sud.click()
Exemplo n.º 21
0
 def do_button(self, bu):
     if bu == 'green':  # start
         self.aim.new1()
         g.player_n = 0
         g.wrong = False
         g.score = 0
         if self.sugar:
             self.green_button.set_sensitive(True)
             self.back_button.set_sensitive(False)
         else:
             buttons.off('green')
             buttons.on('back')
     elif bu == 'back':
         self.aim.start()  # show again
Exemplo n.º 22
0
 def do_button(self, bu):
     max_n = len(g.tesses)
     if bu == 'fd':  # next tessellation
         g.tess_n += 1
         if g.tess_n > max_n: g.tess_n = 1
         self.tessl = tess.Tess(g.tesses[g.tess_n - 1])
     elif bu == 'back':  # previous tessellation
         g.tess_n -= 1
         if g.tess_n < 1: g.tess_n = max_n
         self.tessl = tess.Tess(g.tesses[g.tess_n - 1])
     elif bu == 'solve':
         self.tessl.solve()
         buttons.off('solve')
     self.tess_n = g.tess_n
Exemplo n.º 23
0
 def do_button(self,bu):
     for n in range(1,19):
         if bu==str(n):
             self.chess.set_layout(n); self.chess.setup()
             for b in range(1,19): buttons.off(str(b))
             buttons.on(['menu','new'])
             if self.chess.layout in self.chess.help: buttons.on('help')
             g.menu=False; return
     if bu=='menu': self.menu(); return
     if bu=='help':
         if g.help1: g.help1=False; buttons.on('new')
         else: self.help1()
     if bu=='new':
         self.chess.setup()
Exemplo n.º 24
0
 def do_button(self,button):
     if button=='equals':
         self.calc()
         buttons.off(['plus','times','equals'])
         if self.correct():
             if not g.correct: g.score+=g.level
             g.correct=True
     elif button=='back':
         self.reset()
     elif button=='new':
         self.new1()
     else:
         g.buffr.append(button)
         buttons.off(['plus','times','equals'])
Exemplo n.º 25
0
 def display(self):
     g.screen.fill(self.colors[1])
     if not self.sugar:
         g.screen.blit(g.bgd, (g.sx(0), 0))
     self.let.draw()
     if self.sugar:
         self.back_button.set_sensitive(False)
         self.tick_button.set_sensitive(False)
     else:
         buttons.off(['back', 'tick'])
     if g.state in (2, 4):
         if len(self.let.ans) > 0:
             if self.sugar:
                 self.back_button.set_sensitive(True)
             else:
                 buttons.on('back')
         if len(self.let.ans) > 1:
             if self.sugar:
                 self.tick_button.set_sensitive(True)
             else:
                 buttons.on('tick')
     buttons.draw()
     #utils.display_number(g.state,(10,10),g.font1)
     if g.state == 3:
         ln = len(self.let.ans)
         if ln == 2:
             s = _('Your word scores one point.')
         else:
             s = _('Your word scores %s points.' % (str(2 ** (ln - 2))))
         utils.text_blit(g.screen, s, g.font2, g.message_cxy,
                         self.colors[0], False)
     if g.state == 4:
         s = _('Sorry, %s is not in my word list' % self.let.ans)
         utils.text_blit(g.screen, s, g.font2, g.message_cxy,
                         self.colors[0], False)
     if self.sugar:
         self.label.set_markup(
             '<span><big><b> %s (%s)</b></big></span>' % (str(g.score),
                                                          str(g.best)))
     else:
         if g.score > 0:
             s = _('Total: %s' % (str(g.score)))
             utils.text_blit(g.screen, s, g.font1, g.score_cxy,
                             self.colors[0], False)
         if g.best > 0:
             s = _('Best: %s' % (str(g.best)))
             utils.text_blit(g.screen, s, g.font1, g.best_cxy,
                             self.colors[0], False)
     if g.help_on:
         utils.centre_blit(g.screen, g.help_img, g.help_cxy)
Exemplo n.º 26
0
 def do_button(self, bu):
     if bu == 'green':  # start
         self.aim.new1()
         g.player_n = 0
         g.wrong = False
         g.score = 0
         if self.sugar:
             self.green_button.set_sensitive(True)
             self.back_button.set_sensitive(False)
         else:
             buttons.off('green')
             buttons.on('back')
     elif bu == 'back':
         self.aim.start()  # show again
Exemplo n.º 27
0
 def buttons_setup(self):
     cx = g.sx(29.5)
     cy = g.sy(5)
     dy = g.sy(3)
     buttons.Button('cyan', (cx, cy))
     cy += dy
     buttons.Button('green', (cx, cy))
     cy += dy
     buttons.Button('red', (cx, cy))
     cy += dy
     buttons.Button('reset', (cx, cy))
     cy += dy
     buttons.Button('one', (cx, cy))
     cy += dy
     if g.pattern == 1: buttons.off('one')
Exemplo n.º 28
0
 def display(self):
     g.screen.fill(self.colors[1])
     if not self.sugar:
         g.screen.blit(g.bgd, (g.sx(0), 0))
     self.let.draw()
     if self.sugar:
         self.back_button.set_sensitive(False)
         self.tick_button.set_sensitive(False)
     else:
         buttons.off(['back', 'tick'])
     if g.state in (g.STATE_PLAY, g.STATE_WRONG):
         if len(self.let.ans) > 0:
             if self.sugar:
                 self.back_button.set_sensitive(True)
             else:
                 buttons.on('back')
         if len(self.let.ans) > 1:
             if self.sugar:
                 self.tick_button.set_sensitive(True)
             else:
                 buttons.on('tick')
     buttons.draw()
     if g.state == g.STATE_RIGHT:
         ln = len(self.let.ans)
         if ln == 2:
             s = _('Your word scores one point.')
         else:
             s = _('Your word scores %s points.' % (str(2**(ln - 2))))
         utils.text_blit(g.screen, s, g.font2, g.message_cxy,
                         self.colors[0], False)
     if g.state == g.STATE_WRONG:
         s = _('Sorry, %s is not in my word list' % self.let.ans)
         utils.text_blit(g.screen, s, g.font2, g.message_cxy,
                         self.colors[0], False)
     if self.sugar:
         self.label.set_markup('<span><big><b> %s (%s)</b></big></span>' %
                               (str(g.score), str(g.best)))
     else:
         if g.score > 0:
             s = _('Total: %s' % (str(g.score)))
             utils.text_blit(g.screen, s, g.font1, g.score_cxy,
                             self.colors[0], False)
         if g.best > 0:
             s = _('Best: %s' % (str(g.best)))
             utils.text_blit(g.screen, s, g.font1, g.best_cxy,
                             self.colors[0], False)
     if g.help_on:
         utils.centre_blit(g.screen, g.help_img, g.help_cxy)
Exemplo n.º 29
0
 def buttons_setup(self):
     cy=g.sy(5.8); dx=g.sy(4.87); dy=g.sy(7.1); n=1
     for r in range(3):
         cx=g.sx(3.82)
         for c in range(6):
             buttons.Button(str(n),(cx,cy),colour='yellow')
             buttons.off(str(n))
             cx+=dx; n+=1
         cy+=dy
     cx,cy=g.sx(29),g.h-g.sy(7.2); dy=g.sy(3.5)
     buttons.Button('menu',(cx,cy))
     buttons.Button('help',(g.sy(3),cy)); cy+=dy
     buttons.Button('new',(cx,cy),colour='cyan')
     g.bw=(g.sy(3),cy)
     k=g.sy(3); g.star_c=[(k+g.offset,k),(g.w-k+g.offset,k)]
     self.menu()
Exemplo n.º 30
0
 def do_button(self, button):
     if button == 'equals':
         self.calc()
         buttons.off(['plus', 'times', 'equals'])
         if not self.complete():
             g.state = 1
             self.mouse_init()
     elif button == 'back':
         self.reset()
     elif button in ['new', 'green']:
         self.new1()
     else:
         g.buffr.append(button)
         buttons.off(['plus', 'times', 'equals'])
         g.state = 1
         self.mouse_init()
Exemplo n.º 31
0
 def do_button(self, button):
     if button == 'equals':
         self.calc()
         buttons.off(['plus', 'times', 'equals'])
         if not self.complete():
             g.state = 1
             self.mouse_init()
     elif button == 'back':
         self.reset()
     elif button in ['new', 'green']:
         self.new1()
     else:
         g.buffr.append(button)
         buttons.off(['plus', 'times', 'equals'])
         g.state = 1
         self.mouse_init()
Exemplo n.º 32
0
 def display(self):
     g.screen.fill((0, 0, 0))
     g.level = self.levels[self.menu.green.n]
     if g.state == 'menu':
         self.menu.draw()
         n = self.slider_n()
         if n != None: self.slider[n].draw()
     else:
         self.tr[g.level].draw()
         buttons.off(['1', '2', '3', '4'])
         if not self.tr[g.level].complete():
             buttons.on(['1', '2', '3', '4'])
             g.screen.blit(g.arrows, g.arrows_xy)
         elif self.tr[g.level].success:
             utils.centre_blit(g.screen, g.smiley, g.smiley_c)
         buttons.draw()
Exemplo n.º 33
0
 def buttons_setup(self):
     if self.sugar:
         self.tick_button.set_sensitive(False)
         self.back_button.set_sensitive(False)
         return
     dx = g.sy(4)
     cx = g.sx(16) - 1.5 * dx
     cy = g.sy(15)
     buttons.Button('new', (cx, cy))
     cx += dx
     buttons.Button('tick', (cx, cy))
     cx += dx
     buttons.off('tick')
     buttons.Button('back', (cx, cy))
     cx += dx
     buttons.off('back')
     buttons.Button('help', (cx, cy))
Exemplo n.º 34
0
 def buttons_setup(self):
     if self.sugar:
         self.tick_button.set_sensitive(False)
         self.back_button.set_sensitive(False)
         return
     dx = g.sy(4)
     cx = g.sx(16) - 1.5 * dx
     cy = g.sy(15)
     buttons.Button('new', (cx, cy))
     cx += dx
     buttons.Button('tick', (cx, cy))
     cx += dx
     buttons.off('tick')
     buttons.Button('back', (cx, cy))
     cx += dx
     buttons.off('back')
     buttons.Button('help', (cx, cy))
Exemplo n.º 35
0
def click():
    if aim.running: return False
    if g.wrong: return False
    ind=which()
    if ind==-1: return False
    if len(aim.list1)==0: return False
    player.glow_start(ind)
    buttons.off("back")
    if ind==aim.list1[g.player_n]:
        g.player_n+=1
        if g.player_n>g.score: g.score=g.player_n
        if g.player_n==len(aim.list1): # all correct - add another
            aim.inc(); g.player_n=0
    else:
        g.wrong=True; g.wrong_ind=ind; g.right_ind=aim.list1[g.player_n]
        buttons.on("green")
    return True # click processed
Exemplo n.º 36
0
    def display(self):
        g.screen.fill(self.colors[1])
        if not self.sugar:
            g.screen.fill((255, 255, 192))
            g.screen.blit(g.magician, (g.sx(0), g.sy(18.0)))
        cx = g.sx(26)
        cy = g.sy(5.0)
        utils.centre_blit(g.screen, g.target, (cx, cy))

        if g.aim > 0:
            self.display_n_glow(g.aim, (cx, cy))
        x, y = g.xy1
        pale = False
        if g.state == 2:
            pale = True
        for i in range(len(g.top)):
            x = self.display_n(g.top[i], (x, y), True, False, pale)
            x += g.sp1
        x, y = g.xy3
        for i in range(len(g.buffr)):
            m = g.buffr[i]
            if m == 'plus':
                g.screen.blit(g.plus, (x, y))
                x += g.plus.get_width()
            elif m == 'times':
                g.screen.blit(g.times, (x, y))
                x += g.times.get_width()
            elif m == 'equals':
                g.screen.blit(g.equals, (x, y))
                x += g.equals.get_width()
            else:
                x = self.display_n(g.buffr[i], (x, y))
            x += g.sp2
        if len(g.top) == 0:
            buttons.off(['plus', 'times'])
        buttons.draw()
        if not self.sugar:
            self.slider.draw()
        if g.state == 4:
            utils.centre_blit(g.screen, g.smiley, (g.sx(16), g.sy(12)))
        if g.score > 0:
            self.display_score()
        if not self.sugar and g.best > 0:
            utils.text_blit(g.screen, str(g.best), g.font2, g.best_c,
                            utils.ORANGE)
Exemplo n.º 37
0
 def do_key(self, key):
     if key == pygame.K_1:
         g.version_display = not g.version_display
         return
     if key in g.CROSS:
         self.do_click()
         return
     if key in g.CIRCLE:
         if g.help_on:
             if not self.sugar:
                 g.help_on = False
                 buttons.on('help')
             return
         else:
             if not self.sugar:
                 g.help_on = True
                 buttons.off('help')
             return
     if key in g.SQUARE:
         self.do_button('new')
         return
     if key in g.UP:
         if g.state in (2, 4):
             self.do_button('back')
         return
     if key in g.LEFT:
         self.let.left()
         return
     if key in g.RIGHT:
         self.let.right()
         return
     if key in g.TICK:
         if len(self.let.ans) > 1:
             self.do_tick()
         return
     #if key==pygame.K_4: self.let.given='clangers'; return###
     if g.state in (2, 4):
         letter = letter_keys.which(key)
         if letter is not None:
             self.let.key(letter)
             return
         if key == pygame.K_BACKSPACE:
             g.state = 2
             self.let.back()
             return
Exemplo n.º 38
0
    def display(self):
        g.screen.fill(self.colors[1])
        if not self.sugar:
            g.screen.fill((255, 255, 192))
            g.screen.blit(g.magician, (g.sx(0), g.sy(18.0)))
        cx = g.sx(26)
        cy = g.sy(5.0)
        utils.centre_blit(g.screen, g.target, (cx, cy))

        if g.aim > 0:
            self.display_n_glow(g.aim, (cx, cy))
        x, y = g.xy1
        pale = False
        if g.state == 2:
            pale = True
        for i in range(len(g.top)):
            x = self.display_n(g.top[i], (x, y), True, False, pale)
            x += g.sp1
        x, y = g.xy3
        for i in range(len(g.buffr)):
            m = g.buffr[i]
            if m == 'plus':
                g.screen.blit(g.plus, (x, y))
                x += g.plus.get_width()
            elif m == 'times':
                g.screen.blit(g.times, (x, y))
                x += g.times.get_width()
            elif m == 'equals':
                g.screen.blit(g.equals, (x, y))
                x += g.equals.get_width()
            else:
                x = self.display_n(g.buffr[i], (x, y))
            x += g.sp2
        if len(g.top) == 0:
            buttons.off(['plus', 'times'])
        buttons.draw()
        if not self.sugar:
            self.slider.draw()
        if g.state == 4:
            utils.centre_blit(g.screen, g.smiley, (g.sx(16), g.sy(12)))
        if g.score > 0:
            self.display_score()
        if not self.sugar and g.best > 0:
            utils.text_blit(
                g.screen, str(g.best), g.font2, g.best_c, utils.ORANGE)
Exemplo n.º 39
0
 def do_key(self, key):
     if key == pygame.K_1:
         g.version_display = not g.version_display
         return
     if key in g.CROSS:
         self.do_click()
         return
     if key in g.CIRCLE:
         if g.help_on:
             if not self.sugar:
                 g.help_on = False
                 buttons.on('help')
             return
         else:
             if not self.sugar:
                 g.help_on = True
                 buttons.off('help')
             return
     if key in g.SQUARE:
         self.do_button('new')
         return
     if key in g.UP:
         if g.state in (g.STATE_PLAY, g.STATE_WRONG):
             self.do_button('back')
         return
     if key in g.LEFT:
         self.let.left()
         return
     if key in g.RIGHT:
         self.let.right()
         return
     if key in g.TICK:
         if len(self.let.ans) > 1:
             self.do_tick()
         return
     if g.state in (g.STATE_PLAY, g.STATE_WRONG):
         letter = letter_keys.which(key)
         if letter is not None:
             self.let.key(letter)
             return
         if key == pygame.K_BACKSPACE:
             g.state = g.STATE_PLAY
             self.let.back()
             return
Exemplo n.º 40
0
 def do_button(self, bu):
     if bu == 'new':
         if not self.let.check():
             if g.score > 0:
                 g.score -= 1
         self.let.setup()
         g.state = 1
         return
     if bu == 'back':
         self.let.reset()
         g.state = 2
         return
     if bu == 'tick':
         self.do_tick()
         return
     if bu == 'help':
         g.help_on = True
         if not self.sugar:
             buttons.off('help')
Exemplo n.º 41
0
 def do_button(self, bu):
     if bu == 'cyan':
         g.pattern += 1
         if g.pattern == 123:
             g.pattern = 1
         g.help1 = 0
         g.help2 = 0
         self.get_goal()
         self.tu.win = False
         g.finale = False
         g.show_help = False
         self.tu.changed = True
         self.tu.clear()
         if self.sugar:
             self.cyan_button.set_sensitive(False)
         else:
             buttons.off('cyan')
         self.mouse_1st_no()  # to 1st number
     elif bu == 'black':
         self.tu.current = utils.copy_list(g.numbers)
         self.tu.setup(self.colors[0])
         g.show_help = False
     elif bu == 'green':
         self.tu.between_levels = False
         g.show_help = False
         if self.tu.changed:
             self.tu.current = utils.copy_list(g.numbers)
             self.tu.setup(self.colors[0])
             self.tu.changed = False
             self.tu.running = True
         elif self.tu.win or self.tu.crashed:
             self.tu.setup(self.colors[0])
             self.tu.running = True
         else:
             if self.tu.step_count == 0:
                 self.tu.ms = pygame.time.get_ticks()
             self.tu.running = True
     elif bu == 'red':
         self.tu.running = False
Exemplo n.º 42
0
    def run(self, restore=False):
        g.init()
        if not self.journal:
            utils.load()
        self.let = let.Let()
        # setup before retrieve
        load_save.retrieve()
        self.buttons_setup()
        if self.canvas is not None:
            self.canvas.grab_focus()
        pygame.key.set_repeat(600, 120)
        going = True
        while going:
            if self.journal:
                # Pump GTK messages.
                while Gtk.events_pending():
                    Gtk.main_iteration()
                if not going:
                    break

            # Pump PyGame messages.
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    if not self.journal:
                        utils.save()
                    return
                elif event.type == pygame.VIDEORESIZE:
                    pygame.display.set_mode(event.size, pygame.RESIZABLE)
                    g.redraw = True
                elif event.type == pygame.MOUSEMOTION:
                    g.pos = event.pos
                    g.redraw = True
                    if self.canvas is not None:
                        self.canvas.grab_focus()
                elif event.type == pygame.MOUSEBUTTONDOWN:
                    g.redraw = True
                    if event.button == 1:
                        if not self.sugar and g.help_on:
                            g.help_on = False
                            buttons.on('help')
                        elif self.do_click():
                            pass
                        else:
                            bu = buttons.check()
                            if bu != '':
                                self.do_button(bu)
                    if not self.sugar and event.button == 3:
                        g.help_on = True
                        buttons.off('help')
                elif event.type == pygame.KEYDOWN:
                    if not self.sugar and event.key not in g.CIRCLE:
                        g.help_on = False
                        buttons.on('help')
                    self.do_key(event.key)
                    g.redraw = True
                elif event.type == pygame.KEYUP:
                    pass
            if not going:
                break

            if g.state == g.STATE_SETUP:
                self.let.choose()
            if g.redraw:
                self.display()
                if g.version_display:
                    utils.version_display()
                if g.state != g.STATE_SETUP:
                    g.screen.blit(g.pointer, g.pos)
                pygame.display.flip()
                g.redraw = False
            g.clock.tick(40)
Exemplo n.º 43
0
    def run(self, restore=False):
        self.g_init()
        if not self.journal:
            utils.load()
        load_save.retrieve()
        if restore:
            self.restore_pattern()
        else:
            g.delay = (3 - g.level) * 400
        self.tu = my_turtle.TurtleClass()
        self.tu.current = [1, 1, 1, 3, 2]
        self.get_goal()
        if g.pattern == 1:
            self.tu.current = utils.copy_list(g.goal)
        self.tu.setup(self.colors[0])
        g.numbers = utils.copy_list(self.tu.current)
        #buttons
        x = g.sx(7.3)
        y = g.sy(16.5)
        dx = g.sy(2.6)

        if not self.sugar:
            buttons.Button("cyan", (x, y), True)
            x += dx
            buttons.off('cyan')
            buttons.Button("green", (x, y), True)
            x += dx
            buttons.Button("red", (x, y), True)
            x += dx
            buttons.Button("black", (x, y), True)
            x += dx
            self.slider = slider.Slider(g.sx(23.5), g.sy(21), 3, utils.YELLOW)

        self.mouse_1st_no()  # to 1st number
        if self.canvas is not None:
            self.canvas.grab_focus()
        ctrl = False
        pygame.key.set_repeat(600, 120)
        key_ms = pygame.time.get_ticks()
        going = True
        while going:
            if self.journal:
                # Pump GTK messages.
                while gtk.events_pending():
                    gtk.main_iteration()

            # Pump PyGame messages.
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    if not self.journal:
                        utils.save()
                    going = False
                elif event.type == pygame.MOUSEMOTION:
                    g.pos = event.pos
                    g.redraw = True
                    if self.canvas is not None:
                        self.canvas.grab_focus()
                elif event.type == pygame.MOUSEBUTTONDOWN:
                    g.redraw = True
                    if g.big:
                        g.big = False
                    else:
                        bu = buttons.check()
                        if bu != '':
                            self.do_button(bu)
                            self.flush_queue()
                        elif not self.sugar:
                            if utils.mouse_on_img1(g.magician, g.magician_c):
                                self.help2()
                            elif utils.mouse_in(g.x1, g.y0, g.x1 + g.bw,
                                                g.y0 + g.bw):
                                self.big_pic()
                            elif self.slider.mouse():
                                g.delay = (3 - g.level) * 400
                            else:
                                g.show_help = False
                                self.check_nos(event.button)
                        else:
                            g.show_help = False
                            self.check_nos(event.button)
                elif event.type == pygame.KEYDOWN:
                    # throttle keyboard repeat
                    if pygame.time.get_ticks() - key_ms > 110:
                        key_ms = pygame.time.get_ticks()
                        if ctrl:
                            if event.key == pygame.K_q:
                                if not self.journal:
                                    utils.save()
                                going = False
                                break
                            else:
                                ctrl = False
                        if event.key in (pygame.K_LCTRL, pygame.K_RCTRL):
                            ctrl = True
                            break
                        self.do_key(event.key)
                        g.redraw = True
                        self.flush_queue()
                elif event.type == pygame.KEYUP:
                    ctrl = False
            if not going:
                break
            if self.tu.running:
                self.tu.move()
            if not g.crash_drawn:
                g.crash_drawn = True
                g.redraw = True
            if g.redraw:
                self.display()
                if g.version_display:
                    utils.version_display()
                g.screen.blit(g.pointer, g.pos)
                pygame.display.flip()
                g.redraw = False
            g.clock.tick(40)
Exemplo n.º 44
0
    def run(self, restore=False):
        g.init()
        if not self.journal:
            utils.load()
        self.let = let.Let()
        # setup before retrieve
        load_save.retrieve()
        self.buttons_setup()
        if self.canvas is not None:
            self.canvas.grab_focus()
        ctrl = False
        pygame.key.set_repeat(600, 120)
        key_ms = pygame.time.get_ticks()
        going = True
        while going:
            if self.journal:
                # Pump GTK messages.
                while Gtk.events_pending():
                    Gtk.main_iteration()
            # Pump PyGame messages.
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    if not self.journal:
                        utils.save()
                    going = False
                elif event.type == pygame.MOUSEMOTION:
                    g.pos = event.pos
                    g.redraw = True
                    if self.canvas is not None:
                        self.canvas.grab_focus()
                elif event.type == pygame.MOUSEBUTTONDOWN:
                    g.redraw = True
                    if event.button == 1:
                        if not self.sugar and g.help_on:
                            g.help_on = False
                            buttons.on('help')
                        elif self.do_click():
                            pass
                        else:
                            bu = buttons.check()
                            if bu != '':
                                self.do_button(bu)
                                self.flush_queue()
                    if not self.sugar and event.button == 3:
                        g.help_on = True
                        buttons.off('help')
                elif event.type == pygame.KEYDOWN:
                    if not self.sugar and event.key not in g.CIRCLE:
                        g.help_on = False
                        buttons.on('help')
                    # throttle keyboard repeat
                    if pygame.time.get_ticks() - key_ms > 110:
                        key_ms = pygame.time.get_ticks()
                        if ctrl:
                            if event.key == pygame.K_q:
                                if not self.journal:
                                    utils.save()
                                going = False
                                break
                            else:
                                ctrl = False
                        if event.key in (pygame.K_LCTRL, pygame.K_RCTRL):
                            ctrl = True
                            break
                        self.do_key(event.key)
                        g.redraw = True
                        self.flush_queue()
                elif event.type == pygame.KEYUP:
                    ctrl = False
            if not going:
                break

            if g.state == 1:
                self.let.choose()
            if g.redraw:
                self.display()
                if g.version_display:
                    utils.version_display()
                if g.state != 1:
                    g.screen.blit(g.pointer, g.pos)
                pygame.display.flip()
                g.redraw = False
            g.clock.tick(40)
Exemplo n.º 45
0
    def run(self, restore=False):
        self.g_init()
        if not self.journal:
            utils.load()
        load_save.retrieve()
        self.aim = simon.Simon(1200)  # arg is glow time
        if self.sugar:
            self.set_delay(800)
        else:
            self.set_delay()
        self.player = simon.Simon(200)
        if restore:
            self.restore_pattern()
            self.aim.started = True
        if self.sugar:
            self.green_button.set_sensitive(True)
            self.back_button.set_sensitive(False)
        else:
            bx = g.sx(22.42)
            by = g.sy(20.8)
            buttons.Button('green', (bx, by), True)
            buttons.Button('back', (bx, by), True)
            buttons.off('back')
            self.slider = slider.Slider(g.sx(9), g.sy(20.8), 3, utils.BLUE)
        self.rc = rc_skip_last.RC(3, 5)
        if self.canvas is not None:
            self.canvas.grab_focus()
        ctrl = False
        pygame.key.set_repeat(600, 120)
        key_ms = pygame.time.get_ticks()
        going = True
        while going:
            if self.journal:
                # Pump GTK messages.
                while gtk.events_pending():
                    gtk.main_iteration()

            # Pump PyGame messages.
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    if not self.journal:
                        utils.save()
                    going = False
                elif event.type == pygame.MOUSEMOTION:
                    g.pos = event.pos
                    g.redraw = True
                    if self.canvas is not None:
                        self.canvas.grab_focus()
                    self.mouse_set()
                elif event.type == pygame.MOUSEBUTTONDOWN:
                    g.redraw = True
                    if event.button == 1:
                        self.do_click()
                        self.flush_queue()
                elif event.type == pygame.KEYDOWN:
                    # throttle keyboard repeat
                    if pygame.time.get_ticks() - key_ms > 110:
                        key_ms = pygame.time.get_ticks()
                        if ctrl:
                            if event.key == pygame.K_q:
                                if not self.journal:
                                    utils.save()
                                going = False
                                break
                            else:
                                ctrl = False
                        if event.key in (pygame.K_LCTRL, pygame.K_RCTRL):
                            ctrl = True
                            break
                        self.do_key(event.key)
                        g.redraw = True
                        self.flush_queue()
                elif event.type == pygame.KEYUP:
                    ctrl = False
            if not going:
                break
            if self.sugar:
                if g.player_n == 0 and not self.green_button.get_sensitive():
                    self.back_button.set_sensitive(True)
            else:
                if g.player_n == 0 and not buttons.active('green'):
                    buttons.on('back')
            self.player.do()
            self.aim.do()
            if g.redraw:
                self.display()
                if g.version_display:
                    utils.version_display()
                if self.aim.running or self.aim.glow_active:
                    pass
                else:
                    g.screen.blit(g.pointer, g.pos)
                pygame.display.flip()
                g.redraw = False
            g.clock.tick(40)