class Avioncito():
# Este juego es equivalente al test de Coraz'on-Flor de Adelle Diamond.
def __init__(self):
if LOG:
self.api = Fw_API()
else:
self.api = DebugGame()
self.screen = pygame.display.get_surface()
self.clock = pygame.time.Clock()
self.level = Level()
self.background = pygame.sprite.DirtySprite()
self.background.image = pygame.image.load(
"images/fondo" + str(Properties.SCREEN_RES[0]) + "x" +
str(Properties.SCREEN_RES[1]) + ".png")
self.background.rect = self.background.image.get_rect()
self.event_handler = EventHandler()
self.keyboard_handler = Event()
self.sprites_group = pygame.sprite.LayeredDirty()
self.clickeableGroup = pygame.sprite.Group()
self.sprites_group.add(self.background, layer=BACKGR_lyr)
self.clock_hand = ClockHand()
self.sprites_group.add(self.clock_hand, layer=CLOCK_HAND_lyr)
c = Clock()
c.rect.x = self.screen.get_rect().centerx - c.rect.width / 2
c.rect.y = self.screen.get_rect().centery - c.rect.height / 2
self.sprites_group.add(c, layer=CLOCK_lyr)
self.log("INIT ", "INICIANDO JUEGO")
self.shadow = pygame.sprite.DirtySprite()
self.shadow.image = pygame.Surface(self.screen.get_size(),
pygame.SRCALPHA) # per-pixel alpha
self.shadow.image.fill((0, 50, 150, 180))
self.shadow.rect = self.screen.get_rect()
self.shadow.visible = 0
self.levelbar = LevelBar(self.level)
self.sprites_group.add(self.levelbar.bar, layer=LEVEL_BAR_lyr)
self.leveltime = LevelTime(self.level)
self.sprites_group.add(self.leveltime, layer=LEVEL_TIME_lyr)
self.sprites_group.add(self.levelbar.check, layer=LEVEL_BAR_CHK_lyr)
self.sprites_group.add(self.shadow, layer=MSG_lyr)
self.info_button = InfoButton(self.show_instructions)
self.sprites_group.add(self.info_button, layer=CTRL_BTN_lyr)
self.clickeableGroup.add(self.info_button)
self.close_button = CloseButton(self.terminar_juego)
self.sprites_group.add(self.close_button, layer=CTRL_BTN_lyr)
self.clickeableGroup.add(self.close_button)
self.instructions_window = Instruction()
self.sprites_group.add(self.instructions_window, layer=INST_lyr)
self.state = State()
def sprites_clicked(self, _):
for i in self.clickeableGroup:
i.clicked(mouse.get_pos())
def show_instructions(self):
if self.state.show_instructions():
self.instructions_window.visible = 1
def log(self, prop, value):
self.api.log(
"AVIONCITO",
datetime.datetime.today().strftime("[%Y-%m-%d %H.%M.%S] ") + prop +
value + "\n")
def log_new_game(self):
self.log("NEW ", "*****************")
def log_plane(self, kind):
self.log("PLANE_KIND ", json.dumps(kind))
def log_plane_pos(self, pos):
self.log("PLANE_POS ", json.dumps(pos))
def log_res(self, res, time):
self.log("RES ", json.dumps(res) + " " + json.dumps(time))
def terminar_juego(self, ev=None):
self.running = False
def set_events(self):
suscribir_tecla = self.keyboard_handler.suscribe
self.event_handler.suscribe(pygame.QUIT, self.terminar_juego)
self.event_handler.suscribe(pygame.MOUSEBUTTONDOWN,
self.sprites_clicked)
self.event_handler.suscribe(
pygame.KEYDOWN,
lambda ev: self.keyboard_handler.dispatch(ev.key, ev))
suscribir_tecla(pygame.K_ESCAPE, self.terminar_juego)
suscribir_tecla(pygame.K_SPACE, lambda ev: self.restart_game())
suscribir_tecla(pygame.K_a, lambda ev: self.plane_left())
suscribir_tecla(pygame.K_l, lambda ev: self.plane_right())
def plane_left(self):
if self.plane is not None:
res = self.plane.plane_left()
self.eval_result(res)
def plane_right(self):
if self.plane is not None:
res = self.plane.plane_right()
self.eval_result(res)
def set_info_status(self):
self.log("Status ", " - Checkpoint: " + str(self.level.checkpoint))
def refresh_game_indicators(self):
self.set_info_status()
self.levelbar.make_checkpoint()
self.leveltime.refresh()
def restart_game(self):
if self.state.is_initial():
self.instructions_window.visible = 0
self.level.initial_values()
self.refresh_game_indicators()
self.clock_hand.start()
self.ticks = 0
self.plane_ticks = 50
self.answered = False
self.state.go_next()
elif self.state.is_pause():
self.instructions_window.visible = 0
self.state.go_next()
elif self.state.is_inst_lost():
self.instructions_window.visible = 0
self.state.go_next()
elif self.state.is_lost() and False:
self.level.initial_values()
self.refresh_game_indicators()
self.clock_hand.start()
self.ticks = 0
self.plane_ticks = 50
self.answered = False
self.state.go_next()
self.hide_messages()
def hide_messages(self):
for s in self.sprites_group.get_sprites_from_layer(MSG_lyr):
s.visible = 0
s.dirty = 0
def eval_result(self, res):
self.clock_hand.stop()
current_checkpoint = self.level.checkpoint
if not self.state.is_playing():
return
if not self.answered:
if res is None:
self.level.wrong_answer()
self.log_res("NO ANSW ",
time.time() - self.clock_hand.init_time)
elif res:
self.level.correct_answer()
self.log_res("CORRECT ",
time.time() - self.clock_hand.init_time)
else:
self.level.wrong_answer()
self.log_res("WRONG ", time.time() - self.clock_hand.init_time)
self.shadow.visible = 1
self.shadow.dirty = 1
self.answered = True
self.plane_ticks = 0
self.refresh_game_indicators()
if (current_checkpoint != self.level.checkpoint
and self.level.checkpoint < len(self.level.level_order)):
self.show_instructions()
if self.level.is_won():
print "ganaste"
self.sprites_group.add(Message("GANASTE", "ESC PARA SALIR"),
layer=MSG_lyr)
self.state.lost()
def delete_current_plane(self):
self.sprites_group.remove(self.plane)
self.plane = None
self.answered = False
def plane_builder(self):
p = self.level.next_trial()
self.plane = p()
self.plane.rect.center = choice(Properties.positions)
self.log_plane(self.plane.kind)
self.log_plane_pos(self.plane.rect.center)
print self.plane.rect.center
self.sprites_group.add(self.plane, layer=PLANE_lyr)
self.clock_hand.start()
def run(self):
#~ import pdb; pdb.set_trace()
self.running = True
self.set_events()
self.mainLoop()
def mainLoop(self):
print "MainLoop"
pygame.display.flip()
self.plane = None
while self.running:
self.clock.tick(10)
#while gtk.events_pending():
# gtk.main_iteration()
#1) Procesar acciones del jugador
self.event_handler.handle()
if self.state.is_playing():
if self.level.is_timed_level():
res = self.clock_hand.tic()
else:
res = True
self.plane_ticks += 1
if not res:
self.eval_result(None)
if self.answered and self.plane_ticks > 5: # ANDRE
self.delete_current_plane()
#if self.plane_ticks > 10 and self.plane is None:
if self.plane is None:
self.plane_builder()
self.plane_ticks = 0
self.hide_messages()
self.sprites_group.draw(self.screen)
pygame.display.flip()
self.api.close()
class Corsi():
def __init__(self, experiment):
self.logger = FileLogger()
self.screen = pygame.display.get_surface()
self.clock = pygame.time.Clock()
self.experiment = experiment
self.event_handler = EventHandler()
self.keyboard_handler = Event()
self.sprites_group = pygame.sprite.LayeredDirty()
self.background = {}
self.background["pasive"] = pygame.sprite.DirtySprite()
# self.background["pasive"].image = pygame.surface.Surface(Properties.SCREEN_RES)
self.background["pasive"].image = pygame.surface.Surface(
self.screen.get_size())
self.background["pasive"].image.fill([40, 40, 40])
self.background["pasive"].rect = self.background[
"pasive"].image.get_rect()
self.sprites_group.add(self.background["pasive"], layer=BACKGR_lyr)
# self.background["active"] = pygame.sprite.DirtySprite()
# self.background["active"].image = pygame.surface.Surface(Properties.SCREEN_RES)
# # self.background["active"].image = pygame.surface.Surface(self.screen.get_size())
# self.background["active"].image.fill([80,80,80])
# self.background["active"].rect = self.background["active"].image.get_rect()
# self.sprites_group.add(self.background["active"], layer=BACKGR_lyr)
# self.background["active"].visible = False
self.feedback_ok = Feedback()
self.feedback_no = Feedback(False)
self.sprites_group.add(self.feedback_ok, layer=FEED_lyr)
self.sprites_group.add(self.feedback_no, layer=FEED_lyr)
self.msgs = {}
self.boxes = {}
self.instruction = Instruction()
self.instruction.hide()
self.sprites_group.add(self.instruction, layer=INST_lyr)
self.msgs["done"] = ImageDone()
for v in self.msgs.itervalues():
self.sprites_group.add(v, layer=BTN_lyr)
for box_name, position in self.experiment["box_positions"].iteritems():
box = Box(box_name, json.loads(position),
self.experiment["properties"])
self.sprites_group.add(box, layer=BOXES_lyr)
self.boxes[box_name] = box
self.tic_group = []
self.trial = Trial(
self.logger, self.experiment["properties"],
self.change_to_active_mode, None, {
"ok": self.feedback_ok.show,
"no": self.feedback_no.show,
"off":
(lambda: [self.feedback_ok.hide(),
self.feedback_no.hide()])
})
self.exp_runner = ExpRunner(self.experiment, self.trial, self.boxes)
self.exp_runner.end_test = self.terminar_juego
self.exp_runner.instruction = self.instruction
self.trial.handle_end = self.exp_runner.next_trial
self.trial.set_boxes(self.boxes, self.suscribe_box_on,
self.unsuscribe_box)
self.boxes_on = []
self.msgs["done"].set_callback(self.trial.next_by_usr)
self.change_to_active_mode(False)
def change_to_active_mode(self, toActive=True):
# self.change_background(toActive)
if toActive:
self.state = INTERACTIVE
self.msgs["done"].show()
else:
self.state = PASSIVE
self.msgs["done"].hide()
def change_background(self, toActive=True):
if toActive:
self.background["active"].visible = True
self.background["pasive"].visible = False
else:
self.background["active"].visible = False
self.background["pasive"].visible = True
self.background["active"].dirty = True
self.background["pasive"].dirty = True
def set_events(self):
key_suscribe = self.keyboard_handler.suscribe
self.event_handler.suscribe(
pygame.KEYDOWN,
lambda ev: self.keyboard_handler.dispatch(ev.key, ev))
key_suscribe(
pygame.K_ESCAPE,
(lambda ev:
[self.logger.log_message("esc pressed"),
self.terminar_juego(ev)]))
self.event_handler.suscribe(
pygame.QUIT,
(lambda ev:
[self.logger.log_message("pygame quit"),
self.terminar_juego(ev)]))
self.event_handler.suscribe(pygame.MOUSEBUTTONDOWN, self.click)
# self.event_handler.suscribe(pygame.MOUSEBUTTONUP, self.click)
self.event_handler.suscribe(pygame.MOUSEBUTTONUP, self.release_click)
# def click(self, res):
# (x, y) = pygame.mouse.get_pos()
# if self.state == INTERACTIVE:
# for i in self.sprites_group.get_sprites_from_layer(BOXES_lyr):
# if (i.rect.collidepoint(x, y)):
# a = i.tic_off
# ev = pygame.USEREVENT + 1
# print "Suscribing event ", ev
# self.event_handler.suscribe(ev, a)
# i.click(lambda: self.event_handler.unsuscribe(ev, a))
# pygame.time.set_timer(ev, self.experiment["properties"]["tansweron"])
def click(self, res):
(x, y) = pygame.mouse.get_pos()
if self.state == INTERACTIVE:
click_in_box = False
for i in self.sprites_group.get_sprites_from_layer(BOXES_lyr):
if (i.rect.collidepoint(x, y)):
# print "Click box ", i.box_name
if not i.is_on:
self.suscribe_box_on(i)
i.click(self.experiment["properties"]["tansweron"],
self.unsuscribe_box)
self.trial.usr_answer(i.box_name, (x, y))
click_in_box = True
for i in self.sprites_group.get_sprites_from_layer(BTN_lyr):
if (i.rect.collidepoint(x, y)):
# print "Click button "
click_in_box = True
i.click()
if not click_in_box:
self.trial.usr_answer(None, (x, y))
elif self.state == PASSIVE:
if self.instruction.visible:
self.instruction.hide()
def release_click(self, res):
(x, y) = pygame.mouse.get_pos()
if self.state == INTERACTIVE:
for i in self.sprites_group.get_sprites_from_layer(BTN_lyr):
if (i.rect.collidepoint(x, y)):
# print "Click button "
click_in_box = True
i.release_click()
def suscribe_box_on(self, box):
self.boxes_on.append(box)
def unsuscribe_box(self, box):
# import pdb; pdb.set_trace();
self.boxes_on.remove(box)
def terminar_juego(self, ev=None):
print "TERMINANDO"
self.logger.log_message("end game")
self.logger.close()
self.running = False
def report_answ(self, ev=None):
if not self.trial.usr_answer():
self.logger.log_invalid_press()
def run(self):
#~ import pdb; pdb.set_trace()
self.running = True
self.set_events()
self.exp_runner.next()
self.mainLoop()
def trial_handle_next(self):
pass
def mainLoop(self):
pygame.display.flip()
self.playing = None
while self.running:
self.clock.tick(60)
self.event_handler.handle()
self.trial.tic()
for box in self.boxes_on:
box.tic()
self.sprites_group.draw(self.screen)
pygame.display.flip()
class Chrono():
def __init__(self, experiment):
self.logger = FileLogger()
self.screen = pygame.display.get_surface()
self.clock = pygame.time.Clock()
self.experiment = experiment
# self.level = Level()
self.event_handler = EventHandler()
self.keyboard_handler = Event()
self.sprites_group = pygame.sprite.LayeredDirty()
self.msgs = {}
self.msgs["welcome"] = ImageMessage(str(0), "welcome.jpg")
self.msgs["the_end"] = ImageMessage(str(0), "theEnd.jpg")
for v in self.msgs.itervalues():
self.sprites_group.add(v, layer=MSG_lyr)
self.trial = Trial(self.logger)
self.block = Block(self.trial, self.msgs)
self.exp_runner = ExpRunner(self.experiment, self.block, self.msgs,
self.set_images)
# self.log("INIT ", "INICIANDO JUEGO")
# self.state = State()
def set_images(self, block_num):
# print "Set images"
self.sprites_group.empty()
self.background = ImageMessage(block_num, "background.jpg")
self.background.show()
self.stimulus = Stimulus(block_num)
self.target_img = Stimulus(block_num, False)
self.feed = Feedback(block_num)
self.msgs["background"] = ImageMessage(block_num, "background.jpg")
self.msgs["op"] = ImageMessage(block_num, "operator.jpg")
self.msgs["feed"] = ImageMessage(block_num, "feedback.jpg")
self.msgs["subj"] = ImageMessage(block_num, "subject.jpg")
self.msgs["wait"] = ImageMessageBar(block_num, "endTrial.jpg",
self.feed)
self.msgs["end_block"] = ImageMessage(block_num, "endBlock.jpg")
for v in self.msgs.itervalues():
self.sprites_group.add(v, layer=MSG_lyr)
self.sprites_group.add(self.background, layer=BACKGR_lyr)
self.sprites_group.add(self.stimulus, layer=STIM_lyr)
self.sprites_group.add(self.target_img, layer=STIM_lyr)
self.sprites_group.add(self.feed.reference, layer=FEED_lyr)
self.sprites_group.add(self.feed.slow, layer=FEED_lyr)
self.sprites_group.add(self.feed.ok, layer=FEED_lyr)
self.sprites_group.add(self.feed.quick, layer=FEED_lyr)
self.trial.set_images(self.stimulus, self.target_img, self.feed)
def set_events(self):
key_suscribe = self.keyboard_handler.suscribe
# self.event_handler.suscribe(pygame.QUIT, self.terminar_juego)
# self.event_handler.suscribe(pygame.MOUSEBUTTONDOWN, self.sprites_clicked)
self.event_handler.suscribe(
pygame.KEYDOWN,
lambda ev: self.keyboard_handler.dispatch(ev.key, ev))
key_suscribe(pygame.K_ESCAPE, self.terminar_juego)
# key_suscribe(pygame.K_SPACE, lambda ev: self.restart_game())
# key_suscribe(pygame.K_q, self.start_stimulus)
key_suscribe(pygame.K_SPACE, self.report_answ)
self.event_handler.suscribe(pygame.MOUSEBUTTONDOWN,
lambda ev: self.block.next_by_usr())
self.event_handler.suscribe(pygame.MOUSEBUTTONDOWN,
lambda ev: self.exp_runner.next_block())
# key_suscribe(pygame.K_a, lambda ev: self.block.next_by_usr())
# key_suscribe(pygame.K_a, lambda ev: self.exp_runner.next_block())
def terminar_juego(self, ev=None):
self.logger.close()
self.running = False
def report_answ(self, ev=None):
if not self.trial.usr_answer():
self.logger.log_invalid_press()
def run(self):
#~ import pdb; pdb.set_trace()
self.running = True
self.set_events()
self.mainLoop()
self.current_block = 0
def trial_handle_next(self):
pass
def mainLoop(self):
# print "MainLoop"
pygame.display.flip()
self.playing = None
while self.running:
self.clock.tick(10)
self.event_handler.handle()
self.trial.tic()
self.block.tic()
self.sprites_group.draw(self.screen)
pygame.display.flip()