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 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 __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 __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_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 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 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.")
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.")
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.")
def sendNetMsg(self, feature, event, *args):
try:
data = self.__protocol.createMsg(feature, event, *args)
except ProtocolException, err:
log.error(err)
return
