Aja, pero en tu post de antes no has puesto lo que saca get_error, solo sacas la cadena que has puesto tú. No saca ningún error ?

Que va, lo que sale es lo que has visto.

Otra cosa, no tendreis alguno firewall o similar :? xD

Jajaja, que va, nunca hemos hecho nada para cabrear a ningún juanker y, como usamos Linux, pues... ¿pa' que? xDD.

Por cierto, fijaos que curioso:Si pillo un vector de sockets de tamaño 10, todo funciona bien y sin problemas, aún cuando solamente envío el primero (SDLNet_UDP_SendV(AdminSocket,packet,1)). Pero si reservo este vector tan solo de tamaño 1 (1 paquete, se entiende) el servidor no recibe ningún mensaje  :huh: . Me está sorprendiendo bastante esta biblioteca, la verdad :D.

 Sí, yo también leí lo del len, pero lo probé y no funcionó. Eso sí, no está de más y debería haberlo dejado puesto , y en futuras ocasiones, para el envío de datos "ingame", sí que van a hacer mucha falta.
Y lo del SDLNet_GetError, está puesto :).

 Sí sí, UDP.
La idea es que se "simule" la conexión esa que tú dices... El código de arriba es una especie de miniprotocolo para acceder a una partida en red: El cliente (jugador) envía un mensaje al servidor vía un puerto especial de que quiere unirse la partida, y se queda esperando un cierto tiempo (el timeout, vamos) hasta que, o el servidor le contesta que puede meterse o que no, o que no llegue el mensaje de respuesta y el cliente se canse.
Al final lo que he hecho es usar un vector de paquetes con AllocPacketV, y parece que así sí que va. Tal vez sea un fallo de la implementación de SDLNet_UDP_Send: Lo habrán hecho, a todos los efectos, no bloqueante, sin importar el timeout que le pases por parámetro. Sería cuestión de mirar el código :D.
Gracias mil, vicho. Un saludo.

 Pues un amigo y yo acabamos de probar el cliente y el servidor (en diferentes ordenadores, se entiende :D) y no se produce comunicación: El cliente se sale con un flamante GDClient::Connect() : No se pudo enviar mensaje. y el servidor, por ende, no rcibe nada.
Y no hago más que mirar y mirar el código y no encuentro nada malo a mis ojos. ¿En que me estoy equivocando?
Otra vez gracias de antemano.

 Sí sí, los conjuntos de sockets los tendré que usar tarde o temprano :P. Digamos que los sockets estos aislados son, simplemente, para admitir y desadmitir peticiones de entrada en el juego.
Gracias por la respuesta, cogeré a alguien para que me haga de cobaya humano :D.

 Hola.

Tendré que reescribir esto desde cero, ya que antes se me cerró el navegador misteriosamente, pero bueno, ahí va  (nooo) :

Estoy metido en un pequeño proyecto de una biblioteca de red para juegos, básicamente en tiempo real (vamos, UDP), implementándola a partir de la biblioteca SDL_net.
El caso es que antes estaba haciéndola con los sockets BSD, pero decidí cambiar ya que portar estos a Windows no es tan sencillo como en un principio me parecía.

A la hora de hacer la prueba fatal (ejecutar el servidor, luego el cliente y, tras mandarle este último un mensaje, el servidor imprime "Recibido, líder rojo"). Esta prueba la he reducido a que el servidor espere que un jugador se conecte, y que, cuando ocurra, este envie una petición para unirse al juego y el servidor se ponga contento al descubrir que no está solo en el universo, y aceptarle en la partida.

Con los sockets BSD no había ningún problema al hacer esto (ya digo, tanto cliente como servidor bajo el mismo ordenador), pero con SDL_net, el cliente se aborta abruptamente con un flamante "SDL Parachute Deployed". Si hago que el puerto del socket del servidor sea diferente al del cliente, elimino este fallo; pero claro, obviamente, el mensaje no llega a recibirse.

Mi pregunta es: ¿Estoy haciendo algo mal o realmente tendré que comprarme un portátil, instalarme una máquina virtual como Quemu, o depender de algún amigo para realizar las pruebas, para ejecutar al cliente y al servidor en diferentes máquinas?

Os pongo los trozos de código relevantes.

Este de aquí es el servidor:

Código [Seleccionar] Expand


int main(int argc, char** argv)
{

 GDServerr Serverr;
 Serverr.startServer();
 while(1)
Server.adminIncomingConnections();

 return 0;
}


El miembro adminIncomingConnections:

Código [Seleccionar] Expand


void GDServer::adminIncomingConnections()
{
UDPpacket p;
if(SDLNet_UDP_Recv(SocketConnections,&p))
{
 std::cout << "Mensaje de conexión recibido: " << (int)p.data[0] <<  std::endl;
 if(CurrentClients<MaxClients)
 {
  CurrentClients++;
  Sockets.push_back(SDLNet_UDP_Open(p.address.port));
  SDLNet_UDP_AddSocket(SocketSet,Sockets[Sockets.size()-1]);
 }
}
}


El cliente:

Código [Seleccionar] Expand


int main(int argc, char** argv)
{

 GDClient client;
 if(!client.connect("127.0.0.1"))
cout << "Fallo en la comunicación con el servidor" << endl;
 
 return 0;
}


Y el método connect:

Código [Seleccionar] Expand


//Connection to a server
bool GDClient::connect(const char* dir,int timeout,int port) /*throw(GDError)*/
{
AdminSocket=SDLNet_UDP_Open((Uint16)port);

IPaddress Ip;
SDLNet_ResolveHost(&Ip,const_cast<char*>(dir),(Uint16)port);

int channel=SDLNet_UDP_Bind(AdminSocket,-1,&Ip);
if(channel==-1)
 std::cerr <<"GDClient::Connect(): No se pudo crear canal. "<< SDLNet_GetError() << std::endl;
UDPpacket* packet=SDLNet_AllocPacket(sizeof(Uint8));
packet->data[0] = GD_NETMSG_CONNECT;
if(!SDLNet_UDP_Send(AdminSocket,channel,packet))
 std::cerr <<"GDClient::Connect() : No se pudo enviar mensaje. "<< SDLNet_GetError() << std::endl;


Uint32 t1=SDL_GetTicks();
while(SDL_GetTicks() - t1 <= (Uint32)timeout)
{
 if(SDLNet_UDP_Recv(AdminSocket,packet))
 {
  SDLNet_FreePacket(packet);
  return true;
 }
}

SDLNet_FreePacket(packet);
return false;

}


Muchísimas gracias de antemano :).

 Gracias, Microsoft! :D
Gracias a ti todos empezaremos a migrar a otros sistemas operativos y a otras plataformas de programación menos... como lo diría? oscurantistas... :D

 De verdad nadie, absolutamente nadie, usa Linux?
Bueno, pues hale, ahi va mi Kubuntu:

[immccc@gmail.com]

 

immccc@gmail.com
LC0
Cádiz, España
Estudiante terminando la carrera
C,C++,Python, Allegro,SDL,OpenGL,Irrlicht

 Por lo que yo se, puedes acceder perféctamente a los píxeles almacenados en el buffer de un surface.  Eso sí, tienes que conocer de antemano los datos de la profundidad de color, orden de los bits, y si lleva canal alpha la imagen o no.

De todas formas yo te recomiendo la biblioteca (que no librería ;)) DeVIL. Llevan bastante tiempo sin sacar una nueva versión, pero su manejko es muy parecido al de OpenGL y, de hecho, está pensada para integrar la carga de bitmaps para este API.
Saludos.

 Yo creo que con el tema este de los punteros automáticos hay que tener muchísimo cuidado, ya que, aunque la idea es buena y bien planteada puede simplificar mucho la programación y evitar posibles fugas de memoria, un mal diseño puede conllevar el desastre: La sencillez de uso se puede convertir en una ofuscación total, tal y como pasa con el Crystal Space, motor que, aun siendo potentísimo, peca de dificultad de manejo.
Haciendo buen uso de los destructores en C++, todo este rollo de referencias compartidas se puede ahorrar. Claro que este buen uso solo se hace un 10-20% de las veces que se programa algo bajo este lenguaje :D
Es mi humilde opinión.

 Pues, precisamente, en los foros deUbuntu responden muy bien a las preguntas formuladas. Obviamente, de su  distro :D, pero la mayoría de problemas suelen ser comunes.
También, aunque de esto no tengo constancia, la comunidad de Gentoo es muy amable (http://www.gentoo.org).
Vamos, que por foros, que no quede :D.
Y, con respecto a lo que dices de las dependencias, si ves que falla en una, pues busca el paquete que te pide, y ya está. Bueno... a veces suelen ser muchos paquetes.

Y espero que, algún día, abandones Windows. :D

 ¿Te estás bajando el KDevelop en formato rar? Me parece muy extraño que no esté en .tar.gz o en .zip.
Yo lo compilé hará algún tiempo desde las fuentes y recuerdo que estaba en .tar.gz. A ver si casca porque te has bajado un fake o algo...  :S

 

El problema esta en que guardas los datos de los vértices sin tener en cuenta los datos de las caras, los vértices están en su sitio pero las caras están de cualquier manera.

Uhm... pues tiene pinta de ser lo que tú dices, pero no acabo de ver cual puede ser esa información que falta.
Estaba pensando que, probablemente, el problema radique en que no guarde las normales de las caras (aunque, de un principio, tenía el objetivo de que el objeto se viera suavizado y, para eso, bastan las normales de los vértices.
Ahora mismo no puedo, pero mañana o en otro momento lo miraré, a ver que tal...
Venga, gracias :).

 Sí, me he percatado de la propiedad index, pero eso solo indica la posición del vértice en la lista de vértices de la malla, y no de la cara en cuestión.
Aunque parezca confuso, pero a los vértices de una malla se pueden acceder de dos formas: A través de ella misma, o a través de las caras.
Obtenerla directamente desde la malla no asegura la pertenencia a una cara en concreto.

Por cierto, gracias a todos por las respuestas.