def set_hearts(self, num): if 0 < num <= self.max_hp: if self.hp - 1 == num: event.post(event.Event(53, {})) self.hp = num self.heart_sprites.empty() for i in range(self.max_hp): spr = sprite.Sprite() if i < self.hp: spr.image = self.heart else: spr.image = self.heart_pass spr.image.set_colorkey((255, 255, 255)) spr.rect = spr.image.get_rect() spr.rect.center = (int(self.rect_size * 1.5) * (i + 1), self.rect_size) self.heart_sprites.add(spr) elif num <= 0: self.hp = num self.heart_sprites.empty() for i in range(self.max_hp): spr = sprite.Sprite() if i < self.hp: spr.image = self.heart else: spr.image = self.heart_pass spr.image.set_colorkey((255, 255, 255)) spr.rect = spr.image.get_rect() spr.rect.center = (int(self.rect_size * 1.5) * (i + 1), self.rect_size) self.heart_sprites.add(spr) event.post(event.Event(31, {}))
def get_damage(self): if not self.invulnerable: event.post(event.Event(50, {})) self.hp = self.hp - 1 self.invulnerable = True else: event.post(event.Event(51, {}))
def process(l, e): global _FOCUSED def find_new_over(l): for i in l: try: if i.collidepoint(_Pos.topleft): try: if i.MASK.get_at(_Pos.move(-i.left, -i.top).topleft): return i else: return None except: return i except: i = find_new_over(i[::-1]) if i: return i return None if e.type == MOUSEMOTION: _Pos.topleft = e.pos elif e.type in (KEYDOWN, KEYUP) and hasattr(_FOCUSED, 'wakeup'): _FOCUSED.wakeup(e) if e.type not in (KEYDOWN, KEYUP) and hasattr(l._Last_over, 'wakeup'): l._Last_over.wakeup(e) if not l._Last_over or not l._Last_over.collidepoint(_Pos.topleft): if hasattr(l._Last_over, 'wakeup'): l._Last_over.wakeup(event.Event(MOUSEOVER, {'over': 0})) l._Last_over = find_new_over(l[::-1]) if hasattr(l._Last_over, 'wakeup'): l._Last_over.wakeup(event.Event(MOUSEOVER, {'over': 1})) '''
def participant_change_cb(self, added, removed): log.debug('participant_change_cb: %s %s', added, removed) def nick(buddy): if buddy is not None: return buddy.props.nick else: return 'Unknown' for handle, bus_name in added: dbus_handle = self.tube.participants[handle] self.ordered_bus_names.append(dbus_handle) eventwrap.post(PEvent.Event(PARTICIPANT_ADD, handle=dbus_handle)) for handle in removed: dbus_handle = self.tube.participants[handle] self.ordered_bus_names.remove(dbus_handle) eventwrap.post(PEvent.Event(PARTICIPANT_REMOVE, handle=dbus_handle)) if self.is_initiator: if not self.entered: # Initiator will broadcast a new ordered_bus_names each time # a participant joins. self.ordered_bus_names = [self.tube.get_unique_name()] self.NewParticipants(self.ordered_bus_names) self.entered = True
def check_died(self, scene): """ Check whether this enemy has died. """ if self.hp <= 0: scene.enemyGroup.remove(self) event.post(event.Event(USEREVENT, code=CAESARDEAD))
def click_item(self, n, e): if n < len(self.rows): for sub in self.rows[n].subwidgets: if sub: x = e.local[0] - self.margin - self.rows[ n].rect.left - self.rows[ n].margin - self.scrollRow.cell_rect( n, 0).left - sub.rect.left y = e.local[1] - self.margin - self.rows[ n].rect.top - self.rows[ n].margin - self.scrollRow.cell_rect( n, 0).top - sub.rect.top if sub.left <= x <= sub.right: _e = event.Event( e.type, { 'alt': e.alt, 'meta': e.meta, 'ctrl': e.ctrl, 'shift': e.shift, 'button': e.button, 'cmd': e.cmd, 'num_clicks': e.num_clicks, 'local': (x, y), 'pos': e.local }) self.focus_on(sub) if self.selected: self.selected.is_modal = False sub.is_modal = True sub.mouse_down(_e) self.selected = sub break
def launch(self): ev = event.Event(constants.THORPY_EVENT, id=constants.EVENT_LAUNCH, launcher=self) event.post(ev) self.prelaunch() self.add_to_current_menu()
def drop(self, borderLineHeight): # TODO add a fast drop function... if self.stuck: return vector = Vector(0, BLOCK_SIZE) for polygon in self.polygons: polygon.move(vector) self.rotationPoint += vector # TODO find a better solution to this. we cant use infinity linePoints = [(-100, borderLineHeight), (10000, borderLineHeight)] for polygon in self.polygons: for point in polygon.points: pVec = Vector(*point) lVec = Vector(0, borderLineHeight) delta = pVec - lVec if abs(delta.posY) == 0: self.stuck = True # TODO fix unessecery filter otherTetros = list( filter(lambda tetro: tetro != self, self.otherTetrosOnScreen)) print(otherTetros) for otherTetro in otherTetros: if collision.checkCollision(self, otherTetro): self.stuck = True if self.stuck: event.post(event.Event(SPAWN_EVENT))
def _end(self): """ Reset the timer and post self.event to the queue. Called when time reaches self._endTime. """ self.reset() pgevent.post(pgevent.Event(self.event))
def _mousemove(self, widget, event): # From http://www.learningpython.com/2006/07/25/writing-a-custom-widget-using-pygtk/ # if this is a hint, then let's get all the necessary # information, if not it's all we need. if event.is_hint: x, y, state = event.window.get_pointer() else: x = event.x y = event.y state = event.state rel = (x - self.__mouse_pos[0], y - self.__mouse_pos[1]) self.__mouse_pos = (x, y) self.__button_state = [ state & gtk.gdk.BUTTON1_MASK and 1 or 0, state & gtk.gdk.BUTTON2_MASK and 1 or 0, state & gtk.gdk.BUTTON3_MASK and 1 or 0, ] evt = Pevent.Event(pygame.MOUSEMOTION, pos=self.__mouse_pos, rel=rel, buttons=self.__button_state) self._post(evt) return True
def emulate_ok_press(element=None, inserters=None): if inserters: for i in inserters: i.K_RETURN_pressed() e = event.Event(constants.THORPY_EVENT, id=constants.EVENT_DONE, el=element) event.post(e) functions.quit_menu_func()
def _keyevent(self, widget, event, type): key = gtk.gdk.keyval_name(event.keyval) if key is None: # No idea what this key is. return False keycode = None if key in self.key_trans: keycode = self.key_trans[key] elif hasattr(pygame, 'K_' + key.upper()): keycode = getattr(pygame, 'K_' + key.upper()) elif hasattr(pygame, 'K_' + key.lower()): keycode = getattr(pygame, 'K_' + key.lower()) else: print 'Key %s unrecognized' % key if keycode is not None: if type == pygame.KEYDOWN: mod = self._keymods() self.__keystate[keycode] = type == pygame.KEYDOWN if type == pygame.KEYUP: mod = self._keymods() ukey = gtk.gdk.keyval_to_unicode(event.keyval) evt = Pevent.Event(type, key=keycode, unicode=ukey, mod=mod) self._post(evt) return True
def __init__(self, model, target_model, buffer_size=100, learning_rate=.0015, epsilon=.1, gamma=.95, batch_size=4, target_update_iter=400, train_nums=5000, start_learning=10): super().__init__() self.JUMP = event.Event(KEYDOWN, key=K_SPACE) # model self.model = model self.target_model = target_model opt = ko.Adam(learning_rate=learning_rate, clipvalue=10.0) self.model.compile(optimizer=opt, loss='mse') # parameters self.lr = learning_rate # learning step self.epsilon = epsilon # e-greedy when exploring self.gamma = gamma # discount rate self.batch_size = batch_size # batch_size self.target_update_iter = target_update_iter # target network update period self.train_nums = train_nums # total training steps self.num_in_buffer = 0 # transition's num in buffer self.buffer_size = buffer_size # replay buffer size self.start_learning = start_learning # step to begin learning(no update before that step) # replay buffer params [(s, a, r, ns, done), ...] self.obs = np.empty((self.buffer_size,) + self.state.shape) self.actions = np.empty((self.buffer_size), dtype=np.int8) self.rewards = np.empty((self.buffer_size), dtype=np.float32) self.dones = np.empty((self.buffer_size), dtype=np.bool) self.next_states = np.empty((self.buffer_size,) + self.state.shape) self.next_idx = 0
def generate_events(self): prev = set(self.pressed) curr = set(self.get_buttons_pressed()) if prev != curr: for button_down in curr.difference(prev): self.events.append( event.Event(CONTROLLERBUTTONDOWN, button=button_down, controller=self.controller.get_id())) for button_up in prev.difference(curr): self.events.append( event.Event(CONTROLLERBUTTONUP, button=button_up, controller=self.controller.get_id())) self.pressed = list(curr)
def pressKey(self, newEvent, controller): # Quit everything if (newEvent.key == gc.USER_KEYS_DES.get('ESCAPE', None)): event.post(event.Event(pgc.QUIT)) # Send a move event to an attached NTController elif ('HAT_' in gc.USER_KEYS_NUM.get(newEvent.key, None)): controller.modHat(gc.CONTR_BINDS.get(newEvent.key, None), 1.0)
def clicked(self, mouse_event): if self.rect.collidepoint(mouse_event.pos): event.post( event.Event(self.event, { "name": self.name, "command": "push", "scene": self.next_scene }))
def __init__(self): self.subscribers = [] self.conditions = [] self.last_event = None self.custom_event_conditions = [ (lambda subscriber: subscriber.rect.collidepoint(mouse.get_pos()), event.Event(MOUSE_OVER)) ]
def _reaction_drag(self, event): if self.current_state_key == constants.STATE_PRESSED: if self.will_be_inside(event.rel[0]): self.dragmove(event.rel[0]) drag_event = pygevent.Event(constants.THORPY_EVENT, name=constants.EVENT_SLIDE, el=self.father) pygevent.post(drag_event)
def shoot(self): if not self.alive(): return if random() < self.shoot_chance: event.post(event.Event(CUSTOM_EVENTS['ADD_ALIEN_BULLET'], { 'particle': self.get_bullet() }))
def post_note(self, attributes): for _ in range(5): try: pygame.fastevent.post ( event.Event( PITCH_DETECT, **attributes) ) break except Exception, e: pass
def test_post__clear(self): """Ensure posted events can be cleared.""" for _ in range(10): fastevent.post(event.Event(pygame.USEREVENT)) event.clear() self.assertListEqual(fastevent.get(), []) self.assertListEqual(event.get(), [])
def unlaunch(self, what=None): if what is None: what = self.launched ev = event.Event(constants.THORPY_EVENT, id=constants.EVENT_UNLAUNCH, launcher=self, what=what) event.post(ev) ## print(ev, "posted") self.remove_from_current_menu() self.postlaunch()
def update(self): # Update ball position self.posX += self.direction[0] * self.speed self.posY += self.direction[1] * self.speed self.rect.x = round(self.posX) self.rect.y = round(self.posY) # Check for collision with players if self.rect.x < 400: playerX = self.player1.rect.x + 32 playerY = self.player1.rect.y #playerW = self.player1.rect.w playerH = self.player1.rect.h if self.posX - playerX <= 0 and self.rect.y >= playerY - 32 - 16 and self.rect.y + 32 <= playerY + playerH + 32: bounceAngle = ((playerY + (playerH / 2) - self.posY - (self.rect.h / 2)) / 64) * (pi / 2) * -1 self.direction = (-1 * self.direction[0], sin(bounceAngle)) self.posX = playerX else: playerX = self.player2.rect.x - 32 playerY = self.player2.rect.y #playerW = self.player2.rect.w playerH = self.player2.rect.h if self.posX - playerX >= 0 and self.rect.y >= playerY - 32 - 16 and self.rect.y + 32 <= playerY + playerH + 32: bounceAngle = ((playerY + (playerH / 2) - self.posY - (self.rect.h / 2)) / 64) * (pi / 2) * -1 self.direction = (-1 * self.direction[0], sin(bounceAngle)) self.posX = playerX # Check for "goals" if self.rect.x < self.leftZone: event.post(event.Event(USEREVENT, id="p1Lose")) elif self.rect.x > self.rightZone: event.post(event.Event(USEREVENT, id="p2Lose")) # Bounce on edges of play area if self.posY <= 1: self.posY = 1 self.direction = (self.direction[0], -1 * self.direction[1]) elif self.posY >= 600 - self.rect.h - 1: self.posY = 600 - self.rect.h - 1 self.direction = (self.direction[0], -1 * self.direction[1])
def _treat_midi_event(self, midi_event): # Treatment of MIDI message based on message type and associated values # Most of the time, it ends up firing a pygame event that will be treated in application main loop msg_type = self._get_msg_type(midi_event[0][0]) msg_action = midi_event[0][1] msg_value = midi_event[0][2] if msg_type == self._PGM_CHG: self._bank = msg_action pygame_event = event.Event(LPD8_Events.LPD8_PGM_CHG, { 'pgm': self._program, 'bank': msg_action }) event.post(pygame_event) elif msg_type == self._NOTE_ON: pygame_event = event.Event( LPD8_Events.LPD8_NOTE_ON, { 'pgm': self._program, 'bank': self._bank, 'note': msg_action, 'velocity': msg_value }) event.post(pygame_event) elif msg_type == self._NOTE_OFF: pygame_event = event.Event(LPD8_Events.LPD8_NOTE_OFF, { 'pgm': self._program, 'bank': self._bank, 'note': msg_action }) event.post(pygame_event) elif msg_type >= self._CTRL: msg_value = self._ctrl_knob_array.set_value( self._program, self._bank, msg_action, msg_value) if msg_value == -1: pass else: pygame_event = event.Event( LPD8_Events.LPD8_CTRL, { 'pgm': self._program, 'bank': self._bank, 'ctrl': msg_action, 'value': msg_value }) event.post(pygame_event)
def mouse_down(self, e): if e.button == 3: _e = event.Event(e.type, {'alt': e.alt, 'meta': e.meta, 'ctrl': e.ctrl, 'shift': e.shift, 'button': 1, 'cmd': e.cmd, 'local': e.local, 'pos': e.pos, 'num_clicks': e.num_clicks}) ScrollRow.mouse_down(self, _e) self.parent.show_menu(e.local) else: ScrollRow.mouse_down(self, e)
def get_input(): while True: command = input("--> ") result = parse_input(command[1:]) if (result == None): print("Invalid command") continue to_post = event.Event(result[0], result[1]) print(to_post) event.post(to_post)
def participant_change_cb(self, added, removed): log.debug('participant_change_cb: %s %s', added, removed) for handle, bus_name in added: dbus_handle = self.tube.participants[handle] self.ordered_bus_names.append(dbus_handle) PEvent.post(PEvent.Event(PARTICIPANT_ADD, handle=dbus_handle)) for handle in removed: dbus_handle = self.tube.participants[handle] self.ordered_bus_names.remove(dbus_handle) PEvent.post(PEvent.Event(PARTICIPANT_REMOVE, handle=dbus_handle)) if self.is_initiator: if not self.entered: # Initiator will broadcast a new ordered_bus_names each time # a participant joins. self.ordered_bus_names = [self.tube.get_unique_name()] self.NewParticipants(self.ordered_bus_names) self.entered = True
def update(self, key): if key[K_LEFT]: self.move((-1, 0)) elif key[K_RIGHT]: self.move((1, 0)) elif key[K_SPACE]: gun = PlayerBullet((self.rect.centerx, self.rect.y - 30)) event.post( event.Event(CUSTOM_EVENTS['ADD_PLAYER_BULLET'], {'particle': gun}))
def test_get(self): # __doc__ (as of 2008-08-02) for pygame.fastevent.get: # pygame.fastevent.get() -> list of Events # get all events from the queue for _ in range(1, 11): event.post(event.Event(pygame.USEREVENT)) self.assertEquals([e.type for e in fastevent.get()], [pygame.USEREVENT] * 10, race_condition_notification)
def kill(self, drop=True): super().kill() if drop: gun = BonusBullet((self.rect.centerx, self.rect.centery)) event.post( event.Event(CUSTOM_EVENTS['ADD_BONUS_BULLET'], {'particle': gun})) pass time.set_timer(CUSTOM_EVENTS['ADD_BONUS'], randint(10000, 15000))