Example #1
0
    def __init__(self, baseConfig, pInBoundQueue, pOutBoundQueue,
                 loggingQueue):
        """ Initialize new CamCollectionPoint instance.
        Setup queues, variables, configs, constants and loggers.
        """
        super(BtleCollectionPoint, self).__init__()
        # Queues
        self.outQueue = pOutBoundQueue  #messages from this thread to the main process
        self.inQueue = pInBoundQueue
        self.loggingQueue = loggingQueue
        self.queueBLE = mp.Queue()
        # Configs
        self.moduleConfig = configLoader.load(
            self.loggingQueue)  #Get the config for this module
        self.config = baseConfig

        # Logger
        self.logger = ThreadsafeLogger(loggingQueue, __name__)
        # Variables
        self.registeredClientRegistry = RegisteredClientRegistry(
            self.moduleConfig, self.loggingQueue)
        self.eventManager = EventManager(self.moduleConfig, pOutBoundQueue,
                                         self.registeredClientRegistry,
                                         self.loggingQueue)
        self.alive = True
        self.btleThread = None
        self.BLEThread = None
        self.repeatTimerSweepClients = None
Example #2
0
 def __init__(self):
     GPIO.setmode(GPIO.BCM)
     GPIO.setwarnings(False)
     self.beeper = Beeper(pins)
     self.errorBeeper = Beeper(pins)
     self.sensorReader = Sensor(pins["photoresistor"], pins["tandu"])
     self.readingLock = False
     evm = EventManager(pins["button"])
     evm.registerButtonListener(self.onButtonPress)
     self.running = True
     self.saver = Saver()
Example #3
0
	def eventsContext(agentMessage):
		'''
		Контекст пакета запроса событий
		'''
		context = {}
		context['type'] = 'events'
		context['events'] = EventManager.getEvents(agentMessage['sessionid'],agentMessage)
		return context
Example #4
0
	def createEventContext(agentMessage):
		'''
		Контекст пакета создания событий
		'''
		context = {}
		context['type'] = 'eventcreate'
		context['result'] = EventManager.createEvent(agentMessage['sessionid'],agentMessage)
		return context
Example #5
0
	def deleteEventContext(agentMessage):
		'''
		Контекст пакета удаления событий
		'''
		context = {}
		context['type'] = 'eventdelete'
		context['result'] = EventManager.deleteEvent(agentMessage['sessionid'],agentMessage['eventid'])
		return context
Example #6
0
def main():
    q = Queue(1)
    pandaScene = PandaScene()
    sceneGraphManager = SceneGraphManager(pandaScene)
    eventManager = EventManager(sceneGraphManager)
    gui = GuiThread(q, eventManager)
    gui.start()
    pandaScene.run()
Example #7
0
	def modifyEventContext(agentMessage):
		'''
		Контекст пакета изменения событий
		'''
		context = {}
		context['type'] = 'eventmodify'
		context['result'] = EventManager.modifyEvent(agentMessage['sessionid'],agentMessage['eventid'],agentMessage)
		return context
Example #8
0
def main():
    Settings.init()
    print('Settings file: "{}"'.format(Settings.fileName()))
    q = Queue(1)
    pandaScene = PandaScene()
    sceneGraphManager = SceneGraphManager(pandaScene)
    eventManager = EventManager(sceneGraphManager)
    gui = GuiThread(q, eventManager)
    gui.start()
    pandaScene.run()
Example #9
0
	def gameWindow(self):

		pygame.init()

		# Window
		self.fpsClock = pygame.time.Clock()
		window = pygame.display.set_mode((WINDOW_WIDTH, WINDOW_HEIGHT))
		pygame.display.set_caption(WINDOW_TITLE)
		pygame.key.set_repeat()
		self.mainBoard = MainBoard(window)
		self.evtMgr = EventManager()
Example #10
0
class DIM:
    def __init__(self, host, port):
        # sageGate is the network connection with SAGE
        self.sageGate = SageGate()
        setSageGate(self.sageGate)

        # the event manager takes care of properly dispatching events
        self.evtMgr = EventManager()
        setEvtMgr(self.evtMgr)
        self.evtMgr.addHandlers()

        # sageData keeps the current state of the SAGE windows/apps
        self.sageData = SageData()
        setSageData(self.sageData)
        
        # overlay manager creates, destroys and updates overlays
        self.overlayMgr = OverlayManager()
        setOverlayMgr(self.overlayMgr)

        # contains all the devices and takes care of loading plugins for them
        # also, distributes HW messages to each device 
        self.devMgr = DeviceManager()
        setDevMgr(self.devMgr)

        # connect to SAGE
        for i in range(5):  # try to connect to SAGE for 5 seconds
            if self.sageGate.connectToSage(host, port) != 0:
                self.sageGate.registerSage()
                break
            time.sleep(1)
        else:  # we didn't manage to connect to sage in 5 seconds... so quit
            exitApp()

        # start listening for the device events
        time.sleep(2)   # wait till all the messages come in
        self.listener = Listener(LISTENER_PORT, self.devMgr.onHWMessage)
        self.listener.serve_forever()
Example #11
0
    def mainloop(self):
        while True:
            dt = self.clock.tick(self.FPS)

            quitter = EventManager.update(self)
            if quitter:
                return

            if not self.story_manager.blocking:
                self.userInput.updateKey(dt)

            for key, value in self.clocks.iteritems():
                if value >= 0:
                    if value == 0:
                        if key == "playerHud":
                            self.hideHud(key)
                            pass
                    else:
                        self.clocks[key] = value - 1

            #Récupère les collisions
            self.collision_manager.tmx_stackCollisionEvents()

            #stack les collision de monstre
            self.collision_manager.player_stackEvents()

            self.collision_manager.monster_stackEvents()

            #gère les évenement crée par le joureur
            self.collision_manager.player_manageCollisionEvents()

            #Gère les colisions selon leur nature
            self.collision_manager.tmx_manageCollisionEvents()

            self.collision_manager.monster_manageCollisionEvents()

            if self.perso.alive():
                self.layer_manager.update(self.story_manager.blocking)
            else:
                self.story_manager.display_speech(["GAME OVER"], "bottom")
                self.story_manager.set_unblockable(False)

            self.layer_manager.draw()

            pygame.display.update()
Example #12
0
 def move_left(self):
     self.actor.move(self.coord_left[0], self.coord_left[1], "left")
     EventManager.envois_event(EventEnum.MOVE, 'left')
Example #13
0
class Grymark:

	def __init__(self, playerNames, mode, directory):
		self.directory = directory
		self.gameWindow()
		Counter.FRAME_CNT = 0

		self.mainLoop(playerNames, mode)


	def gameWindow(self):

		pygame.init()

		# Window
		self.fpsClock = pygame.time.Clock()
		window = pygame.display.set_mode((WINDOW_WIDTH, WINDOW_HEIGHT))
		pygame.display.set_caption(WINDOW_TITLE)
		pygame.key.set_repeat()
		self.mainBoard = MainBoard(window)
		self.evtMgr = EventManager()


	def mainLoop(self, playerNames, mode):

		retry = True

		# First game or continue
		while retry:
			# Set game mode
			gm = GameModeManager(self.mainBoard, playerNames, mode, self.directory)

			# TODO animation before beginning

			gameOver = False
			# Game loop
			while not gameOver:
				
				Counter.FRAME_CNT += 1

				# Event handling loop
				self.evtMgr.update()
				if self.evtMgr.quitEvent or self.evtMgr.escapePressed:
					pygame.quit()
					sys.exit()

				# Update game
				gameOver, retry = gm.update(self.evtMgr)

				# Update view
				gm.gs.draw()
				pygame.display.update()
				
				self.fpsClock.tick(FPS)

		#pygame.quit()
		#sys.exit()


#game = Grymark('Isoscorp, Izuviel, Protois, Kasbari', GAME_MODE['SINGLE_ADVENTURE'])
### TODO-LIST ###
# DONE - Game Over (display and ask Try Again/Quit)
# DONE - Level loading from file
# Remove dead code and use methods to match impedance
# DONE - Detecting end of level and switching levels
# Sound effects
# Improved score calculation (bonus factor for one paddle hit multiple collisions, bonus factor for long series without dying, "perfect", Trackmania-style time tiers)
# DONE - Various strengths of bricks (multiple hits to destroy)
# Special effect bricks (bonus points, fast bounce, indestructible)
# Allow N paddles M balls (in GameState and CollisionHandler)
# Falling usable objects
# Networked p2p multiplayer mode
################
Example #14
0
 def move_up(self):
     self.actor.move(self.coord_up[0], self.coord_up[1], "up")
     EventManager.envois_event(EventEnum.MOVE, "up")
Example #15
0
class BtleCollectionPoint(Thread):
    def __init__(self, baseConfig, pInBoundQueue, pOutBoundQueue,
                 loggingQueue):
        """ Initialize new CamCollectionPoint instance.
        Setup queues, variables, configs, constants and loggers.
        """
        super(BtleCollectionPoint, self).__init__()
        # Queues
        self.outQueue = pOutBoundQueue  #messages from this thread to the main process
        self.inQueue = pInBoundQueue
        self.loggingQueue = loggingQueue
        self.queueBLE = mp.Queue()
        # Configs
        self.moduleConfig = configLoader.load(
            self.loggingQueue)  #Get the config for this module
        self.config = baseConfig

        # Logger
        self.logger = ThreadsafeLogger(loggingQueue, __name__)
        # Variables
        self.registeredClientRegistry = RegisteredClientRegistry(
            self.moduleConfig, self.loggingQueue)
        self.eventManager = EventManager(self.moduleConfig, pOutBoundQueue,
                                         self.registeredClientRegistry,
                                         self.loggingQueue)
        self.alive = True
        self.btleThread = None
        self.BLEThread = None
        self.repeatTimerSweepClients = None

    # main start method
    def run(self):
        ###Pausing Startup to wait for things to start after a system restart
        self.logger.info(
            "Pausing execution 15 seconds waiting for other system services to start"
        )
        time.sleep(15)
        self.logger.info(
            "Done with our nap.  Time to start looking for clients")

        #########  setup global client registry start #########
        # self.registeredClientRegistry = RegisteredClientRegistry(self.moduleConfig, self.loggingQueue)
        #########  setup global client registry end #########
        self.logger.info('here 1')
        self.btleThread = BlueGigaBtleCollectionPointThread(
            self.queueBLE, self.moduleConfig, self.loggingQueue)
        self.BLEThread = Thread(target=self.btleThread.bleDetect,
                                args=(__name__, 10))
        self.BLEThread.daemon = True
        self.BLEThread.start()
        self.logger.info('here 2')

        #Setup repeat task to run the sweep every X interval
        self.repeatTimerSweepClients = RepeatedTimer(
            (self.moduleConfig['AbandonedClientCleanupIntervalInMilliseconds']
             / 1000), self.registeredClientRegistry.sweepOldClients)

        # Process queue from main thread for shutdown messages
        self.threadProcessQueue = Thread(target=self.processQueue)
        self.threadProcessQueue.setDaemon(True)
        self.threadProcessQueue.start()
        self.logger.info('here 3')

        #read the queue
        while self.alive:
            if not self.queueBLE.empty():
                self.logger.info(
                    'got a thing here herhehrehfhve!~ ~ ~@~@~!#~ ~ #~ #@@~ ~@# @~#'
                )
                result = self.queueBLE.get(block=False, timeout=1)
                self.__handleBtleClientEvents(result)

    def processQueue(self):
        self.logger.info(
            "Starting to watch collection point inbound message queue")
        while self.alive:
            if not self.inQueue.empty():
                self.logger.info("Queue size is %s" % self.inQueue.qsize())
                try:
                    message = self.inQueue.get(block=False, timeout=1)
                    if message is not None:
                        if message == "SHUTDOWN":
                            self.logger.info("SHUTDOWN command handled on %s" %
                                             __name__)
                            self.shutdown()
                        else:
                            self.sendOutMessage(message)
                except Exception as e:
                    self.logger.error("Unable to read queue, error: %s " % e)
                    self.shutdown()
                self.logger.info("Queue size is %s after" %
                                 self.inQueue.qsize())
            else:
                time.sleep(.25)

    #handle btle reads
    def __handleBtleClientEvents(self, detectedClients):
        self.logger.debug("doing handleBtleClientEvents: %s" % detectedClients)
        for client in detectedClients:
            self.logger.debug("--- Found client ---")
            self.logger.debug(vars(client))
            self.logger.debug("--- Found client end ---")
            self.eventManager.registerDetectedClient(client)

    def shutdown(self):
        self.logger.info("Shutting down")
        # self.threadProcessQueue.join()
        self.repeatTimerSweepClients.stop()
        self.btleThread.stop()
        self.alive = False
        time.sleep(1)
        self.exit = True
Example #16
0
 def move_down(self):
     self.actor.move(self.coord_down[0], self.coord_down[1], "down")
     EventManager.envois_event(EventEnum.MOVE, "down")
Example #17
0
 def jump(self):
     if self.actor.is_doing == "nothing":
         #self.actor.jump()
         #déclanche un event
         #pygame.time.set_timer(self.actor.actors_actions.event_jump, 40)#1 second is 1000 milliseconds
         EventManager.delay_event(EventEnum.JUMP, 40)
Example #18
0
 def move_right(self):
     self.actor.move(self.coord_right[0], self.coord_right[1], "right")
     EventManager.envois_event(EventEnum.MOVE, "right")
Example #19
0
 def attack(self):
     if self.actor.is_doing == "nothing":
         EventManager.delay_event(EventEnum.ATTACK, 40)
Example #20
0
    return apologies[randint(0, len(apologies) - 1)]


def get_random_rep_request():
    return repeat_requests[randint(0, len(repeat_requests) - 1)]


def color_text(text):
    return bold_text("[color={}]".format(BOT_TEXT_COLOR) + text + "[/color]")


def bold_text(text):
    return "[b]" + text + "[/b]"


event_mgr = EventManager()

Builder.load_string('''
<ScrollableLabel>:
    effect_cls: 'DampedScrollEffect'
    scroll_y: 0
    Label:
        padding: 15, 15
        size_hint_y: None
        height: self.texture_size[1]
        text_size: self.width, None
        text: root.text
        color: {}
        markup: True
'''.format(TEXT_COLOR))
Example #21
-1
    def __init__(self, host, port, loadState, autosave, doLog):
       
        print "\n\n=========   Starting DIM  ============\n"

        # the log object
        if doLog:
            setLog(Log())
            print "Logging user interaction into: ", getLog().getLogFilename(), "\n\n"

        # sageGate is the network connection with SAGE
        self.sageGate = SageGate()
        setSageGate(self.sageGate)

        # the event manager takes care of properly dispatching events
        self.evtMgr = EventManager()
        setEvtMgr(self.evtMgr)
        self.evtMgr.addHandlers()

        # sageData keeps the current state of the SAGE windows/apps
        self.sageData = SageData(autosave, self.sageGate)
        setSageData(self.sageData)
        
        # overlay manager creates, destroys and updates overlays
        self.overlayMgr = OverlayManager()
        setOverlayMgr(self.overlayMgr)

        # contains all the devices and takes care of loading plugins for them
        # also, distributes HW messages to each device 
        self.devMgr = DeviceManager()
        setDevMgr(self.devMgr)

        # connect to SAGE
        if (DEBUG):
            print "\n\nRUNNING IN DEBUG MODE!!!!\n\n"
        else:
            time.sleep(2)
        
        for i in range(20):  # try to connect to SAGE for X seconds
            retval = self.sageGate.connectToSage(host, port)
            if retval == 1:
                self.sageGate.registerSage("dim")
                print "DIM: successfully connected to SAGE", (host, port)
                break
            elif retval == 0:
                print "DIM: SAGE", (host, port), "is not ready yet. Retrying..."
            elif retval == -1:
                print "DIM: Couldn't connect to appLauncher. appLauncher is not ready yet. Retrying..."
            time.sleep(1)
        else:  # we didn't manage to connect to sage in X seconds... so quit
            exitApp()

        # start listening for the device events
        time.sleep(2)   # wait till all the messages come in
        self.overlayMgr._addGlobalOverlays()   # add all the UI plugins for the display

        # automatically load a saved state if so desired
        if loadState:
            print "\n===> Autoloading state: ", loadState, "\n"
            t = Timer(3, self.sageData.loadState, [loadState])
            t.start()
        
        self.listener = Listener(LISTENER_PORT, self.devMgr.onHWMessage)
        self.listener.serve_forever()