def wire_events(self):
imp.IMP().add_delegate(
events.UserEvent(CustomEvent.CARD_MOTION).listen(
self.on_card_motion, quell=True))
imp.IMP().add_delegate(
events.UserEvent(CustomEvent.CARD_DROPPED).listen(
self.on_card_dropped))
def wire_events(self):
imp.IMP().add_delegate(
events.UserEvent(CustomEvent.FIRST_CARD).listen(
self.on_first_card))
imp.IMP().add_delegate(
events.UserEvent(CustomEvent.CARD_TABLE_RESIZED).listen(
self.on_card_table_resized))
def wire_events(self):
self.imp.add_listener(events.QuitEvent().create([self.on_quit]))
self.imp.add_listener(events.VideoResizeEvent().create(
[self.on_resize]))
self.imp.add_listener(events.KeyDownEvent().create([self.on_quit]))
self.imp.add_listener(
events.UserEvent(events.UserEvents.UNIT_TEST).create(
[self.on_unit_test]))
events.UserEvent(events.UserEvents.UNIT_TEST).post()
def post_tile_clicked(self, mouse_pos):
tile = self.get_clicked_tile(mouse_pos)
if not tile == None:
if tile.index == DeckTile.INDEX:
discard_tile = self.get_discard_tile()
events.UserEvent(CustomEvent.DRAW_ONE).post(
deck_tile=tile, discard_tile=discard_tile)
else:
events.UserEvent(CustomEvent.TILE_CLICKED).post(tile=tile,
pos=mouse_pos)
def wire_events(self):
imp.IMP().add_delegate(events.WindowResizedEvent().listen(
self.on_resize))
imp.IMP().add_delegate(events.MouseMotionEvent().listen(
self.on_mouse_motion, quell=True))
imp.IMP().add_delegate(events.MouseLeftButtonDownEvent().listen(
self.on_mouse_left_button_down))
imp.IMP().add_delegate(events.MouseLeftButtonUpEvent().listen(
self.on_mouse_left_button_up))
imp.IMP().add_delegate(
events.UserEvent(CustomEvent.QUICK_LAY).listen(self.on_quick_lay))
imp.IMP().add_delegate(
events.UserEvent(CustomEvent.CARD_LAYED).listen(
self.on_card_layed))
def on_card_layed(self, event):
selected_card = event.card
if not selected_card == None:
max_area = 0
original_tile = selected_tile = self.card_tiles[
selected_card.tile_index]
for tile in self.find_all(lambda x: not x == BlankTile.INDEX):
if selected_card.rect.is_intersecting(tile.rect):
area = selected_card.rect.intersecting(
tile.rect).get_area()
if area > max_area:
max_area = area
selected_tile = tile
original_tile.pop()
if not selected_tile.index == original_tile and selected_tile.can_lay(
selected_card):
self.post_score_update(selected_tile.index)
print('Action> {} -> {} -> {}'.format(original_tile.index,
selected_card,
selected_tile))
selected_tile.lay(selected_card)
undo_args = (original_tile, selected_tile, selected_card)
undo_action = acts.UndoAction(self.undo_card_layed,
self.redo_card_layed, *undo_args)
imp.IMP().actions.post(undo_action)
else:
print('NonAction> {} <- {}'.format(original_tile,
selected_card))
original_tile.lay(selected_card)
if self.check_win():
events.UserEvent(CustomEvent.GAME_OVER).post()
def on_resize(self, event):
new_size = (event.w, event.h)
self.set_size(new_size)
self.set_position(self.origin)
self.resize(*self.origin, *new_size)
events.UserEvent(
CustomEvent.CARD_TABLE_RESIZED).post(tiles=self.find_all())
def redo_draw(self, index, card, deck_tile, discard_tile):
self.active_cards.append(index)
events.UserEvent(CustomEvent.UPDATE_SCORE).post(inc=-1)
discard_tile.lay(card)
deck_tile.update_text(str(len(self.deck) - len(self.active_cards)))
print('RedoAction> (#{} {}) {} Left'.format(
index, card,
len(self.deck) - len(self.active_cards)))
def undo_draw(self, index, card, deck_tile, discard_tile):
discard_tile.remove(card)
events.UserEvent(CustomEvent.UPDATE_SCORE).post(inc=-1)
self.active_cards.remove(index)
deck_tile.update_text(str(len(self.deck) - len(self.active_cards)))
print('UndoAction> (#{} {}) {} Left'.format(
index, card,
len(self.deck) - len(self.active_cards)))
def on_tile_dbl_clicked(self, event):
for i in reverse(self.active_cards):
card = self.deck[i]
if card.tile_index == event.tile.index:
self.active_cards.remove(i)
self.active_cards.append(i)
events.UserEvent(CustomEvent.QUICK_LAY).post(card=card)
break
def on_draw_one(self, event):
if len(self.active_cards) < len(self.deck):
next_index = len(self.active_cards)
next_card = self.deck[next_index]
self.active_cards.append(next_index)
event.discard_tile.lay(next_card)
self.update_remaining(event.deck_tile)
events.UserEvent(CustomEvent.UPDATE_SCORE).post(inc=-1)
print('Action> Next Card: (#{} {})'.format(next_index, next_card))
undo_args = (next_index, next_card, event.deck_tile,
event.discard_tile)
undo_action = acts.UndoAction(self.undo_draw, self.redo_draw,
*undo_args)
imp.IMP().actions.post(undo_action)
def on_quick_lay(self, event):
card = event.card
tile = self.find_tile_to_lay(card)
source_tile = self.card_tiles[card.tile_index]
if not tile == None:
source_tile.pop()
tile.lay(card)
if not tile.index == source_tile.index:
self.post_score_update(tile.index)
print('Action> {} -> {} -> {}'.format(source_tile.index, card,
tile))
undo_args = (source_tile, tile, card)
undo_action = acts.UndoAction(self.undo_card_layed,
self.redo_card_layed, *undo_args)
imp.IMP().actions.post(undo_action)
else:
print('NonAction> {} <- {}'.format(source_tile, card))
if self.check_win():
events.UserEvent(CustomEvent.GAME_OVER).post()
def wire_events(self):
imp.IMP().add_delegate(
events.UserEvent(CustomEvent.TILE_CLICKED).listen(
self.on_tile_clicked))
imp.IMP().add_delegate(
events.UserEvent(CustomEvent.TILE_DBL_CLICKED).listen(
self.on_tile_dbl_clicked))
imp.IMP().add_delegate(
events.UserEvent(CustomEvent.NEW_DEAL).listen(self.on_new_deal))
imp.IMP().add_delegate(
events.UserEvent(CustomEvent.RESTART).listen(self.on_restart))
imp.IMP().add_delegate(
events.UserEvent(CustomEvent.DRAW_ONE).listen(self.on_draw_one))
imp.IMP().add_delegate(
events.UserEvent(CustomEvent.CARD_TABLE_RESIZED).listen(
self.on_card_table_resized))
imp.IMP().add_delegate(
events.UserEvent(CustomEvent.WINNABLE_HANDS).listen(
self.on_winnable_hands))
def wire_events(self):
imp.IMP().add_delegate(events.QuitEvent().listen(self.on_quit))
imp.IMP().add_delegate(events.WindowResizedEvent().listen(
self.on_resize))
imp.IMP().add_delegate(
events.KeyDownEvent(pygame.K_ESCAPE).listen(self.on_pause))
imp.IMP().add_delegate(
events.UserEvent(CustomEvent.GAME_OVER).listen(self.on_game_over))
imp.IMP().add_delegate(
events.UserEvent(CustomEvent.UNDO_STACK_CLEARED).listen(
self.on_redo_undo_changed))
imp.IMP().add_delegate(
events.UserEvent(CustomEvent.REDO_STACK_CLEARED).listen(
self.on_redo_undo_changed))
imp.IMP().add_delegate(
events.UserEvent(CustomEvent.UNDO_ENABLED).listen(
self.on_redo_undo_changed))
imp.IMP().add_delegate(
events.UserEvent(CustomEvent.REDO_ENABLED).listen(
self.on_redo_undo_changed))
imp.IMP().add_delegate(
events.UserEvent(CustomEvent.UPDATE_SCORE).listen(
self.on_update_score))
def position_controls(w, h):
total_height = -10
for control in controls:
total_height += control.h + 10
left, top = (w // 2, h // 2 - total_height // 2)
for control in controls:
control.set_position((left - control.w // 2, top))
top += control.h + 10
position_controls(*window_size)
def on_refresh(event):
position_controls(*window_size)
def on_resize(event):
global window_size
window_size = (event.w, event.h)
position_controls(*window_size)
imp.IMP().add_listener(
events.UserEvent(CustomEvent.SLIDER_TICK).create(
lambda event: slider_value.set_counter(event.value)))
imp.IMP().add_listener(
events.UserEvent(CustomEvent.REFRESH_UI).create(on_refresh))
imp.IMP().add_listener(events.WindowResizedEvent().create(on_resize))
unit_test.register(controls)
unit_test.run()
def on_checked(self, event):
events.UserEvent(CustomEvent.WINNABLE_HANDS).post(
winnable_hands=self.check_box.is_checked)
def pause(self):
events.UserEvent(CustomEvent.PAUSE).post()
self.is_paused = not self.is_paused
self.pause_text.set_visibility(self.is_paused)
if not self.is_paused:
self.previous = time.time()
def wire_events(self):
imp.IMP().add_delegate(events.WindowResizedEvent().listen(
self.on_resize))
imp.IMP().add_delegate(
events.UserEvent(CustomEvent.REFRESH_SIDEBAR).listen(
self.on_refresh_sidebar))
def post_sidebar_refresh(self):
events.UserEvent(CustomEvent.REFRESH_SIDEBAR).post()
def redo(self):
if any(self.redo_stack):
redo_action = self.redo_stack.pop()
redo_action.redo()
self.undo_stack.append(redo_action)
events.UserEvent(CustomEvent.UNDO_ENABLED).post()
def undo(self):
if any(self.undo_stack):
undo_action = self.undo_stack.pop()
undo_action.undo()
self.redo_stack.append(undo_action)
events.UserEvent(CustomEvent.REDO_ENABLED).post()
def post(self, action):
self.redo_stack.clear()
self.undo_stack.append(action)
events.UserEvent(CustomEvent.REDO_STACK_CLEARED).post()
events.UserEvent(CustomEvent.UNDO_ENABLED).post()
def clear(self):
self.redo_stack.clear()
self.undo_stack.clear()
events.UserEvent(CustomEvent.REDO_STACK_CLEARED).post()
events.UserEvent(CustomEvent.UNDO_STACK_CLEARED).post()
def set_text(self, btn_txt):
self.btn_txt.set_text(btn_txt)
self.set_size(self.get_size())
events.UserEvent(CustomEvent.REFRESH_UI).post(sender=self)
def post_score_update(self, index):
if index in FoundationTile.INDEXES:
events.UserEvent(CustomEvent.UPDATE_SCORE).post(inc=10)
else:
events.UserEvent(CustomEvent.UPDATE_SCORE).post(inc=-5)
def post_tick_event(self):
self.tick_value = self.slider.x - self.bar.left
events.UserEvent(CustomEvent.SLIDER_TICK).post(
value=round(self.tick_value / self.tick_length))
def post_refresh(self):
events.UserEvent(CustomEvent.REFRESH_UI).post(sender=self)
def set_text(self, text):
self.lbl_text.set_text(text)
self.set_size(tuple(x + 10 for x in self.lbl_text.size))
events.UserEvent(CustomEvent.REFRESH_UI).post(sender=self)
def redo_card_layed(self, source_tile, dest_tile, card):
print('RedoAction> {} -> {} -> {}'.format(source_tile.index, card,
dest_tile))
events.UserEvent(CustomEvent.UPDATE_SCORE).post(inc=-1)
source_tile.remove(card)
dest_tile.lay(card)
def reset(self, event):
imp.IMP().actions.clear()
for tile in self.card_tiles:
tile.reset()
events.UserEvent(event).post(tiles=self.find_all(),
deck_tile=self.find(DeckTile.INDEX))
