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))
