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
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
def clear(self):
self.cg()
self.home()
self.steps = 0
self.running = False
self.draw_turtle()
buttons.on('turtle')
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))
def main():
while True:
ms=pygame.time.get_ticks()
for event in pygame.event.get():
if event.type==QUIT:
utils.exit()
elif event.type == pygame.MOUSEBUTTONDOWN: # allow any button - left, right or middle
glow_off()
if click(): break
display(); pygame.display.flip() # no pointer in case button pressed
bu=buttons.check()
if bu<>'':do_button(bu)
elif event.type==KEYDOWN:
if event.key==K_ESCAPE: utils.exit()
if event.key==K_x: g.version_display=not g.version_display
if g.player_n==0 and not buttons.active('green'):
buttons.on("back")
display()
aim.do()
aim.glow(); player.glow()
if g.version_display:
g.message=g.app+' Version '+g.ver
g.message+=' '+str(g.w)+' x '+str(g.h)
g.message+=' '+str(g.frame_rate)+'fps'
utils.message(g.screen,g.font1,g.message)
mx,my=pygame.mouse.get_pos()
if my>g.pointer.get_height(): g.screen.blit(g.pointer,(mx,my))
pygame.display.flip()
g.clock.tick(40)
d=pygame.time.get_ticks()-ms; g.frame_rate=int(1000/d)
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'))
def click(self):
g.glow_sq = None
if self.carry == 0:
n = self.which_pile()
if n > 0:
piles[n] -= 1
self.carry = n
else:
sq = self.which_square()
if sq <> None:
if not sq.given:
if sq <> None:
self.carry = sq.piece
sq.piece = 0
else:
sq = self.which_square()
if sq == None:
piles[self.carry] += 1
self.carry = 0
else:
if not sq.given:
if sq.piece > 0: # piece already there
piles[sq.piece] += 1 # put it back
sq.piece = self.carry
self.carry = 0
buttons.on('reset')
self.check()
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)
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()
def do_button(self, bu):
if bu == 'save':
load_save.save_surf()
buttons.on('load')
return
if bu == 'load':
load_save.load_surf()
return
if bu == 'clear':
g.surf.fill(utils.CREAM)
return
def process(self):
if g.state == 0:
g.grid.start()
if g.state == 1:
g.current = 1
if self.complete(): g.state = 3
if g.state == 2:
g.current = 2
g.grid.wizard()
if self.complete(): g.state = 3
if g.state == 3:
buttons.on("cyan")
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'])
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)
def check():
if player.complete:
if convert(player.get_program()) == aim.get_program():
buttons.on('cyan')
p = aim.get_program()
if p[1] == 1: # have basic shape
n = p[0]
if n not in g.shapes:
g.shapes.append(n)
anim.start()
else:
g.checked = True
def do_click(self):
if g.state == 2: # menu
if self.slider.mouse(): return # level changed
n = self.menu.orange.n
self.jigsaw.pic_n = n
self.jigsaw.rc_n = g.level - 1
self.jigsaw.setup()
self.jigsaw.orange = None
self.jigsaw.orange_set()
g.state = 3
elif g.state == 3: # jigsaw
self.jigsaw.click()
if self.jigsaw.complete(): buttons.on('new')
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
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
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)
def check_numbers(self):
if not buttons.active('plus') and not self.correct():
(mx,my)=pygame.mouse.get_pos()
x1=g.sx(3);y1=g.sy(3.5);h=g.n[0].get_height()
for i in range(len(g.top)):
x=self.display_n(g.top[i],(x1,y1),False)
w=x-x1
rect=pygame.Rect(x1,y1,w,h)
if rect.collidepoint(mx,my):
g.buffr.append(g.top[i]); del g.top[i]
buttons.on(['back','plus','times'])
if len(g.buffr)>1: buttons.on('equals')
return True#****
x1=x+g.sp1
return False
def display(self): # called each loop
if g.big:
g.screen.fill(self.colors[1])
utils.centre_blit(g.screen, g.big_surface, (g.sx(16), g.sy(11.5)))
else:
if self.sugar:
g.screen.fill(self.colors[1])
else:
g.screen.blit(g.bgd, (g.sx(0), 0))
g.screen.blit(g.box, (g.x0, g.y0))
g.screen.blit(g.box, (g.x1, g.y1))
if not self.sugar:
utils.centre_blit(g.screen, g.magician, g.magician_c)
self.draw_goal()
utils.centre_blit(g.screen, g.turtle,
(g.x0 + 4 * g.dd, g.y0 + 6 * g.dd))
self.tu.draw()
if self.tu.win:
if self.sugar:
if self.good_job is None:
path = self.parent.good_job_image_path()
self.good_job = utils.load_image(path, True)
if g.w > g.h:
utils.centre_blit(
g.screen, self.good_job, (g.sx(7), g.sy(17)))
else:
utils.centre_blit(g.screen, self.good_job, (g.sx(7),
g.sy(38)))
else:
utils.centre_blit(g.screen, g.smiley, (g.sx(16.6),
g.sy(2.2)))
if self.sugar:
self.cyan_button.set_sensitive(True)
else:
buttons.on('cyan')
if not self.journal:
utils.save()
self.draw_nos()
if not self.sugar:
buttons.draw()
self.slider.draw()
if g.score > 0:
if self.sugar:
self.parent.update_score(int(g.score))
else:
utils.display_score()
utils.display_number1(g.pattern, (g.sx(2.4), g.sy(2)),
g.font1, utils.WHITE)
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)
def fast_do(self):
if self.running:
self.steps += 2
self.fd(self.size)
self.rt(self.a)
self.j += 1
if self.j == self.n:
self.j = 0
self.rt(self.angle)
self.i += 1
if self.i == self.repeat:
self.draw_turtle()
buttons.on('turtle')
self.running = False
self.steps = 0
self.complete = True #finished
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()
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
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
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
def do_button(self,bu):
if bu=='green':
if g.running:
g.running=False; buttons.clear()
else:
buttons.stay_down('green'); g.running=True
elif bu=='yellow':
g.running=False; buttons.clear(); self.sim.step()
elif bu=='cream':
g.running=False; buttons.clear(); self.sim.clear()
elif bu=='cyan':
g.running=False; buttons.clear(); self.sim.clear()
self.sim.load()
elif bu=='orange':
g.running=False; buttons.clear()
self.sim.save()
if g.saved_n>0: buttons.on('cyan')
elif bu=='help':
g.help_on=True; buttons.off('help'); return
def update(self):
if g.glow_ms <> None:
if g.glow_ms == -1: # start glow (set in tra.py)
g.glow_ms = pygame.time.get_ticks()
else: # check if glow finished
d = pygame.time.get_ticks() - g.glow_ms
if d > 800:
g.glow_ms = None
g.redraw = True
if g.red_ms <> None:
if g.red_ms == -1: # start red (set in tra.py)
g.red_ms = pygame.time.get_ticks()
else: # check if red finished
d = pygame.time.get_ticks() - g.red_ms
if d > 400:
g.red_ms = None
g.redraw = True
buttons.on('reset')
if self.board.first: buttons.off('reset')
def do_button(self, bu):
if bu == 'toc':
for (bu, filename, surf, x, y) in g.popups:
bu.off()
buttons.off(['fd', 'back', 'toc'])
for (bu, n) in g.toc:
bu.on()
g.toc_showing = True
if bu == 'blue':
for (bu, n) in g.toc:
if bu.mouse_on():
if g.page != n:
g.page = n
self.render()
if g.jig: self.jig.shuffle()
break
for (bu, filename, surf, x, y) in g.popups:
bu.on()
buttons.on(['toc'])
for (bu, n) in g.toc:
bu.off()
g.toc_showing = False
if bu == 'fd':
g.page += 1
self.render()
if g.jig: self.jig.shuffle()
if bu == 'back':
g.page -= 1
self.render()
if g.jig: self.jig.shuffle()
if bu == 'yellow':
for (bu, filename, surf, x, y) in g.popups:
if bu.mouse_on():
if self.bu != None: self.bu.on()
self.popup = surf, x, y
bu.off()
self.bu = bu
return
def display(self): # called each loop
if g.big:
g.screen.fill(self.colors[1])
utils.centre_blit(g.screen, g.big_surface, (g.sx(16), g.sy(11.5)))
else:
if self.sugar:
g.screen.fill(self.colors[1])
else:
g.screen.blit(g.bgd, (g.sx(0), 0))
g.screen.blit(g.box, (g.x0, g.y0))
g.screen.blit(g.box, (g.x1, g.y1))
if not self.sugar:
utils.centre_blit(g.screen, g.magician, g.magician_c)
self.draw_goal()
utils.centre_blit(g.screen, g.turtle,
(g.x0 + 4 * g.dd, g.y0 + 6 * g.dd))
self.tu.draw()
if self.tu.win:
utils.centre_blit(g.screen, g.smiley, (g.sx(16.6), g.sy(2.2)))
if self.sugar:
self.cyan_button.set_sensitive(True)
else:
buttons.on('cyan')
if not self.journal:
utils.save()
self.draw_nos()
if not self.sugar:
buttons.draw()
self.slider.draw()
if g.score > 0:
if self.sugar:
self.label.set_markup(
'<span><big><b> %s</b></big></span>' % (str(g.score)))
else:
utils.display_score()
utils.display_number1(g.pattern, (g.sx(2.4), g.sy(2)),
g.font1, utils.BLUE)
def display(self): # called each loop
if g.big:
g.screen.fill(self.colors[1])
utils.centre_blit(g.screen, g.big_surface, (g.sx(16), g.sy(11.5)))
else:
if self.sugar:
g.screen.fill(self.colors[1])
else:
g.screen.blit(g.bgd, (g.sx(0), 0))
g.screen.blit(g.box, (g.x0, g.y0))
g.screen.blit(g.box, (g.x1, g.y1))
if not self.sugar:
utils.centre_blit(g.screen, g.magician, g.magician_c)
self.draw_goal()
utils.centre_blit(g.screen, g.turtle,
(g.x0 + 4 * g.dd, g.y0 + 6 * g.dd))
self.tu.draw()
if self.tu.win:
utils.centre_blit(g.screen, g.smiley, (g.sx(16.6), g.sy(2.2)))
if self.sugar:
self.cyan_button.set_sensitive(True)
else:
buttons.on('cyan')
if not self.journal:
utils.save()
self.draw_nos()
if not self.sugar:
buttons.draw()
self.slider.draw()
if g.score > 0:
if self.sugar:
self.label.set_markup(
'<span><big><b> %s</b></big></span>' % (str(g.score)))
else:
utils.display_score()
utils.display_number1(g.pattern, (g.sx(2.4), g.sy(2)), g.font1,
utils.BLUE)
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()
def check_numbers(self):
if g.state == 1:
mx, my = g.pos
x1, y1 = g.xy1
h = g.n[0].get_height()
for i in range(len(g.top)):
x = self.display_n(g.top[i], (x1, y1), False)
w = x - x1
rect = pygame.Rect(x1, y1, w, h)
if rect.collidepoint(mx, my):
g.buffr.append(g.top[i])
del g.top[i]
buttons.on(['plus', 'times'])
buttons.on('back')
g.state = 2
self.mouse_init()
if len(g.buffr) > 1:
buttons.on('equals')
return True
x1 = x + g.sp1
return False
def check_numbers(self):
if g.state == 1:
mx, my = g.pos
x1, y1 = g.xy1
h = g.n[0].get_height()
for i in range(len(g.top)):
x = self.display_n(g.top[i], (x1, y1), False)
w = x - x1
rect = pygame.Rect(x1, y1, w, h)
if rect.collidepoint(mx, my):
g.buffr.append(g.top[i])
del g.top[i]
buttons.on(['plus', 'times'])
buttons.on('back')
g.state = 2
self.mouse_init()
if len(g.buffr) > 1:
buttons.on('equals')
return True
x1 = x + g.sp1
return False
def new1(self):
g.magic_show=False
self.display(True)
pygame.display.flip()
self.rects.setup(g.level)
buttons.on("black")
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)
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)
def run(self):
g.init()
if not self.journal: utils.load()
load_save.retrieve()
self.buttons_setup()
self.objects = jum.Objects()
self.objects.setup()
self.setup()
if self.canvas <> 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
self.objects.update()
if self.canvas <> None: self.canvas.grab_focus()
elif event.type == pygame.MOUSEBUTTONDOWN:
g.redraw = True
if event.button == 1:
if self.objects.click():
if self.objects.complete:
buttons.off('next')
else:
self.display()
bu = buttons.check()
if bu != '': self.do_button(bu)
if event.button == 3:
if buttons.active('next'): self.do_button('next')
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 g.setup_on:
self.objects.setup()
g.redraw = True
if (pygame.time.get_ticks() - self.setup_ms) > 2000:
g.setup_on = False
buttons.on('next')
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)
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)
