def dispatchEvent(self, event): """ Dispatch a launched event to all affected listeners. @param event: Event launched. @type event: C{L{Event}} """ if event.type in self.listeners: for obj in self.listeners[event.type]: # Try to call event-specific handle method fctname = obj.event_pattern % (event.type) if hasattr(obj, fctname): function = getattr(obj, fctname) if callable(function): function(event) continue # Try to call default handle method if hasattr(obj, obj.event_default): function = getattr(obj, obj.event_default) if callable(function): function(event) continue # No handle method found, raise error ? if not obj.event_silent: raise UnhandledEventError("%s has no method to handle %s" % (obj, event)) else: log.error("Pas de event.type %s" % event.type)
def dispatchEvent(self, event): """ Dispatch a launched event to all affected listeners. @param event: Event launched. @type event: C{L{Event}} """ if event.type in self.listeners: for obj in self.listeners[event.type]: # Try to call event-specific handle method fctname = obj.event_pattern %(event.type) if hasattr(obj, fctname): function = getattr(obj, fctname) if callable(function): function(event) continue # Try to call default handle method if hasattr(obj, obj.event_default): function = getattr(obj, obj.event_default) if callable(function): function(event) continue # No handle method found, raise error ? if not obj.event_silent: raise UnhandledEventError("%s has no method to handle %s" %(obj, event)) else: log.error("Pas de event.type %s" % event.type)
def displayThread(self): """ Thread handler for the "display" part.""" try: self.display.start() except Exception, msg: bt = getBacktrace() log.error("EXCEPTION IN DISPLAY THREAD:\n%s\n%s" % (msg, bt))
def runThread(self, port, max_connection): try: self.__running = True self.start(port, max_connection) except Exception, msg: log.error("EXCEPTION IN TCP SERVER WAITER!\n%s\n%s" \ % (msg, getBacktrace()))
def evt_happyboom_network(self, feature, event, *args): try: if self.debug: log.info("Send event: %s.%s%s" % (feature, event, args)) self.launchEvent("happyboom", "event", (self._io,), feature, event, args) except ProtocolException, msg: log.error("Protocol error: %s" % msg)
def __clientChallenge(self, client, func): try: func(client) except Exception, msg: log.error( \ "EXCEPTION WHEN A CLIENT TRY TO CONNECT :\n%s\n%s" \ % (msg, getBacktrace())) self.stop()
def evt_happyboom_netCreateItem(self, client, item): try: type = item.type type = self.presentation.protocol.getFeature(type) type = type.id except ProtocolException, err: log.error(err) return
def evt_happyboom_network(self, feature, event, *args): try: if self.debug: log.info("Send event: %s.%s%s" % (feature, event, args)) self.launchEvent("happyboom", "event", (self._io, ), feature, event, args) except ProtocolException, msg: log.error("Protocol error: %s" % msg)
def run_io_thread(self): try: while self.__io.isRunning(): self.__io.live() time.sleep(0.001) except Exception, msg: log.error( \ "EXCEPTION IN IO THREAD :\n%s\n%s" \ % (msg, getBacktrace())) self.server.stop()
def run_thread(self): """ Function which should be called in a thread. """ try: while self._running: self.live() time.sleep(self.thread_sleep) except Exception, msg: log.error( \ "EXCEPTION DANS LE THREAD IO :\n%s\n%s" % (msg, getBacktrace()))
def run_curses(stdscr, args): from happyboom.common.log import log from curses_client import Client try: args["window"] = stdscr args["item_path"] = "curses_client/items" stdscr.scrollok(True) run(Client, args) except Exception, err: log.error("Uncatched error in run_curses: %s" % err) raise
def run_thread(self): """ Function which should be called in a thread : call L{live()} with a sleep. """ try: while self.__running: self.live() time.sleep(self.thread_sleep) except Exception, msg: log.error( \ "EXCEPTION IN UDP SERVER:\n%s\n%s" \ % (msg, getBacktrace())) self.stop()
def start(self, port, max_connection): self.__max_clients = max_connection self.__port = port if self.__server.debug: log.info("Start %s on port %u." \ % (self.__server.name, port)) self.__socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) try: self.__socket.bind((self.__host, self.__port)) self.__socket.listen(max_connection) except socket.error, err: if self.__server.debug: log.error("Binding error for %s." % (self.__server.name)) if self.__server.on_binding_error != None: self.__server.on_binding_error(self.__server) return
def onConnectionFails(self): """ Handler called when network connection fails. """ log.error("[HAPPYBOOM] Fail to connect to the server.")
class Client(Happyboom, EventListener): """ The main class of the client of BoomBoom. @ivar display: Display manager of the game. @type display: C{L{BoomBoomDisplay}} @ivar input: Input manager of the game. @type input: C{L{BoomBoomInput}} @ivar __verbose: Verbose mode flag. @type __verbose: C{bool} @ivar __stopped: Stopped game flag. @type __stopped: C{bool} @ivar __stoplock: Mutex for synchronizing __stopped. @type __stoplock: C{thread.lock} """ def __init__(self, args): """ BoomBoomClient constructor. @param host: Server hostname. @type host: C{str} @param display_port: Server port for "display"/"view" connection. @type display_port: C{int} @param input_port: Server port for "input" connection. @type input_port: C{int} @param verbose: Verbose mode flag. @type verbose: C{bool} @param debug: Debug mode flag. @type debug: C{bool} @param max_fps: Maximal number of frames per second, for optimization. @type max_fps: C{int} """ args["protocol"] = protocol.loadProtocol("protocol.xml") args["features"] = ["game"] # Constant features Happyboom.__init__(self, args) EventListener.__init__(self, prefix="evt_") self.display = Display(args) self.input = Input(args) self.__verbose = args.get("verbose", False) self.registerEvent("happyboom") self.registerEvent("game") def start(self): """ Starts the game client.""" if self.__verbose: log.info("[BOOMBOOM] Starting client...") Happyboom.start(self) # Create thread for display thread.start_new_thread(self.displayThread, ()) quit = False while not quit: self.input.process() time.sleep(0.100) quit = self.stopped def stop(self): """ Stops the game client.""" if self.__verbose: log.info("[BOOMBOOM] Stopping client...") Happyboom.stop(self) self.launchEvent("happyboom", "disconnection", self._io, u"Quit.") self.display.stop() def evt_game_stop(self): self.stop() def evt_happyboom_stop(self): """ Stop event handler. """ self.stop() def displayThread(self): """ Thread handler for the "display" part.""" try: self.display.start() except Exception, msg: bt = getBacktrace() log.error("EXCEPTION IN DISPLAY THREAD:\n%s\n%s" % (msg, bt)) try: self.stop() except Exception, msg: bt = getBacktrace() log.error("EXCEPTION (2) IN DISPLAY THREAD:\n%s\n%s" % (msg, bt))
def sendNetMsg(self, feature, event, *args): try: data = self.__protocol.createMsg(feature, event, *args) except ProtocolException, err: log.error(err) return
def pingTimeout(self, id): """ Function called when a ping timeout is raised. @parameter id: The ping id. @type id: C{int} """ log.error("UDP ping timeout.")