def main():
#theres a better way to do this, but this is faster
fn = sys.argv[2] if (len(sys.argv) == 3
and sys.argv[1] == '-c') else 'default.cfg'
g.init(fn) # read in the input file to the project's globals
game = Game() # create the initial game board
log = open(g.logfile, 'w')
prepare_log(log)
best_soln = [(None, -maxint, -maxint, -maxint)]
for n in range(g.runs):
print 'Starting run #' + str(n + 1) + '\n'
log.write('Run ' + str(n + 1) + '\n')
result = evolution(game, log)
best_soln = determine_dominance(best_soln, result)
if n < g.runs - 1 and not g.datafile:
create_soln_file(best_soln)
g.seed = randint(0, maxint)
game.rand = Random(g.seed)
game.new_random_board()
log.close()
print 'finished calculations'
create_soln_file(best_soln)
def main():
#theres a better way to do this, but this is faster
fn = sys.argv[2] if (len(sys.argv) == 3 and sys.argv[1] == '-c') else 'default.cfg'
g.init(fn) # read in the input file to the project's globals
game = Game() # create the initial game board
log = open(g.logfile, 'w')
prepare_log(log)
best_soln = [(None, -maxint, -maxint, -maxint)]
for n in range(g.runs):
print 'Starting run #' + str(n+1) + '\n'
log.write('Run ' + str(n+1) + '\n')
result = evolution(game, log)
best_soln = determine_dominance(best_soln, result)
if n < g.runs-1 and not g.datafile:
create_soln_file(best_soln)
g.seed = randint(0, maxint)
game.rand = Random(g.seed)
game.new_random_board()
log.close()
print 'finished calculations'
create_soln_file(best_soln)
def run(self):
g.init()
g.journal = self.journal
if not self.journal:
utils.load()
self.best = g.best
else:
g.best = self.best
buttons.Button('reset', (g.sx(15.6), g.yc), True)
buttons.Button('new', (g.sx(18.8), g.yc), True)
self.board = tra.Board()
self.board.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:
g.mx, g.my = pygame.mouse.get_pos()
# 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
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:
g.glow_ms = None
g.red_ms = None
bu = buttons.check()
if bu != '': self.do_button(bu)
else: self.board.click()
elif event.type == pygame.KEYDOWN:
self.do_key(event.key)
g.redraw = True
if not going: break
self.update()
#self.board.setup(); g.redraw=True###
if g.redraw:
self.display()
if g.version_display: utils.version_display()
pygame.display.flip()
g.redraw = False
if g.score > g.best: g.best = g.score
self.best = g.best
tf = False
if pygame.mouse.get_focused(): tf = True
pygame.mouse.set_visible(tf)
g.clock.tick(40)
def run(self):
for event in pygame.event.get():
if event.type == pygame.QUIT:
return
elif event.type == pygame.VIDEORESIZE:
pygame.display.set_mode(
(event.size[0], event.size[1] - GRID_CELL_SIZE),
pygame.RESIZABLE)
break
g.init()
self.display()
if self.canvas is not None:
self.canvas.grab_focus()
while self.going:
# Pump Gtk messages.
if self.journal:
while Gtk.events_pending():
Gtk.main_iteration()
if not self.going:
break
for event in pygame.event.get():
if 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:
if not self.status:
self.do_button(event.pos)
g.redraw = True
self.flush_queue()
elif event.type == pygame.KEYDOWN:
if not self.status:
self.do_key(event)
g.redraw = True
self.flush_queue()
elif event.type == pygame.QUIT:
return
elif event.type == pygame.VIDEORESIZE:
pygame.display.set_mode(
(event.size[0], event.size[1] - GRID_CELL_SIZE),
pygame.RESIZABLE)
g.redraw = True
break
if g.redraw:
self.display()
g.screen.blit(g.pointer, g.pos)
pygame.display.flip()
g.redraw = False
pygame.display.update()
self.clock.tick(20) # Try to stay at 20 FPS
def run(self):
g.init()
if not self.journal: utils.load()
self.chess=chess.Chess()
g.cells=self.chess.cells
load_save.retrieve()
self.chess.setup() # having retrieved layout if any
self.buttons_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
if self.canvas<>None: self.canvas.grab_focus()
elif event.type == pygame.MOUSEBUTTONDOWN:
g.redraw=True
if event.button==1:
if self.do_click():
pass
else:
bu=buttons.check()
if bu!='': self.do_button(bu); 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.redraw:
self.display()
if g.version_display: utils.version_display()
g.screen.blit(g.pointer,g.pos)
pygame.display.flip()
g.redraw=False
self.update()
g.clock.tick(40)
def run(self):
g.init()
if not self.journal:
utils.load()
self.tess_n = g.tess_n
self.max_n = g.max_n
else:
g.tess_n = self.tess_n
g.max_n = self.max_n
self.tessl = tess.Tess(g.tesses[g.tess_n - 1])
dx = g.sy(2.4)
bx = g.sx(16) - dx / 2
by = g.sy(20.2)
buttons.Button("back", (bx, by), True)
bx += dx
buttons.Button("fd", (bx, by), True)
bx = g.sx(16)
by = g.sy(11)
buttons.Button("solve", (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 = ''
if not self.tessl.carrying:
bu = buttons.check()
if bu <> '': self.do_button(bu)
else: self.tessl.click()
self.tessl.update()
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)
def run(self):
g.init()
g.journal=self.journal
if not self.journal:
utils.load(); self.score=g.score; self.level=g.level
else:
g.score=self.score; g.level=self.level
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)
self.slider=slider.Slider(g.sx(16),g.sy(20.5),9,utils.GREEN)
self.grid=ah.Grid()
self.grid.new1(); self.grid.setup()
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
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:
if self.grid.click():
pass
elif self.slider.mouse():
self.grid.new1(); self.grid.setup(); buttons.clear() # level changed
else:
bu=buttons.check()
if bu!='': self.do_button(bu)
else: self.grid.colour_ind=0
elif event.type == pygame.KEYDOWN:
self.do_key(event.key); g.redraw=True
if not going: break
if self.grid.complete():
buttons.clear()
if g.redraw:
self.display()
if g.version_display: utils.version_display()
pygame.display.flip()
g.redraw=False
self.score=g.score; self.level=g.level
tf=False
if pygame.mouse.get_focused(): tf=True
pygame.mouse.set_visible(tf)
g.clock.tick(40)
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 run(self):
g.init()
if not self.journal: utils.load()
self.oms = []
for n in range(3, 8):
omm = om.Om(n)
omm.setup()
self.oms.append(omm)
load_save.retrieve()
self.omm = self.oms[g.level - 1]
self.buttons_setup()
self.slider = slider.Slider(g.sx(10.5), g.sy(20), 5, utils.YELLOW)
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.pos = event.pos
self.omm.mouse_move()
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:
if self.do_click():
pass
elif self.slider.mouse(): # level changed
self.omm = self.oms[g.level - 1]
else:
bu = buttons.check()
if bu != '': self.do_button(bu)
if event.button == 3: # right button
self.do_button('try')
elif event.type == pygame.KEYDOWN:
self.do_key(event.key)
g.redraw = True
if not going: break
if g.redraw:
self.display()
if not self.journal: # not on XO
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):
g.init()
if not self.journal: utils.load()
load_save.retrieve()
g.puzzle_n=g.solved
if g.puzzle_n==10: g.puzzle_n=0
iq1.init(); iq1.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
if self.canvas<>None: self.canvas.grab_focus()
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 g.redraw:
self.display()
if g.version_display: utils.version_display()
g.screen.blit(g.pointer,g.pos)
pygame.display.flip()
g.redraw=False
iq1.complete()
if g.finished and not g.redrawn: g.redraw=True; g.redrawn=True
g.clock.tick(40)
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
def run(self):
g.init()
self.grid = grid.Grid(8, 8, g.sy(2.4), 2, (212, 212, 175), utils.CREAM,
g.x0, g.y0)
if not self.journal: utils.load()
# setup before retrieve
self.grid.setup()
load_save.retrieve()
self.buttons_setup()
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.pos = event.pos
self.grid.check_mouse()
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 == 3:
g.ms = None
self.grid.right_click()
if event.button == 1:
g.ms = None
if self.do_click():
pass
else:
bu = buttons.check()
if bu != '': self.do_button(bu)
elif event.type == pygame.KEYDOWN:
g.ms = None
self.do_key(event.key)
g.redraw = True
if not going: break
self.glow()
if g.redraw:
self.display()
if not self.journal: # not on XO
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):
g.init()
if not self.journal:
utils.load(); self.level=g.level
else:
g.level=self.level
x=g.sx(26); y=g.sy(11.2)
buttons.Button("new",(x,y))
x=g.sx(4); y=g.sy(10); dx=g.sy(4)
buttons.Button("back",(x,y)); x+=dx
buttons.Button("plus",(x,y)); x+=dx
buttons.Button("times",(x,y)); x+=dx
buttons.Button("equals",(x,y))
self.slider=slider.Slider(g.sx(20.5),g.sy(20.5),10,utils.GREEN)
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)
self.level1() # initial animation
going=True
while going:
self.level=g.level
# 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=='':
if not self.check_numbers():
if self.slider.mouse(): self.level1()
else: self.do_button(bu) # eg do_button('plus')
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)
def run(self, restore=False):
g.init()
for event in pygame.event.get():
if event.type == pygame.QUIT:
return
elif event.type == pygame.VIDEORESIZE:
pygame.display.set_mode(event.size, pygame.RESIZABLE)
break
if not self.journal:
utils.load()
self.trip = trip.Trip(self.sugar, self.label, self.colors[0])
self.trip.setup()
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:
# only in standalone version
if not self.journal:
utils.save()
going = False
elif event.type == pygame.MOUSEMOTION:
g.pos = event.pos
self.trip.check_mouse()
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:
bu = buttons.check()
if bu != '':
self.do_button(bu)
else:
if self.trip.check_mouse():
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 g.redraw:
self.display()
if g.version_display:
utils.version_display()
g.screen.blit(g.pointer, g.pos)
pygame.display.flip()
g.redraw = False
if self.trip.delay:
pygame.time.delay(1000)
self.trip.delay = False
self.trip.gone()
g.redraw = True
self.trip.complete()
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):
for event in pygame.event.get():
if event.type == pygame.QUIT:
return
elif event.type == pygame.VIDEORESIZE:
pygame.display.set_mode(event.size, pygame.RESIZABLE)
break
g.init()
if not self.journal:
utils.load()
self.pages = pages.Pages()
self.map1 = map1.Map1()
self.ctry = ctry.Ctry()
load_save.retrieve()
self.buttons_setup()
if self.canvas is not None:
self.canvas.grab_focus()
ctrl = False
going = True
answer_input = False
down_event = None
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:
# Store the latest MOUSEBUTTONDOWN event
if event.button == 1:
down_event = event
elif event.type == pygame.MOUSEBUTTONUP:
g.redraw = True
self.ctry.message = None
g.pic = g.globe
if event.button == 1:
if self.proximity(
event, down_event) and answer_input is False:
if self.do_click():
pass
else:
bu = buttons.check()
if bu != '':
value = self.do_button(bu)
if value == 0:
answer_input = True
elif self.proximity(
event, down_event) and answer_input is True:
res = self.ctry.which_oval()
if res == 'y':
self.check_response()
else:
self.ctry.message = "Sorry, " + self.ctry.answer +\
" is not on my list"
self.ctry.answer = ''
answer_input = False
self.flush_queue()
if event.button == 3:
self.ctry.clear()
elif event.type == pygame.KEYDOWN:
# throttle keyboard repeat
self.ctry.message = None
g.pic = g.globe
if ctrl:
if event.key == pygame.K_q:
if not self.journal:
utils.save()
going = False
break
else:
ctrl = False
if answer_input is False:
if event.key in (pygame.K_LCTRL, pygame.K_RCTRL):
ctrl = True
break
value = self.do_key(event.key)
if value == 0:
answer_input = True
else:
if event.key == g.YES: # Value of 'y'
self.check_response()
else:
self.ctry.message = "Sorry, " + self.ctry.answer +\
" is not on my list"
self.ctry.answer = ''
answer_input = False
g.redraw = True
self.flush_queue()
elif event.type == pygame.KEYUP:
ctrl = False
if not going:
break
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):
g.init()
if not self.journal: utils.load()
load_save.retrieve()
self.buttons_setup()
self.slider=slider.Slider(g.sx(16),g.sy(20.5),9,utils.GREEN)
self.grid=ah.Grid()
self.grid.new1(); self.grid.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
if self.canvas!=None: self.canvas.grab_focus()
elif event.type == pygame.MOUSEBUTTONDOWN:
g.redraw=True
if event.button==1:
if self.grid.click():
pass
elif self.slider.mouse():
self.grid.new1(); self.grid.setup(); buttons.clear() # level changed
else:
bu=buttons.check()
if bu!='': self.do_button(bu)
else: self.grid.colour_ind=0
self.flush_queue()
elif event.button==3:
self.do_button('reset')
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.grid.complete():
buttons.clear()
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
self.score=g.score; self.level=g.level
g.clock.tick(40)
def run(self, restore=False):
self.black = False
g.init()
if not self.journal:
utils.load()
load_save.retrieve()
x = g.sx(26)
y = g.sy(11.2)
if not self.sugar:
buttons.Button("new", (x, y))
x, y = g.cxy2
dx = g.sy(4)
self.back_button = buttons.Button("back", (x, y))
x += dx
buttons.Button("plus", (x, y))
x += dx
buttons.Button("times", (x, y))
x += dx
buttons.Button("equals", (x, y))
self.ops = ['back', 'plus', 'times', 'equals']
if not self.sugar:
self.slider = slider.Slider(g.sx(22.4), g.sy(20.5), 10,
utils.GREEN)
self.mouse_auto = True
self.anim_ms = None
self.level1() # initial animation
self.scored = False
if restore:
g.score = self.save_score
ctrl = False
pygame.key.set_repeat(600, 120)
key_ms = pygame.time.get_ticks()
going = True
if self.canvas is not None:
self.canvas.grab_focus()
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
self.anim_end()
if event.button == 1:
bu = buttons.check()
if bu == '':
if not self.check_numbers():
if not self.sugar:
if self.slider.mouse():
self.level1()
else:
self.do_button(bu) # eg do_button('plus')
self.flush_queue()
elif event.type == pygame.KEYDOWN:
self.anim_end()
# 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
self.animation()
if g.redraw:
self.display()
if g.version_display:
utils.version_display()
if not self.black:
g.screen.blit(g.pointer, g.pos)
pygame.display.flip()
g.redraw = False
g.clock.tick(40)
def run(self, restore=False):
self.black = False
for event in pygame.event.get():
if event.type == pygame.QUIT:
return
elif event.type == pygame.VIDEORESIZE:
pygame.display.set_mode(event.size, pygame.RESIZABLE)
break
g.init()
if not self.journal:
utils.load()
load_save.retrieve()
x = g.sx(26)
y = g.sy(11.2)
if not self.sugar:
buttons.Button("new", (x, y))
x, y = g.cxy2
dx = g.sy(4)
self.back_button = buttons.Button("back", (x, y))
x += dx
buttons.Button("plus", (x, y))
x += dx
buttons.Button("times", (x, y))
x += dx
buttons.Button("equals", (x, y))
self.ops = ['back', 'plus', 'times', 'equals']
if not self.sugar:
self.slider = slider.Slider(g.sx(22.4), g.sy(20.5), 10,
utils.GREEN)
self.mouse_auto = True
self.anim_ms = None
self.level1() # initial animation
self.scored = False
if restore:
g.score = self.save_score
ctrl = False
pygame.key.set_repeat(600, 120)
key_ms = pygame.time.get_ticks()
going = True
if self.canvas is not None:
self.canvas.grab_focus()
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
self.anim_end()
if event.button == 1:
bu = buttons.check()
if bu == '':
if not self.check_numbers():
if not self.sugar:
if self.slider.mouse():
self.level1()
else:
self.do_button(bu) # eg do_button('plus')
self.flush_queue()
elif event.type == pygame.KEYDOWN:
self.anim_end()
# 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
self.animation()
if g.redraw:
self.display()
if g.version_display:
utils.version_display()
if not self.black:
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):
g.init()
g.journal = self.journal
if not self.journal:
utils.load()
self.success = g.success
else:
g.success = self.success
x = g.sx(3)
y = g.sy(1.8)
self.menu_bu = buttons.Button("menu", (x, y))
self.menu_bu.off()
self.pj = jigsaw.Jigsaw()
going = True
while going:
ms = pygame.time.get_ticks()
g.mx, g.my = pygame.mouse.get_pos()
# 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
g.version_display = not g.version_display
break
elif event.button == 1: # left button
if g.state == 3:
bu = buttons.check()
if bu != '':
g.state = 1
break
if g.state == 1:
self.menu_click()
if g.state == 2:
if not self.setup():
going = False
break
g.state = 3
elif g.state == 3:
self.pj.click()
if not going: break
if g.redraw:
self.display()
if g.version_display: utils.version_display()
if self.pj.carry:
g.screen.blit(g.negative, (g.mx, g.my))
else:
g.screen.blit(g.pointer, (g.mx, g.my))
pygame.display.flip()
g.redraw = False
self.success = g.success
g.clock.tick(40)
d = pygame.time.get_ticks() - ms
g.frame_rate = int(1000 / d)
def run(self, restore=False):
g.init()
pygame.init()
pygame.display.init()
if not self.journal:
utils.load()
self.trip = trip.Trip(self.sugar, self.label, self.colors[0])
self.trip.setup()
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:
# only in standalone version
if not self.journal:
utils.save()
going = False
elif event.type == pygame.MOUSEMOTION:
g.pos = event.pos
self.trip.check_mouse()
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:
bu = buttons.check()
if bu != '':
self.do_button(bu)
else:
if self.trip.check_mouse():
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 g.redraw:
self.display()
if g.version_display:
utils.version_display()
g.screen.blit(g.pointer, g.pos)
pygame.display.flip()
g.redraw = False
if self.trip.delay:
pygame.time.delay(1000)
self.trip.delay = False
self.trip.gone()
g.redraw = True
self.trip.complete()
g.clock.tick(40)
def run(self):
g.init()
if not self.journal: utils.load()
g.grid.setup()
load_save.retrieve()
bx = g.sx(3.3)
by = g.sy(9)
buttons.Button("cyan", (bx, by), True)
buttons.off("cyan")
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
if self.canvas <> None: self.canvas.grab_focus()
elif event.type == pygame.MOUSEBUTTONDOWN:
g.redraw = True
if event.button == 1:
if self.click():
self.flush_queue()
break
bu = buttons.check()
if bu <> '':
g.result = None
g.state = 0
g.grid.setup()
buttons.off("cyan")
self.flush_queue()
break
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
self.process()
g.grid.update()
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):
g.init()
if not self.journal: utils.load()
self.didg = didg.Didg()
g.carry_shape = didg.shapes[0]
self.didg.make_carry()
load_save.retrieve()
self.buttons_setup()
if self.canvas <> None: self.canvas.grab_focus()
ctrl = False
pygame.key.set_repeat(600, 120)
key_ms = pygame.time.get_ticks()
need_carry = False
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
need_carry = True
if self.canvas <> None: self.canvas.grab_focus()
elif event.type == pygame.MOUSEBUTTONDOWN:
g.redraw = True
if event.button == 1:
if self.do_click(1):
pass
else:
bu = buttons.check()
if bu != '':
self.do_button(bu)
self.flush_queue()
if event.button == 3:
self.do_click(3)
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.redraw:
g.carry_save = False
self.display()
if g.version_display: utils.version_display()
self.carry()
need_carry = False
pygame.display.flip()
g.redraw = False
elif need_carry:
self.carry()
pygame.display.flip()
need_carry = 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)
def reload(self):
self.save_score = g.score
buttons.reset()
g.init()
def run(self):
g.init()
g.journal = self.journal
if not self.journal:
utils.load()
self.best = g.best
else:
g.best = self.best
self.castle = cas.Castle(4) # 4x4 - 3x3 is ok too
self.castle.setup()
self.bu_setup()
going = True
while going:
ms = pygame.time.get_ticks()
g.mx, g.my = pygame.mouse.get_pos()
# 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
if self.canvas <> None: self.canvas.grab_focus()
elif event.type == pygame.MOUSEBUTTONDOWN:
g.redraw = True
if event.button == 2: # centre button
g.version_display = not g.version_display
break
if g.state == 1:
if g.telep_ms <> None:
g.telep_ms = None
break # stop teleporting
bu = buttons.check()
if bu != '':
self.do_button(bu)
break
if g.health > 0: self.click()
elif event.type == pygame.MOUSEBUTTONUP:
g.redraw = True
if event.button == 1:
self.bu_clear()
elif event.type == pygame.KEYDOWN:
if g.direction == '': self.do_key(event.key)
elif event.type == pygame.KEYUP:
g.redraw = True
self.bu_clear()
if not going: break
self.castle.move(g.direction)
self.castle.update()
if g.health == 0: self.bus_off()
if g.redraw:
self.display()
if g.version_display: utils.version_display()
if g.my > g.pointer.get_height():
g.screen.blit(g.pointer, (g.mx, g.my))
pygame.display.flip()
g.redraw = False
if g.best < g.score: g.best = g.score
self.best = g.best
g.clock.tick(40)
d = pygame.time.get_ticks() - ms
g.frame_rate = int(1000 / d)
def g_init(self):
g.init()
def reload(self):
self.save_score = g.score
buttons.reset()
g.init()
def run(self):
g.init()
if not self.journal:
utils.load()
g.xo = False
load_save.retrieve()
self.toc = layout.toc()
self.layout = layout.Layout(g.w - 2 * g.offset, int(g.h * 19 / 24))
self.render()
self.jig = jig.Jig()
self.buttons_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
if self.canvas <> None: self.canvas.grab_focus()
elif event.type == pygame.MOUSEBUTTONDOWN:
g.redraw = True
if event.button == 1:
bu = ''
if self.bu == None: bu = buttons.check()
if bu != '':
self.do_button(bu)
self.flush_queue()
else:
self.do_click()
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.layout.movie != None: self.layout.movie.update()
self.update()
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):
g.init()
g.journal = self.journal
if not self.journal:
utils.load()
self.count = g.count
else:
g.count = self.count
self.buttons_setup()
self.objects = jum.Objects()
self.objects.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
self.setup()
while going:
g.mx, g.my = pygame.mouse.get_pos()
# 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
self.objects.update()
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:
if self.objects.click():
if self.objects.complete:
buttons.off('next')
else:
self.display()
bu = buttons.check()
if bu != '': self.do_button(bu)
elif event.type == pygame.KEYDOWN:
self.do_key(event.key)
g.redraw = True
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 not going: break
if g.redraw:
self.display()
if g.version_display: utils.version_display()
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 g_init(self):
g.init()
def run(self):
for event in pygame.event.get():
if event.type==pygame.QUIT:
return
elif event.type == pygame.VIDEORESIZE:
pygame.display.set_mode(event.size, pygame.RESIZABLE)
break
g.init()
if not self.journal: utils.load()
self.acr=acr.Acr()
load_save.retrieve()
self.buttons_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
if self.canvas<>None: self.canvas.grab_focus()
elif event.type == pygame.MOUSEBUTTONDOWN:
self.acr.message=None
g.redraw=True
if event.button==1:
if g.help_on:
g.help_on=False
elif self.do_click():
pass
else:
bu=buttons.check()
if bu!='': self.do_button(bu); self.flush_queue()
if event.button==3: g.help_on=not g.help_on
elif event.type == pygame.KEYDOWN:
if event.key not in g.CIRCLE: g.help_on=False
self.acr.message=None
# 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
self.acr.update()
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)
# TurtleMachine.py
import g
g.init()
import my_turtle, angler, utils, pygame, buttons, animate
from pygame.locals import *
def display():
aim.do()
aim.draw()
if not aim.running: aim.draw_turtle_abs()
player.delay = 100 * (6 - g.level)
player.do()
player.draw()
g.screen.blit(g.basic_imgs[g.shape], (g.basic_x, g.basic_y))
g.screen.blit(g.bgd, (g.sx(0), 0))
if buttons.active('cyan'):
g.screen.blit(g.magician, (g.sx(1), g.sy(1.5)))
utils.centre_blit(g.screen, g.sparkle, (g.sx(4.5), g.sy(3.1)))
angler.draw()
s = str(g.repeats[g.repeat])
c = (g.repeat_cx, g.repeat_cy)
g.text_rect = utils.text_blit(g.screen, s, g.font2, c, (0, 0, 200))
s = str(g.aim_n + 1) + ' / ' + str(len(my_turtle.aims))
utils.text_blit1(g.screen, s, g.font1, (g.sx(6.3), g.sy(8.3)), (0, 0, 255))
buttons.draw()
g.slider.draw()
def aim_setup():
aim.set_program(my_turtle.aims[g.aim_n])
def run(self):
g.init()
if not self.journal: utils.load()
self.sim=sim.Sim()
load_save.retrieve()
self.buttons_setup()
if g.saved_n==0: buttons.off('cyan')
self.slider=slider.Slider(g.sx(23.4),g.sy(20.2),5,utils.GREEN)
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
if self.canvas<>None: self.canvas.grab_focus()
elif event.type == pygame.MOUSEBUTTONDOWN:
g.redraw=True
if g.help_on: g.help_on=False
elif event.button==1:
if self.do_click():
pass
elif self.slider.mouse():
pass # level changed
else:
bu=buttons.check()
if bu!='': self.do_button(bu); self.flush_queue()
elif event.button==3:
self.right_click()
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
self.update()
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):
for event in pg.event.get():
if event.type == pg.VIDEORESIZE:
pg.display.set_mode(event.size, pg.RESIZABLE)
break
g.init()
pg.font.init()
self.heading = pg.font.Font(None, 96).render("Tic - Tac - Toe", True, g.WHITE)
self.reset_text = pg.font.Font(None, 56).render("Reset", True, g.WHITE)
self.question_text = pg.font.Font(None, 72).render("?", True, g.WHITE)
self.close_text = pg.font.Font(None, 64).render("X", True, g.WHITE)
self.help_text = [
pg.font.Font(None, 36).render(
i,
True,
g.WHITE,
)
for i in (
"Each player takes it in turn to place their X or O",
"into one of the empty squares in the grid by clicking on it.",
"To win the game get three of your symbols in a line",
"horizontally, vertically or diagonally",
)
]
self.help_pos = pg.Rect(
(3 * g.WIDTH + g.FRAME_GAP * 3) // 4 - 40,
(g.HEIGHT * 0.5 - g.FRAME_GAP * 1.5) // 2 - 40,
80,
80,
)
self.reset_rect = pg.Rect(
g.WIDTH / 2 - self.reset_text.get_width() / 2,
g.HEIGHT - self.reset_text.get_height() - 80,
self.reset_text.get_width(),
self.reset_text.get_height() + 20,
)
self.font = pg.font.Font(None, 72)
self.cross_ui = Animate(self, color=g.ORANGE).cross(
((g.WIDTH - g.FRAME_GAP * 3) / 4, g.HEIGHT / 2 - g.FRAME_GAP / 4), 43, 11
)
self.circle_ui = Animate(self, color=g.RED).circle(
(g.WIDTH - (g.WIDTH - g.FRAME_GAP * 3) / 4, g.HEIGHT / 2 - g.FRAME_GAP / 4),
40,
8,
)
if self.canvas is not None:
self.canvas.grab_focus()
self.frame = Frame(self, (g.WIDTH / 2, g.HEIGHT / 2))
self.clock = pg.time.Clock()
while self.running:
if self.journal:
# Pump GTK messages.
while Gtk.events_pending():
Gtk.main_iteration()
self.check_events()
self.draw()
self.clock.tick(g.FPS)
pg.display.quit()
pg.quit()
sys.exit(0)
def run(self):
g.init()
if not self.journal: utils.load()
self.tr = [None, None, None, None]
self.menu = menu.Menu(4, 4, g.sy(.2), g.sy(1.3), g.sy(.2))
load_save.retrieve()
self.buttons_setup()
self.slider = [None, None]
self.slider[0] = slider.Slider(g.sx(16), g.sy(20.8), 2, utils.GREEN)
self.slider[1] = slider.Slider(g.sx(16), g.sy(20.8), 3, utils.GREEN)
self.levels = [1] * 16
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
if self.canvas <> None: self.canvas.grab_focus()
elif event.type == pygame.MOUSEBUTTONDOWN:
g.redraw = True
if event.button == 1:
if self.do_click():
pass
else:
if g.state == 'jigsaw':
bu = buttons.check()
if bu != '':
self.do_button(bu)
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.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)
