def notify(self, event):
if isinstance(event, TickEvent):
#Handle Input Events
for event in pygame.event.get():
ev = None
if event.type == QUIT:
ev = QuitEvent()
elif event.type == KEYDOWN \
and event.key == K_ESCAPE:
ev = QuitEvent()
elif event.type == KEYDOWN \
and event.key == K_UP:
direction = DIRECTION_UP
ev = CharactorMoveRequest(direction)
elif event.type == KEYDOWN \
and event.key == K_DOWN:
direction = DIRECTION_DOWN
ev = CharactorMoveRequest(direction)
elif event.type == KEYDOWN \
and event.key == K_LEFT:
direction = DIRECTION_LEFT
ev = CharactorMoveRequest(direction)
elif event.type == KEYDOWN \
and event.key == K_RIGHT:
direction = DIRECTION_RIGHT
ev = CharactorMoveRequest(direction)
elif event.type == KEYDOWN \
and event.key == K_RETURN:
ev = GameStartRequest()
if ev:
self.ev_manager.post(ev)
def end(self):
"""
Sends quit event to both queues and waits for them to run their course.
"""
self.rxq.put(QuitEvent())
self.txq.put(QuitEvent())
self.end_safely(self.broker_p)
self.end_safely(self.irc_p)
for input in self.inputs:
input.terminate()
def animate(self, delta):
"""Computes new state of the game."""
for minion in self.minions[:]:
minion.animate(delta)
#if minion.reached_end:
#self.minions.remove(minion)
#self.lives -= 1
for tower in self.towers:
tower.animate(delta)
for bullet in self.bullets:
bullet.animate(delta)
self.check_for_finished_minions()
self.collision_detection()
for tower in self.towers:
bullet = tower.shoot(self.minions)
if bullet != None:
self.bullets.append(bullet)
self.current_level.update(delta)
if self.current_level.sent_next_wave:
self.current_level.sent_next_wave = False
self.evm.Post(WaveChangeEvent())
for wave in self.current_level.active_waves[:]:
if wave.new_minion:
wave.new_minion = False
wave.nr_minion -= 1
self.add_minion(wave.hp_minion)
self.evm.Post(WaveChangeEvent())
if wave.nr_minion == 0:
self.current_level.active_waves.remove(wave)
if self.lives <= 0:
self.evm.Post(QuitEvent())
if not self.minions and not self.current_level.active_waves and not self.current_level.next_wave:
self.evm.Post(QuitEvent())
def notify(self, event):
if isinstance(event, TickEvent):
ev = None
for event in pygame.event.get(): #va de cajon
if event.type == QUIT:
ev = QuitEvent()
elif event.type == KEYDOWN \
and event.key == K_ESCAPE:
ev = QuitEvent()
elif event.type == KEYDOWN \
and event.key == K_RETURN:
ev = GameStartRequest()
########################################################
if event.type == KEYDOWN:
if event.key in self.available_keys \
and event.key not in self.keys_pressed:
self.keys_pressed.insert(0, event.key)
elif event.type == KEYUP:
if event.key in self.available_keys:
index = self.keys_pressed.index(event.key)
del (self.keys_pressed[index])
########################################################
if not ev and self.keys_pressed:
key = self.keys_pressed[0]
direction = None
if key == K_UP:
direction = DIRECTION_UP
elif key == K_DOWN:
direction = DIRECTION_DOWN
elif key == K_LEFT:
direction = DIRECTION_LEFT
elif key == K_RIGHT:
direction = DIRECTION_RIGHT
ev = CharactorMoveRequest(direction)
if ev:
self.ev_manager.post(ev)
def Notify(self, event):
if isinstance( event, KeyPressEvent ):
if event.key == 'q':
self.evm.Post(QuitEvent())
if event.key == 'a':
self.logic.add_minion()
if event.key == ' ':
self.logic.current_level.send_next_wave()
elif isinstance( event, MouseClickEvent ):
self.logic.add_tower(event.pos.x, event.pos.y)
elif isinstance( event, TickEvent ):
self.evm.Send(ClearScreenEvent())
self.draw_map()
self.draw_minions()
self.draw_towers()
self.draw_bullets()
self.draw_hud()
self.wc.draw_widgets(self.main_window)
if self.logic.current_level.next_wave and len(self.logic.current_level.active_waves) < len(self.wave_windows):
self.wave_windows[len(self.logic.current_level.active_waves)].set_time(self.logic.current_level.next_wave.offset_wave)
elif isinstance( event, WaveChangeEvent ):
wavelist = []
wavelist.extend(self.logic.current_level.active_waves)
if self.logic.current_level.next_wave:
wavelist.append(self.logic.current_level.next_wave)
wavelist.extend(self.logic.current_level.waves)
for i in range(0, min(len(self.wave_windows), len(wavelist))):
wave = wavelist[i]
window = self.wave_windows[i]
window.set_nr(wave.nr_minion)
window.border_bold = False
window.show_time(False)
for i in range(min(len(self.wave_windows), len(wavelist)),len(self.wave_windows)):
self.wave_windows[i].show = False
if self.logic.current_level.next_wave and len(self.logic.current_level.active_waves) < len(self.wave_windows):
self.wave_windows[len(self.logic.current_level.active_waves)].border_bold = True
self.wave_windows[len(self.logic.current_level.active_waves)].show_time(True)
def main():
pygame.init()
pygame.display.set_caption("The 15 Puzzle")
win = pygame.display.set_mode((WIN_WIDTH, WIN_HEIGHT))
clock = pygame.time.Clock()
event_manager = EventManager()
game_board = GameModel()
game_view = GameView(win)
spinner = CPUSpinnerController(event_manager, clock)
game_controller = GameController(game_board, game_view)
event_manager.registerListener(TickEvent(), game_controller)
event_manager.registerListener(QuitEvent(), spinner)
spinner.run()
pygame.quit()
def notify(self, event, event_manager):
if isinstance(event, TickEvent):
# Handle input events
for event in pygame.event.get():
if event.type == pygame.QUIT:
event_manager.post(QuitEvent())
elif event.type == pygame.MOUSEBUTTONUP and event.button == 1:
moves = self.get_viable_moves()
pos = pygame.mouse.get_pos()
if self.view.instructions_btn.collidepoint(pos):
self.view.instructions()
break
for tile in moves:
if tile.box.collidepoint(pos):
self.move(self.model.tiles.index(tile))
break
if self.check_solved():
self.update_best()
else:
keys = pygame.key.get_pressed()
if keys[pygame.K_SPACE]:
self.restart()
self.view.draw(self.model)
pygame.display.update()
def main(lineMax=5000,
logfileName='ircsimul.log',
writeStdOut=False,
realTime=False,
logInitialPopulation=False):
# create character maps for various text processing/writing functions
helpers.makeTransMaps()
# load up markov generator
markovGenerator = markov.MarkovGenerator(sourcefileName, reasonsfileName)
# load channel
channel = Channel(channelName, markovGenerator, initialUserCount)
# open log
fileObjectList = []
fileObjectList.append(open(logfileName, 'wt', encoding='utf8'))
if writeStdOut:
fileObjectList.append(sys.stdout)
log = Log(fileObjectList)
# get current date
date = datetime.datetime.utcnow()
daycache = date.day
# create queue
queue = PriorityQueue()
# write opening of log
log.writeLogOpening(date)
# populates channel with initialPopulation users
if logInitialPopulation:
for i in range(0, initialPopulation):
event = JoinEvent(date, channel.selectOfflineUser(), channel)
queue.put(event)
else:
for i in range(0, initialPopulation):
channel.setOnline(channel.selectOfflineUser())
# bulk of messages
currentEvent = None
while True:
if not lineMax == -1:
if log.totalLines >= lineMax - 1:
break
# empty queue
try:
while not queue.empty():
currentEvent = queue.get()
if currentEvent:
line = currentEvent.process()
if line:
now = datetime.datetime.utcnow()
if realTime and (currentEvent.date > now):
delta = currentEvent.date - datetime.datetime.utcnow(
)
print(str(delta.total_seconds()))
time.sleep(delta.total_seconds())
log.write(line)
log.flush()
else:
log.write(line)
else:
break
except Empty:
pass
# check if day changed, if so, write day changed message
# TODO: make this event based
if daycache != date.day:
log.writeDayChange(date)
daycache = date.day
# generate line
determineType = random()
if determineType > joinPartProbability:
# user message
user = channel.selectOnlineUser()
event = MessageEvent(
date, user, flavourText(markovGenerator.generateMessage(),
user))
elif determineType > actionProbability:
# random join/part event
user = channel.selectUser()
if user in channel.online:
if random() < quitProbability:
event = QuitEvent(date, user,
markovGenerator.generateReason(),
channel)
else:
event = LeaveEvent(date, user,
markovGenerator.generateReason(),
channel)
else:
event = JoinEvent(date, user, channel)
elif determineType > kickProbability:
# user action
# TODO: implement variable user action text
event = UserActionEvent(date, channel.selectOnlineUser(),
"does action")
else:
# kick event
event = KickEvent(date, channel.selectOnlineUser(),
channel.selectOnlineUser(),
markovGenerator.generateReason(), channel)
queue.put(event)
# makes sure some amount of peeps are online or offline
# TODO: check if population checks could be made obsolete by having the next join/parts already cached
# TODO: move to channel class later?
if channel.onlineUsers < minOnline:
event = JoinEvent(date, channel.selectOfflineUser(), channel)
queue.put(event)
if (channel.userCount - channel.onlineUsers) < minOffline:
if random() < quitProbability:
event = QuitEvent(date, user, markovGenerator.generateReason(),
channel)
else:
event = LeaveEvent(date, user,
markovGenerator.generateReason(), channel)
queue.put(event)
# TODO: is += possible here?
date = date + datetime.timedelta(seconds=choice(timeSpan) *
(sin((date.hour) / 24 * pi) + 1.5))
# write log closing message
log.writeLogClosing(date)
# close log file
log.lfs[0].close()