def client_run(self):
self.client = Client(self._host)
connected = self.client.conectarse()
print "Cliente Creado:", connected
if connected:
self.client.connect("error", self.__client_error)
return self.__register_client_in_server()
else:
return False
def __run_client(self, _dict):
"""
El Cliente Host, se encarga de configurar el Server con:
mapa, vidas, enemigos,
tanque y nick (propios)
"""
server = str(_dict['server'])
mapa = os.path.basename(str(_dict['mapa']))
tanque = os.path.basename(str(_dict['tanque']))
enemigos = str(_dict['enemigos'])
vidas = str(_dict['vidas'])
nick = str(_dict['nick'])
self.client = Client(server)
connected = self.client.conectarse()
if connected:
_buffer = "Config,%s,%s,%s,%s,%s" % (mapa, enemigos, vidas, tanque,
nick)
self.client.enviar(_buffer)
retorno = self.client.recibir()
if retorno == "OK":
tanque = str(_dict['tanque'])
mapa = str(_dict['mapa'])
new_dict = {
'tanque': tanque,
'nick': nick,
'mapa': mapa,
}
if MAKELOG:
APPEND_LOG({'client': new_dict})
time.sleep(0.5)
self.__run_game(new_dict)
else:
dialog = Dialogo(
parent=self.get_toplevel(),
text="Algo salió mal al Configurar el Servidor.")
dialog.run()
self.salir()
else:
dialog = Dialogo(
parent=self.get_toplevel(),
text="EL Cliente no pudo Conectarse con el Servidor.")
dialog.run()
self.salir()
def __run_client(self, _dict):
"""
El Cliente remoto intenta conectarse al server pasandole:
tanque y nick (propios)
"""
server = str(_dict['server'])
tanque = os.path.basename(str(_dict['tanque']))
nick = str(_dict['nick'])
dirpath = os.path.dirname(os.path.dirname(str(_dict['tanque'])))
self.client = Client(server)
connected = self.client.conectarse()
if connected:
_buffer = "JOIN,%s,%s" % (tanque, nick)
self.client.enviar(_buffer)
retorno = self.client.recibir()
mapa = os.path.join(dirpath, "Mapas", retorno)
tanque = str(_dict['tanque'])
new_dict = {
'tanque': tanque,
'nick': nick,
'mapa': mapa,
}
if MAKELOG:
APPEND_LOG({'client': new_dict})
if retorno == "CLOSE":
dialog = Dialogo(parent=self.get_toplevel(),
text="El Servidor no Admite más Jugadores.")
dialog.run()
self.salir()
else:
time.sleep(0.5)
self.__run_game(new_dict)
else:
dialog = Dialogo(
parent=self.get_toplevel(),
text="EL Cliente no pudo Conectarse con el Servidor.")
dialog.run()
self.salir()
def __client_run(self):
self.client = Client(self._host)
connected = self.client.conectarse()
print "Cliente del Host Creado:", connected
if connected:
self.client.connect("error", self.__client_error)
return self.__register_client_in_server()
else:
return False
def connectToServer(self, instance, ipAddress):
"""
Permet de gérer la connexion au serveur: lancement de la boucle de la
partie client du modèle client-serveur et passage à l'écran de connexion
à l'application
:param instance: L'écran de bienvenue
:type instance: WelcomeScreen
:param ipAddress: L'addresse IP à laquelle se connecter
:type ipAddress: str
:return:
:rtype: None
"""
self.client = Client(ipAddress)
self.client.bind(on_connection_lost=self.handleConnectionLost)
self.client.bind(on_data_received=self.handleDataReceived)
if self.client.isConnected():
thread = Thread(target=self.client.start)
thread.start()
self.initializeScreens()
self.displaySignInScreen()
else:
CustomPopup("Error", "Could not connect to the server").open()
def __run_client(self, _dict):
"""
El Cliente Host, se encarga de configurar el Server con:
mapa, vidas, enemigos,
tanque y nick (propios)
"""
server = str(_dict['server'])
mapa = os.path.basename(str(_dict['mapa']))
tanque = os.path.basename(str(_dict['tanque']))
enemigos = str(_dict['enemigos'])
vidas = str(_dict['vidas'])
nick = str(_dict['nick'])
self.client = Client(server)
connected = self.client.conectarse()
if connected:
_buffer = "Config,%s,%s,%s,%s,%s" % (mapa, enemigos,
vidas, tanque, nick)
self.client.enviar(_buffer)
retorno = self.client.recibir()
if retorno == "OK":
tanque = str(_dict['tanque'])
mapa = str(_dict['mapa'])
new_dict = {
'tanque': tanque,
'nick': nick,
'mapa': mapa,
}
if MAKELOG:
APPEND_LOG({'client': new_dict})
time.sleep(0.5)
self.__run_game(new_dict)
else:
dialog = Dialogo(parent=self.get_toplevel(),
text="Algo salió mal al Configurar el Servidor.")
dialog.run()
self.salir()
else:
dialog = Dialogo(parent=self.get_toplevel(),
text="EL Cliente no pudo Conectarse con el Servidor.")
dialog.run()
self.salir()
def __run_client(self, _dict):
"""
El Cliente remoto intenta conectarse al server pasandole:
tanque y nick (propios)
"""
server = str(_dict['server'])
tanque = os.path.basename(str(_dict['tanque']))
nick = str(_dict['nick'])
dirpath = os.path.dirname(os.path.dirname(str(_dict['tanque'])))
self.client = Client(server)
connected = self.client.conectarse()
if connected:
_buffer = "JOIN,%s,%s" % (tanque, nick)
self.client.enviar(_buffer)
retorno = self.client.recibir()
mapa = os.path.join(dirpath, "Mapas", retorno)
tanque = str(_dict['tanque'])
new_dict = {
'tanque': tanque,
'nick': nick,
'mapa': mapa,
}
if MAKELOG:
APPEND_LOG({'client': new_dict})
if retorno == "CLOSE":
dialog = Dialogo(parent=self.get_toplevel(),
text="El Servidor no Admite más Jugadores.")
dialog.run()
self.salir()
else:
time.sleep(0.5)
self.__run_game(new_dict)
else:
dialog = Dialogo(parent=self.get_toplevel(),
text="EL Cliente no pudo Conectarse con el Servidor.")
dialog.run()
self.salir()
class DrawingWidget(Gtk.DrawingArea):
__gsignals__ = {
"update": (GObject.SIGNAL_RUN_LAST,
GObject.TYPE_NONE, (GObject.TYPE_PYOBJECT, )),
"salir": (GObject.SIGNAL_RUN_LAST,
GObject.TYPE_NONE, [])}
def __init__(self):
Gtk.DrawingArea.__init__(self)
self.client = False
self.juego = False
self.show_all()
self.set_size_request(640, 480)
def __run_client(self, _dict):
"""
El Cliente remoto intenta conectarse al server pasandole:
tanque y nick (propios)
"""
server = str(_dict['server'])
tanque = os.path.basename(str(_dict['tanque']))
nick = str(_dict['nick'])
dirpath = os.path.dirname(os.path.dirname(str(_dict['tanque'])))
self.client = Client(server)
connected = self.client.conectarse()
if connected:
_buffer = "JOIN,%s,%s" % (tanque, nick)
self.client.enviar(_buffer)
retorno = self.client.recibir()
mapa = os.path.join(dirpath, "Mapas", retorno)
tanque = str(_dict['tanque'])
new_dict = {
'tanque': tanque,
'nick': nick,
'mapa': mapa,
}
if MAKELOG:
APPEND_LOG({'client': new_dict})
if retorno == "CLOSE":
dialog = Dialogo(parent=self.get_toplevel(),
text="El Servidor no Admite más Jugadores.")
dialog.run()
self.salir()
else:
time.sleep(0.5)
self.__run_game(new_dict)
else:
dialog = Dialogo(parent=self.get_toplevel(),
text="EL Cliente no pudo Conectarse con el Servidor.")
dialog.run()
self.salir()
def __end_game(self, juego, _dict):
"""
El juego recibe salir desde el server.
"""
dialog = DialogoEndGame(parent=self.get_toplevel(), _dict=_dict)
self.emit('salir')
dialog.run()
dialog.destroy()
def __run_game(self, _dict):
"""
Comienza a correr el Juego.
"""
try:
# FIXME: Agregar Dialogo con explicacion sobre teclas
xid = self.get_property('window').get_xid()
os.putenv('SDL_WINDOWID', str(xid))
self.juego = Juego(dict(_dict), self.client)
self.juego.connect("end", self.__end_game)
self.juego.connect("update", self.__update_players)
self.juego.config()
time.sleep(0.5)
self.juego.run()
except:
dialog = Dialogo(parent=self.get_toplevel(),
text="EL Juego no pudo Iniciar.")
dialog.run()
self.salir()
def __update_players(self, juego, _dict):
self.emit("update", _dict)
def setup_init(self, _dict):
self.__run_client(dict(_dict))
return False
def do_draw(self, context):
"""
Reescalado en gtk, reescala en pygame.
"""
rect = self.get_allocation()
if self.juego:
self.juego.escalar((rect.width, rect.height))
def update_events(self, eventos):
"""
Eventos gtk, se pasan a pygame
"""
if "Escape" in eventos:
self.salir()
else:
if self.juego:
self.juego.update_events(eventos)
def salir(self):
if self.juego:
self.juego.salir("REMOVE,")
time.sleep(0.5)
del(self.juego)
self.juego = False
if self.client:
self.client.desconectarse()
del(self.client)
self.client = False
dialog = Dialogo(parent=self.get_toplevel(),
text="Saliendo del Juego . . .")
dialog.run()
dialog.destroy()
self.emit('salir')
class DrawingWidget(Gtk.DrawingArea):
__gsignals__ = {
"update": (GObject.SIGNAL_RUN_LAST, GObject.TYPE_NONE,
(GObject.TYPE_PYOBJECT, )),
"salir": (GObject.SIGNAL_RUN_LAST, GObject.TYPE_NONE, [])
}
def __init__(self):
Gtk.DrawingArea.__init__(self)
self.server_thread = False
self.client = False
self.server = False
self.juego = False
self.show_all()
self.set_size_request(640, 480)
def __run_client(self, _dict):
"""
El Cliente Host, se encarga de configurar el Server con:
mapa, vidas, enemigos,
tanque y nick (propios)
"""
server = str(_dict['server'])
mapa = os.path.basename(str(_dict['mapa']))
tanque = os.path.basename(str(_dict['tanque']))
enemigos = str(_dict['enemigos'])
vidas = str(_dict['vidas'])
nick = str(_dict['nick'])
self.client = Client(server)
connected = self.client.conectarse()
if connected:
_buffer = "Config,%s,%s,%s,%s,%s" % (mapa, enemigos, vidas, tanque,
nick)
self.client.enviar(_buffer)
retorno = self.client.recibir()
if retorno == "OK":
tanque = str(_dict['tanque'])
mapa = str(_dict['mapa'])
new_dict = {
'tanque': tanque,
'nick': nick,
'mapa': mapa,
}
if MAKELOG:
APPEND_LOG({'client': new_dict})
time.sleep(0.5)
self.__run_game(new_dict)
else:
dialog = Dialogo(
parent=self.get_toplevel(),
text="Algo salió mal al Configurar el Servidor.")
dialog.run()
self.salir()
else:
dialog = Dialogo(
parent=self.get_toplevel(),
text="EL Cliente no pudo Conectarse con el Servidor.")
dialog.run()
self.salir()
def __end_game(self, juego, _dict):
"""
El juego recibe salir desde el server.
"""
dialog = DialogoEndGame(parent=self.get_toplevel(), _dict=_dict)
self.emit('salir')
dialog.run()
dialog.destroy()
def __run_game(self, _dict):
"""
Comienza a correr el Juego.
"""
try:
# FIXME: Agregar Dialogo con explicacion sobre teclas
xid = self.get_property('window').get_xid()
os.putenv('SDL_WINDOWID', str(xid))
self.juego = Juego(dict(_dict), self.client)
self.juego.connect("end", self.__end_game)
self.juego.connect("update", self.__update_players)
self.juego.config()
time.sleep(0.5)
self.juego.run()
except:
dialog = Dialogo(parent=self.get_toplevel(),
text="EL Juego no pudo Iniciar.")
dialog.run()
self.salir()
def __update_players(self, juego, _dict):
self.emit("update", _dict)
def setup_init(self, _dict):
"""
Comienza a correr el Server.
"""
try:
self.server = Server(host=str(_dict['server']),
port=5000,
handler=RequestHandler)
self.server_thread = threading.Thread(
target=self.server.serve_forever)
self.server_thread.setDaemon(True)
self.server_thread.start()
time.sleep(0.5)
if MAKELOG:
APPEND_LOG({'server': _dict})
self.__run_client(dict(_dict))
except:
dialog = Dialogo(parent=self.get_toplevel(),
text="EL Servidor no pudo Iniciar.")
dialog.run()
self.salir()
return False
def do_draw(self, context):
"""
Reescalado en gtk, reescala en pygame.
"""
rect = self.get_allocation()
if self.juego:
self.juego.escalar((rect.width, rect.height))
def update_events(self, eventos):
"""
Eventos gtk, se pasan a pygame
"""
if "Escape" in eventos:
self.salir()
else:
if self.juego:
self.juego.update_events(eventos)
if "space" in eventos:
eventos.remove("space")
def salir(self):
if self.juego:
self.juego.salir("END,")
del (self.juego)
self.juego = False
if self.client:
self.client.desconectarse()
del (self.client)
self.client = False
if self.server:
self.server.server_close()
self.server.shutdown()
self.server.socket.close()
del (self.server)
self.server = False
if self.server_thread:
terminate_thread(self.server_thread)
del (self.server_thread)
self.server_thread = False
self.emit('salir')
class DrawingWidget(gtk.DrawingArea):
__gsignals__ = {
"update": (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
(gobject.TYPE_PYOBJECT, )),
"salir": (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, [])
}
def __init__(self):
gtk.DrawingArea.__init__(self)
self.client = False
self.juego = False
self.connect("expose-event", self.__do_draw)
self.show_all()
self.set_size_request(640, 480)
def __run_client(self, _dict):
"""
El Cliente remoto intenta conectarse al server pasandole:
tanque y nick (propios)
"""
server = str(_dict['server'])
tanque = os.path.basename(str(_dict['tanque']))
nick = str(_dict['nick'])
dirpath = os.path.dirname(os.path.dirname(str(_dict['tanque'])))
self.client = Client(server)
connected = self.client.conectarse()
if connected:
_buffer = "JOIN,%s,%s" % (tanque, nick)
self.client.enviar(_buffer)
retorno = self.client.recibir()
mapa = os.path.join(dirpath, "Mapas", retorno)
tanque = str(_dict['tanque'])
new_dict = {
'tanque': tanque,
'nick': nick,
'mapa': mapa,
}
if MAKELOG:
APPEND_LOG({'client': new_dict})
if retorno == "CLOSE":
dialog = Dialogo(parent=self.get_toplevel(),
text="El Servidor no Admite más Jugadores.")
dialog.run()
self.salir()
else:
time.sleep(0.5)
self.__run_game(new_dict)
else:
dialog = Dialogo(
parent=self.get_toplevel(),
text="EL Cliente no pudo Conectarse con el Servidor.")
dialog.run()
self.salir()
def __end_game(self, juego, _dict):
"""
El juego recibe salir desde el server.
"""
dialog = DialogoEndGame(parent=self.get_toplevel(), _dict=_dict)
self.emit('salir')
dialog.run()
dialog.destroy()
def __run_game(self, _dict):
"""
Comienza a correr el Juego.
"""
try:
# FIXME: Agregar Dialogo con explicacion sobre teclas
xid = self.get_property('window').xid
os.putenv('SDL_WINDOWID', str(xid))
self.juego = Juego(dict(_dict), self.client)
self.juego.connect("end", self.__end_game)
self.juego.connect("update", self.__update_players)
self.juego.config()
time.sleep(0.5)
self.juego.run()
except:
dialog = Dialogo(parent=self.get_toplevel(),
text="EL Juego no pudo Iniciar.")
dialog.run()
self.salir()
def __update_players(self, juego, _dict):
self.emit("update", _dict)
def __do_draw(self, widget=None, event=None):
"""
Reescalado en gtk, reescala en pygame.
"""
rect = self.get_allocation()
if self.juego:
self.juego.escalar((rect.width, rect.height))
def setup_init(self, _dict):
self.__run_client(dict(_dict))
return False
def update_events(self, eventos):
"""
Eventos gtk, se pasan a pygame
"""
if "Escape" in eventos:
self.salir()
else:
if self.juego:
self.juego.update_events(eventos)
def salir(self):
if self.juego:
self.juego.salir("REMOVE,")
time.sleep(0.5)
del (self.juego)
self.juego = False
if self.client:
self.client.desconectarse()
del (self.client)
self.client = False
dialog = Dialogo(parent=self.get_toplevel(),
text="Saliendo del Juego . . .")
dialog.run()
dialog.destroy()
self.emit('salir')
class ServerModelGame(gobject.GObject):
__gsignals__ = {
"error": (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, []),
"players": (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
(gobject.TYPE_PYOBJECT, )),
"play-enabled": (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
(gobject.TYPE_BOOLEAN, )),
"end-game": (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
(gobject.TYPE_PYOBJECT, ))}
def __init__(self, topwin, _host, _dict, _nick, _tank):
gobject.GObject.__init__(self)
self._topwin = topwin
self._host = _host
self._dict = _dict # jugadores, mapa, vidas
self._nick = _nick
self._tank = _tank
self.server_thread = False
self.server = False
self.client = False
self.juego = False
self.eventos = []
self.publicar = False
self.registro = False
self.default_retorno = {"aceptado": False, "game": {}}
def __handler_registro(self):
new = {
"register": {
"t": "%s" % self._tank,
"n": "%s" % self._nick,
},
}
self.client.enviar(new)
_dict = self.client.recibir(dict(self.default_retorno))
self.default_retorno["aceptado"] = _dict.get("aceptado", False)
if _dict.get("aceptado", False):
self.emit("players", dict(_dict.get("players", {})))
self.default_retorno["game"] = _dict.get("game", {})
dict_game = _dict.get("game", False)
if dict_game.get("todos", False):
self.new_handler_anuncio(False)
self.emit("play-enabled", True)
else:
self.emit("play-enabled", False)
if not self.publicar:
self.new_handler_anuncio(True)
else:
print "Cliente Host Rechazado:", _dict
self.emit("error")
return bool(self.registro)
def __make_anuncio(self, new):
# carga debe ser 150
new["z"] = ""
message = pickle.dumps(new, 2)
l = len(message)
if l < 150:
x = 149 - l
new["z"] = " " * x
message = pickle.dumps(new, 2)
elif l > 150:
print "Sobre Carga en la Red:", l
return message
def __handler_anuncio(self):
if not self.server:
return False
new = dict(self._dict)
new["ip"] = self._host
new["nickh"] = self._nick
message = "%s\n" % self.__make_anuncio(new) # carga debe ser 150
my_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
my_socket.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
my_socket.sendto(message, ("<broadcast>", 10000))
my_socket.close()
return bool(self.publicar)
def __client_run(self):
self.client = Client(self._host)
connected = self.client.conectarse()
print "Cliente del Host Creado:", connected
if connected:
self.client.connect("error", self.__client_error)
return self.__register_client_in_server()
else:
return False
def __register_client_in_server(self):
print "Registrando Cliente del host en el Servidor..."
new = {
"register": {
"t": "%s" % self._tank,
"n": "%s" % self._nick,
},
}
self.client.enviar(new)
_dict = self.client.recibir(dict(self.default_retorno))
self.default_retorno["aceptado"] = _dict.get("aceptado", False)
if _dict.get("aceptado", False):
print "\tCliente del Host Registrado:"
for item in _dict.items():
print "\t\t", item
return True
else:
print "Cliente Host Rechazado:", _dict
return False
def __kill_server(self):
if self.server:
self.server.server_close()
self.server.shutdown()
self.server.socket.close()
del(self.server)
self.server = False
if self.server_thread:
terminate_thread(self.server_thread)
del(self.server_thread)
self.server_thread = False
def __kill_client(self):
if self.client:
self.client.desconectarse()
del(self.client)
self.client = False
def __client_error(self, client, valor):
print "Error del Cliente recibido en ServerModel", valor
self.emit("error")
def new_handler_anuncio(self, reset):
if self.publicar:
gobject.source_remove(self.publicar)
self.publicar = False
if reset:
print "Publicando Juego en la red..."
self.publicar = gobject.timeout_add(1000, self.__handler_anuncio)
def new_handler_registro(self, reset):
if self.registro:
gobject.source_remove(self.registro)
self.registro = False
if reset:
print "Esperando Jugadores..."
self.registro = gobject.timeout_add(100, self.__handler_registro)
def server_run(self):
try:
self.server = Server(host=self._host,
port=5000, handler=RequestHandler, _dict=self._dict)
self.server_thread = threading.Thread(
target=self.server.serve_forever)
self.server_thread.setDaemon(True)
self.server_thread.start()
time.sleep(0.5)
except:
print "EL Servidor no pudo Iniciar."
self.emit("error")
return False
print self._nick, "Ha Creado un Juego en la red"
if self.__client_run():
return True
else:
print "ERROR: Cliente del host falla en el registro"
self.__kill_client()
self.__kill_server()
self.emit("error")
return False
def close_all_and_exit(self):
self.new_handler_anuncio(False)
self.new_handler_registro(False)
# Cuidado, no llamar a esta funcion si no se esta en fase de
# registro. Si hay un juego corriendo todo cae.
if self.client:
time.sleep(0.5)
new = {"ingame": True, "off": True}
self.client.enviar(new)
_dict = self.client.recibir(dict(self.default_retorno))
time.sleep(0.5)
self.__kill_client()
self.__kill_server()
def process_key_press(self, event):
nombre = gtk.gdk.keyval_name(event.keyval)
if self.juego:
teclas = ["w", "s", "d", "a", "space", "Escape"]
if nombre in teclas and not nombre in self.eventos:
if nombre == "w" and "s" in self.eventos:
self.eventos.remove("s")
elif nombre == "s" and "w" in self.eventos:
self.eventos.remove("w")
elif nombre == "d" and "a" in self.eventos:
self.eventos.remove("a")
elif nombre == "a" and "d" in self.eventos:
self.eventos.remove("d")
self.eventos.append(nombre)
if "Escape" in self.eventos:
dialog = DialogoSalir(parent=self._topwin,
text="¿Abandonas el Juego?")
self.juego._jugador.pausar()
ret = dialog.run()
dialog.destroy()
if ret == gtk.RESPONSE_ACCEPT:
self.eventos = ["Escape"]
elif ret == gtk.RESPONSE_CANCEL:
self.eventos = []
self.juego._jugador.reactivar()
try:
self.juego.update_events(self.eventos)
except:
print "Error:", self.process_key_press
else:
if nombre == "Escape":
self.emit("error")
def process_key_release(self, event):
if self.juego:
nombre = gtk.gdk.keyval_name(event.keyval)
teclas = ["w", "s", "d", "a", "space", "Escape"]
if nombre in teclas and nombre in self.eventos:
self.eventos.remove(nombre)
try:
self.juego.update_events(self.eventos)
except:
print "Error:", self.process_key_release
else:
self.eventos = []
def rungame(self, xid, res):
# Debe comenzar a correr en menos de 1.5 segundos
mapa = os.path.join(BASE_PATH, "Mapas", self._dict.get("mapa", ""))
self.juego = Juego()
self.juego.connect("exit", self.__exit_game)
self.juego.config(res=res, client=self.client, xid=xid)
tanque = os.path.join(BASE_PATH, "Tanques", self._tank)
self.juego.load(mapa, tanque, self._nick)
self.juego.run()
def __exit_game(self, game, _dict):
if self.juego:
self.juego.disconnect_by_func(self.__exit_game)
del(self.juego)
self.juego = False
time.sleep(0.5)
new = {"ingame": True, "off": True}
self.client.enviar(new)
new = self.client.recibir(dict(self.default_retorno))
time.sleep(0.5)
self.__kill_client()
#self.__kill_server()
self.emit("end-game", _dict)
class SocialNetworkApp(App):
def __init__(self, **kwargs):
"""
Classe principale de l'application: gère les différents écrans et les
données provenant du serveur
:param kwargs: Arguments clé/valeur de la classe parente
"""
super(SocialNetworkApp, self).__init__(**kwargs)
self.client = None
# Initialisation de l'objet permettant de sérialiser les données
self.dto = DTO()
# Initialisation du gestionnaire d'écrans
self.screenManager = CustomScreenManager()
self.ipScreen = WelcomeScreen(name="Welcome")
self.ipScreen.bind(on_confirm_ip_address=self.connectToServer)
self.signInScreen = None
self.signUpScreen = None
self.profileScreen = None
self.screenManager.add_widget(self.ipScreen)
def build(self):
"""
Méthode appelée lors du lancement de l'application
:return: Le widget parent contenant tous les autres widgets
:rtype: CustomScreenManager
"""
return self.screenManager
def on_stop(self):
"""
Méthode appelée lors de la fermeture de l'application: fermeture du
socket et terminaison du thread gérant la réception des données
provenant du serveur
:return:
:rtype: None
"""
if self.client:
self.client.closeSocket()
def connectToServer(self, instance, ipAddress):
"""
Permet de gérer la connexion au serveur: lancement de la boucle de la
partie client du modèle client-serveur et passage à l'écran de connexion
à l'application
:param instance: L'écran de bienvenue
:type instance: WelcomeScreen
:param ipAddress: L'addresse IP à laquelle se connecter
:type ipAddress: str
:return:
:rtype: None
"""
self.client = Client(ipAddress)
self.client.bind(on_connection_lost=self.handleConnectionLost)
self.client.bind(on_data_received=self.handleDataReceived)
if self.client.isConnected():
thread = Thread(target=self.client.start)
thread.start()
self.initializeScreens()
self.displaySignInScreen()
else:
CustomPopup("Error", "Could not connect to the server").open()
def initializeScreens(self):
"""
Permet d'initialiser les écrans de l'application
:return:
:rtype: None
"""
self.signInScreen = SignInScreen(self.client, name="Sign In")
self.signInScreen.bind(on_sign_up=self.displaySignUpScreen)
self.signUpScreen = SignUpScreen(self.client, name="Sign Up")
self.signUpScreen.bind(on_back=self.displaySignInScreen)
self.profileScreen = ProfileScreen(self.client,
self.dto,
name="Profile")
self.profileScreen.bind(on_sign_out=self.displaySignInScreen)
self.screenManager.add_widget(self.signInScreen)
self.screenManager.add_widget(self.signUpScreen)
self.screenManager.add_widget(self.profileScreen)
def handleConnectionError(self, instance):
"""
Gestion d'une erreur de connexion avec le serveur: affichage d'un message
d'erreur
:param instance: L'instance ayant appelée la méthode
:type instance: Client
:return:
:rtype: None
"""
popup = CustomPopup("Error", "Could not connect to the server")
popup.open()
popup.bind(on_dismiss=self.stop)
def handleConnectionLost(self, instance):
"""
Gestion d'une perte de connexion avec le serveur: affichage d'un message
d'erreur
:param instance: L'instance ayant appelée la méthode
:type instance: Client
:return:
:rtype: None
"""
self.client = None
popup = CustomPopup("Error", "Connection lost")
popup.open()
popup.bind(on_dismiss=self.stop)
def displaySignUpScreen(self, instance):
"""
Permet d'afficher l'écran d'enregistrement à l'application
:param instance: L'instance ayant appelée la méthode
:return:
:rtype: None
"""
self.screenManager.current = "Sign Up"
def displaySignInScreen(self, instance=None):
"""
Permet d'afficher l'écran de connexion à l'application (l'écran d'acceuil)
:param instance: L'instance ayant appelée la méthode
:return:
:rtype: None
"""
self.screenManager.current = "Sign In"
def handleDataReceived(self, instance, data):
"""
Permet de gérer la réception de données provenenant du serveur
:param instance: L'instance ayant appelée la méthode
:type instance: Client
:param data: Les données reçues
:type data: dict
:return:
:rtype: None
"""
request = data["request"]
if request == "signIn":
self.handleSignInValidation(data["isValid"], data["userData"])
elif request == "signUp":
self.handleSignUpValidation(data["isValid"])
elif request == "search":
self.handleSearch(data["results"])
elif request == "displayOtherUserProfile":
self.handleOtherUserProfileDisplay(data["otherUserInfos"])
elif request == "friendRequest":
self.handleFriendRequest(data["username"])
elif request == "friendRequestResponse":
self.handleFriendRequestResponse(data["otherUsername"],
data["accepted"])
elif request == "feed":
self.handleFeed(data["feed"])
elif request == "sendMessage":
self.handleMessageReceived(data["otherUsername"], data["message"])
elif request == "comment":
self.handlePublicationCommentReceived(data["comment"])
elif request == "feedComment":
self.handleFeedCommentReceived(data["comment"])
def handleSignInValidation(self, userInfosAreValid, userData):
"""
Permet de gérer la réception d'une validation de demande de connexion
à l'application
:param userInfosAreValid: Indique si les informations entrées sont valides
:type userInfosAreValid: bool
:param userData: Les données concernant l'utilisateur
:type userData: dict
:return:
:rtype: None
"""
# Si la demande est valide, affichage de l'écran de profil
if userInfosAreValid:
user = self.dto.unserializeLoggedInUser(userData)
self.profileScreen.displayUserProfile(user)
self.screenManager.current = "Profile"
# Sinon, affichage d'un message d'erreur
else:
CustomPopup("Error", "Username/Password incorrect").open()
def handleSignUpValidation(self, userInfosAreValid):
"""
Permet de gérer la réception d'une validation d'une demande d'enregistrement
à l'application
:param userInfosAreValid: Indique si les informations entrées sont valides
:type userInfosAreValid: bool
:return:
:rtype: None
"""
# Affichage d'un message popup de bienvenue ou d'erreur
if userInfosAreValid:
popup = CustomPopup("Welcome", "You can now sign in")
else:
popup = CustomPopup("Error", "Username/Password already taken")
# Retour à l'écran de bienvenue lorsque le popup est fermé
popup.bind(on_dismiss=self.displaySignInScreen)
popup.open()
def handleSearch(self, results):
"""
Permet de gérer la réception des résultats d'une recherche d'un autre
utilisateur de la part du serveur
:param results: Les résultats
:type results: list
:return:
:rtype: None
"""
self.profileScreen.displaySearchResults(results)
def handleOtherUserProfileDisplay(self, otherUserInfos):
"""
Permet de gérer la réception des données concernant un autre
utilisateur provenant du serveur lors d'une demande d'affichage du
profil de cet utilisateur par l'utilisateur connecté à l'application
:param otherUserInfos: Les données concernant l'autre utilisateur
:type otherUserInfos: dict
:return:
:rtype: None
"""
otherUser = self.dto.unserializeUser(otherUserInfos)
self.profileScreen.displayOtherUserProfile(otherUser)
def handleFriendRequest(self, otherUsername):
"""
Gestion de la récption d'une demande d'ami
:param otherUsername: L'émetteur de la demande
:type otherUsername: str
:return:
:rtype: None
"""
self.profileScreen.receiveFriendRequest(otherUsername)
def handleFriendRequestResponse(self, otherUsername, accepted):
"""
Gestion de la réception d'une réponse à une demande d'ami
:param otherUsername: L'émetteur de la réponse
:type otherUsername: str
:param accepted: Indique si la demande est acceptée ou non
:type accepted: bool
:return:
:rtype: None
"""
self.profileScreen.receiveFriendRequestResponse(
otherUsername, accepted)
def handleFeed(self, feedData):
"""
Permet de gérer la réception d'une nouvelle publication dans le
fil d'actualité de l'utilisateur
:param feedData: Les données concernant la nouvelle publication
:type feedData: dict
:return:
:rtype: None
"""
feed = self.dto.unserializePublication(feedData)
self.profileScreen.receiveFeed(feed)
def handleMessageReceived(self, otherUsername, message):
"""
Permet de gérer la réception d'un message envoyé par un autre utilisateur
:param otherUsername: L'émetteur du message
:type otherUsername: str
:param message: Le message
:type message: str
:return:
:rtype: None
"""
self.profileScreen.receiveMessage(otherUsername, message)
def handlePublicationCommentReceived(self, commentData):
"""
Permet de gérer la réception d'un commentaire d'une publication
:param commentData: Les données concernant le commentaire
:type commentData: dict
:return:
:rtype: None
"""
comment = self.dto.unSerialiseComment(commentData)
self.profileScreen.receivePublicationComment(comment)
def handleFeedCommentReceived(self, commentData):
"""
Permet de gérer la réception d'un commentaire d'une publication dans
le fil d'actualité
:param commentData: Les données concernant le commentaire
:type commentData: dict
:return:
:rtype: None
"""
comment = self.dto.unSerialiseComment(commentData)
self.profileScreen.receiveActivityFeedComment(comment)
class DrawingWidget(Gtk.DrawingArea):
__gsignals__ = {
"update": (GObject.SIGNAL_RUN_LAST,
GObject.TYPE_NONE, (GObject.TYPE_PYOBJECT, )),
"salir": (GObject.SIGNAL_RUN_LAST,
GObject.TYPE_NONE, [])}
def __init__(self):
Gtk.DrawingArea.__init__(self)
self.server_thread = False
self.client = False
self.server = False
self.juego = False
self.show_all()
self.set_size_request(640, 480)
def __run_client(self, _dict):
"""
El Cliente Host, se encarga de configurar el Server con:
mapa, vidas, enemigos,
tanque y nick (propios)
"""
server = str(_dict['server'])
mapa = os.path.basename(str(_dict['mapa']))
tanque = os.path.basename(str(_dict['tanque']))
enemigos = str(_dict['enemigos'])
vidas = str(_dict['vidas'])
nick = str(_dict['nick'])
self.client = Client(server)
connected = self.client.conectarse()
if connected:
_buffer = "Config,%s,%s,%s,%s,%s" % (mapa, enemigos,
vidas, tanque, nick)
self.client.enviar(_buffer)
retorno = self.client.recibir()
if retorno == "OK":
tanque = str(_dict['tanque'])
mapa = str(_dict['mapa'])
new_dict = {
'tanque': tanque,
'nick': nick,
'mapa': mapa,
}
if MAKELOG:
APPEND_LOG({'client': new_dict})
time.sleep(0.5)
self.__run_game(new_dict)
else:
dialog = Dialogo(parent=self.get_toplevel(),
text="Algo salió mal al Configurar el Servidor.")
dialog.run()
self.salir()
else:
dialog = Dialogo(parent=self.get_toplevel(),
text="EL Cliente no pudo Conectarse con el Servidor.")
dialog.run()
self.salir()
def __end_game(self, juego, _dict):
"""
El juego recibe salir desde el server.
"""
dialog = DialogoEndGame(parent=self.get_toplevel(), _dict=_dict)
self.emit('salir')
dialog.run()
dialog.destroy()
def __run_game(self, _dict):
"""
Comienza a correr el Juego.
"""
try:
# FIXME: Agregar Dialogo con explicacion sobre teclas
xid = self.get_property('window').get_xid()
os.putenv('SDL_WINDOWID', str(xid))
self.juego = Juego(dict(_dict), self.client)
self.juego.connect("end", self.__end_game)
self.juego.connect("update", self.__update_players)
self.juego.config()
time.sleep(0.5)
self.juego.run()
except:
dialog = Dialogo(parent=self.get_toplevel(),
text="EL Juego no pudo Iniciar.")
dialog.run()
self.salir()
def __update_players(self, juego, _dict):
self.emit("update", _dict)
def setup_init(self, _dict):
"""
Comienza a correr el Server.
"""
try:
self.server = Server(host=str(_dict['server']),
port=5000, handler=RequestHandler)
self.server_thread = threading.Thread(
target=self.server.serve_forever)
self.server_thread.setDaemon(True)
self.server_thread.start()
time.sleep(0.5)
if MAKELOG:
APPEND_LOG({'server': _dict})
self.__run_client(dict(_dict))
except:
dialog = Dialogo(parent=self.get_toplevel(),
text="EL Servidor no pudo Iniciar.")
dialog.run()
self.salir()
return False
def do_draw(self, context):
"""
Reescalado en gtk, reescala en pygame.
"""
rect = self.get_allocation()
if self.juego:
self.juego.escalar((rect.width, rect.height))
def update_events(self, eventos):
"""
Eventos gtk, se pasan a pygame
"""
if "Escape" in eventos:
self.salir()
else:
if self.juego:
self.juego.update_events(eventos)
if "space" in eventos:
eventos.remove("space")
def salir(self):
if self.juego:
self.juego.salir("END,")
del(self.juego)
self.juego = False
if self.client:
self.client.desconectarse()
del(self.client)
self.client = False
if self.server:
self.server.server_close()
self.server.shutdown()
self.server.socket.close()
del(self.server)
self.server = False
if self.server_thread:
terminate_thread(self.server_thread)
del(self.server_thread)
self.server_thread = False
self.emit('salir')
class ClientModelGame(gobject.GObject):
__gsignals__ = {
"error": (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, []),
"players": (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
(gobject.TYPE_PYOBJECT, )),
"play-run": (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, []),
"end-game": (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
(gobject.TYPE_PYOBJECT, ))}
def __init__(self, topwin, _host, _dict, _nick, _tank):
gobject.GObject.__init__(self)
self._topwin = topwin
self._host = _host
self._dict = _dict # jugadores, mapa, vidas
self._nick = _nick
self._tank = _tank
self.client = False
self.juego = False
self.eventos = []
self.registro = False
self.default_retorno = {"aceptado": False, "game": {}}
def __handler_registro(self):
new = {
"register": {
"t": "%s" % self._tank,
"n": "%s" % self._nick,
},
}
self.client.enviar(new)
_dict = self.client.recibir(dict(self.default_retorno))
self.default_retorno["aceptado"] = _dict.get("aceptado", False)
if _dict.get("aceptado", False):
self.emit("players", dict(_dict.get("players", {})))
self.default_retorno["game"] = _dict.get("game", {})
if _dict["game"].get("run", False):
self.emit("play-run")
else:
print "Cliente no Host Rechazado:", _dict
self.emit("error")
return bool(self.registro)
def __register_client_in_server(self):
print "Registrando Cliente no host en el Servidor..."
new = {
"register": {
"t": "%s" % self._tank,
"n": "%s" % self._nick,
},
}
self.client.enviar(new)
_dict = self.client.recibir(dict(self.default_retorno))
self.default_retorno["aceptado"] = _dict.get("aceptado", False)
if _dict.get("aceptado", False):
print "\t Cliente no Host Registrado:"
for item in _dict.items():
print "\t\t", item
return True
else:
print "Cliente no Host Rechazado:", _dict
return False
def __kill_client(self):
if self.client:
self.client.desconectarse()
del(self.client)
self.client = False
def __client_error(self, client, valor):
print "Error del Cliente recibido en ClientModel", valor
self.emit("error")
def new_handler_registro(self, reset):
if self.registro:
gobject.source_remove(self.registro)
self.registro = False
if reset:
print "Esperando Jugadores..."
self.registro = gobject.timeout_add(100, self.__handler_registro)
def client_run(self):
self.client = Client(self._host)
connected = self.client.conectarse()
print "Cliente Creado:", connected
if connected:
self.client.connect("error", self.__client_error)
return self.__register_client_in_server()
else:
return False
def close_all_and_exit(self):
self.new_handler_registro(False)
self.__kill_client()
def process_key_press(self, event):
nombre = gtk.gdk.keyval_name(event.keyval)
if self.juego:
teclas = ["w", "s", "d", "a", "space", "Escape"]
if nombre in teclas and not nombre in self.eventos:
if nombre == "w" and "s" in self.eventos:
self.eventos.remove("s")
elif nombre == "s" and "w" in self.eventos:
self.eventos.remove("w")
elif nombre == "d" and "a" in self.eventos:
self.eventos.remove("a")
elif nombre == "a" and "d" in self.eventos:
self.eventos.remove("d")
self.eventos.append(nombre)
if "Escape" in self.eventos:
dialog = DialogoSalir(parent=self._topwin,
text="¿Abandonas el Juego?")
self.juego._jugador.pausar()
ret = dialog.run()
dialog.destroy()
if ret == gtk.RESPONSE_ACCEPT:
self.eventos = ["Escape"]
elif ret == gtk.RESPONSE_CANCEL:
self.eventos = []
self.juego._jugador.reactivar()
try:
self.juego.update_events(self.eventos)
except:
print "Error:", self.process_key_press
else:
if nombre == "Escape":
self.emit("error")
def process_key_release(self, event):
if self.juego:
nombre = gtk.gdk.keyval_name(event.keyval)
teclas = ["w", "s", "d", "a", "space", "Escape"]
if nombre in teclas and nombre in self.eventos:
self.eventos.remove(nombre)
try:
self.juego.update_events(self.eventos)
except:
print "Error:", self.process_key_release
else:
self.eventos = []
def rungame(self, xid, res):
# Debe comenzar a correr en menos de 1.5 segundos
mapa = os.path.join(BASE_PATH, "Mapas", self._dict.get("mapa", ""))
self.juego = Juego()
self.juego.connect("exit", self.__exit_game)
self.juego.config(res=res, client=self.client, xid=xid)
tanque = os.path.join(BASE_PATH, "Tanques", self._tank)
self.juego.load(mapa, tanque, self._nick)
self.juego.run()
def __exit_game(self, game, _dict):
if self.juego:
self.juego.disconnect_by_func(self.__exit_game)
del(self.juego)
self.juego = False
time.sleep(0.5)
self.__kill_client()
self.emit("end-game", _dict)
class ServerModelGame(gobject.GObject):
__gsignals__ = {
"error": (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, []),
"players": (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
(gobject.TYPE_PYOBJECT, )),
"play-enabled":
(gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, (gobject.TYPE_BOOLEAN, )),
"end-game":
(gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, (gobject.TYPE_PYOBJECT, ))
}
def __init__(self, topwin, _host, _dict, _nick, _tank):
gobject.GObject.__init__(self)
self._topwin = topwin
self._host = _host
self._dict = _dict # jugadores, mapa, vidas
self._nick = _nick
self._tank = _tank
self.server_thread = False
self.server = False
self.client = False
self.juego = False
self.eventos = []
self.publicar = False
self.registro = False
self.default_retorno = {"aceptado": False, "game": {}}
def __handler_registro(self):
new = {
"register": {
"t": "%s" % self._tank,
"n": "%s" % self._nick,
},
}
self.client.enviar(new)
_dict = self.client.recibir(dict(self.default_retorno))
self.default_retorno["aceptado"] = _dict.get("aceptado", False)
if _dict.get("aceptado", False):
self.emit("players", dict(_dict.get("players", {})))
self.default_retorno["game"] = _dict.get("game", {})
dict_game = _dict.get("game", False)
if dict_game.get("todos", False):
self.new_handler_anuncio(False)
self.emit("play-enabled", True)
else:
self.emit("play-enabled", False)
if not self.publicar:
self.new_handler_anuncio(True)
else:
print "Cliente Host Rechazado:", _dict
self.emit("error")
return bool(self.registro)
def __make_anuncio(self, new):
# carga debe ser 150
new["z"] = ""
message = pickle.dumps(new, 2)
l = len(message)
if l < 150:
x = 149 - l
new["z"] = " " * x
message = pickle.dumps(new, 2)
elif l > 150:
print "Sobre Carga en la Red:", l
return message
def __handler_anuncio(self):
if not self.server:
return False
new = dict(self._dict)
new["ip"] = self._host
new["nickh"] = self._nick
message = "%s\n" % self.__make_anuncio(new) # carga debe ser 150
my_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
my_socket.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
my_socket.sendto(message, ("<broadcast>", 10000))
my_socket.close()
return bool(self.publicar)
def __client_run(self):
self.client = Client(self._host)
connected = self.client.conectarse()
print "Cliente del Host Creado:", connected
if connected:
self.client.connect("error", self.__client_error)
return self.__register_client_in_server()
else:
return False
def __register_client_in_server(self):
print "Registrando Cliente del host en el Servidor..."
new = {
"register": {
"t": "%s" % self._tank,
"n": "%s" % self._nick,
},
}
self.client.enviar(new)
_dict = self.client.recibir(dict(self.default_retorno))
self.default_retorno["aceptado"] = _dict.get("aceptado", False)
if _dict.get("aceptado", False):
print "\tCliente del Host Registrado:"
for item in _dict.items():
print "\t\t", item
return True
else:
print "Cliente Host Rechazado:", _dict
return False
def __kill_server(self):
if self.server:
self.server.server_close()
self.server.shutdown()
self.server.socket.close()
del (self.server)
self.server = False
if self.server_thread:
terminate_thread(self.server_thread)
del (self.server_thread)
self.server_thread = False
def __kill_client(self):
if self.client:
self.client.desconectarse()
del (self.client)
self.client = False
def __client_error(self, client, valor):
print "Error del Cliente recibido en ServerModel", valor
self.emit("error")
def new_handler_anuncio(self, reset):
if self.publicar:
gobject.source_remove(self.publicar)
self.publicar = False
if reset:
print "Publicando Juego en la red..."
self.publicar = gobject.timeout_add(1000, self.__handler_anuncio)
def new_handler_registro(self, reset):
if self.registro:
gobject.source_remove(self.registro)
self.registro = False
if reset:
print "Esperando Jugadores..."
self.registro = gobject.timeout_add(100, self.__handler_registro)
def server_run(self):
try:
self.server = Server(host=self._host,
port=5000,
handler=RequestHandler,
_dict=self._dict)
self.server_thread = threading.Thread(
target=self.server.serve_forever)
self.server_thread.setDaemon(True)
self.server_thread.start()
time.sleep(0.5)
except:
print "EL Servidor no pudo Iniciar."
self.emit("error")
return False
print self._nick, "Ha Creado un Juego en la red"
if self.__client_run():
return True
else:
print "ERROR: Cliente del host falla en el registro"
self.__kill_client()
self.__kill_server()
self.emit("error")
return False
def close_all_and_exit(self):
self.new_handler_anuncio(False)
self.new_handler_registro(False)
# Cuidado, no llamar a esta funcion si no se esta en fase de
# registro. Si hay un juego corriendo todo cae.
if self.client:
time.sleep(0.5)
new = {"ingame": True, "off": True}
self.client.enviar(new)
_dict = self.client.recibir(dict(self.default_retorno))
time.sleep(0.5)
self.__kill_client()
self.__kill_server()
def process_key_press(self, event):
nombre = gtk.gdk.keyval_name(event.keyval)
if self.juego:
teclas = ["w", "s", "d", "a", "space", "Escape"]
if nombre in teclas and not nombre in self.eventos:
if nombre == "w" and "s" in self.eventos:
self.eventos.remove("s")
elif nombre == "s" and "w" in self.eventos:
self.eventos.remove("w")
elif nombre == "d" and "a" in self.eventos:
self.eventos.remove("a")
elif nombre == "a" and "d" in self.eventos:
self.eventos.remove("d")
self.eventos.append(nombre)
if "Escape" in self.eventos:
dialog = DialogoSalir(parent=self._topwin,
text="¿Abandonas el Juego?")
self.juego._jugador.pausar()
ret = dialog.run()
dialog.destroy()
if ret == gtk.RESPONSE_ACCEPT:
self.eventos = ["Escape"]
elif ret == gtk.RESPONSE_CANCEL:
self.eventos = []
self.juego._jugador.reactivar()
try:
self.juego.update_events(self.eventos)
except:
print "Error:", self.process_key_press
else:
if nombre == "Escape":
self.emit("error")
def process_key_release(self, event):
if self.juego:
nombre = gtk.gdk.keyval_name(event.keyval)
teclas = ["w", "s", "d", "a", "space", "Escape"]
if nombre in teclas and nombre in self.eventos:
self.eventos.remove(nombre)
try:
self.juego.update_events(self.eventos)
except:
print "Error:", self.process_key_release
else:
self.eventos = []
def rungame(self, xid, res):
# Debe comenzar a correr en menos de 1.5 segundos
mapa = os.path.join(BASE_PATH, "Mapas", self._dict.get("mapa", ""))
self.juego = Juego()
self.juego.connect("exit", self.__exit_game)
self.juego.config(res=res, client=self.client, xid=xid)
tanque = os.path.join(BASE_PATH, "Tanques", self._tank)
self.juego.load(mapa, tanque, self._nick)
self.juego.run()
def __exit_game(self, game, _dict):
if self.juego:
self.juego.disconnect_by_func(self.__exit_game)
del (self.juego)
self.juego = False
time.sleep(0.5)
new = {"ingame": True, "off": True}
self.client.enviar(new)
new = self.client.recibir(dict(self.default_retorno))
time.sleep(0.5)
self.__kill_client()
#self.__kill_server()
self.emit("end-game", _dict)