Mensajes

He de advertir que el código del servidor es "improvisado" de una web para compilarlo rápido y probar el cliente por lo que no tiene ni salida de los bucles ni nada, solo para ver si se conectan:

Código (c) [Seleccionar] Expandir


#include <sys/types.h>
#include <sys/socket.h>
#include <stdio.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>

int main()
{

int server_sockfd, client_sockfd;
int server_len, client_len;
struct sockaddr_in server_address;
struct sockaddr_in client_address;
char c[1024];


server_sockfd = socket(AF_INET, SOCK_STREAM, 0);


server_address.sin_family = AF_INET;
server_address.sin_addr.s_addr = inet_addr("127.0.0.1");
server_address.sin_port = htons(5000);
server_len = sizeof(server_address);
bind(server_sockfd, (struct sockaddr *)&server_address, server_len);
listen(server_sockfd, 5);

client_sockfd = accept(server_sockfd, (struct sockaddr *)&client_address, &client_len);

printf("Cliente conectado\n");
for(;;)
{
read(client_sockfd, c, 1024);
printf(c);
}

return 0;

}


Una última pregunta...
El servidor que utilizo corre en Linux y al intentar conectarlo no va (no pasa nada en el servidor y el cliente se cierra como si no hubiese servidor). En cambio, se el servidor es windows si funciona.
¿Hay algún problema corriente entre las conexiones de Winsock y los sockets de linux o es otro error? (He buscado en google pero los casos que vienen están en Java o hablan de portabilidad...)

Ya había encontrado la función pero había entendido mal y creía que había que hacerlo con una librería externa. Gracias.

Buenas. Esta vez mi duda es como puedo utilizar una URL en una comunicación con sockets tcp/ip en windows en vez de la IP. Tengo este código:

Código (c) [Seleccionar] Expandir


#include <windows.h>
#include <winsock2.h> //Para sockets
#include <ws2tcpip.h> //Para sockets

 
int main()
{
/*************************** DE LOS SOCKETS **************************/
WSADATA wsa;
int sock;
struct sockaddr_in direccion;

WSAStartup(MAKEWORD(2,0),&wsa);

if((sock=socket(AF_INET,SOCK_STREAM,0))==-1 )
{
return -1;
}

direccion.sin_family=AF_INET;
direccion.sin_port=htons(5000);
direccion.sin_addr.s_addr=inet_addr("192.168.1.35");  

if(connect(sock,(struct sockaddr*)&direccion,sizeof(direccion))==-1)
{
return -1;
}
/***********  ....va pa largo......   ************/

Es decir, cambiar el 192.168.1.35 por algo como "miurl.com".
Utilizo mingw.
Gracias.

[creando las variables]

¿Pero eso incluiría el tener que ir creando las variables en tiempo de ejecución, para ir luego guardando su dirección en el array, no? ¿Podrías incluir algo de código porfavor?

Era solo por curiosidad...
Gracias.

Buenas. Me pregunto si en C hay alguna forma de asignar a una variable el valor de otra como nombre, por ejemplo, si tengo una cadena (introducida por el usuario o no) que contiene "var1", puedo crear una variable que se llame var1; o si se puede acceder a una variable llamada var2, a través de una cadena como "var2".
-> He buscado en google pero...
-> Gracias.

-Para instalar la librería ncurses solo teclea en la consola: "sudo apt-get install libncurses5*"

Buenas durasno. LINES y COLS están definidas por ncurses. ¿Podrías copiar el error que te sale?

Buenas, aquí tienen el código de un juego de ping-pong hecho en C, el famoso pong, pero con un solo jugador. No se si calificarlo como aporte o no así que, porfavor, decidme errores y mejoras (como los tics esos que parece que tiene aveces). Para compilarlo: gcc -o pong pong.c -lncurses -lpthread
(Es para Linux y se ejecuta en una terminal, utiliza ncurses)

**Un video:
[youtube=425,350]http://youtu.be/zICUYgHeNEk[/youtube]

Código (c) [Seleccionar] Expandir


/*
-----Creado por neob
-----Juego de ping-pong.
-----Compilar con gcc -o pong pong.c -lncurses -lpthread .
-----Controles:
-- W - Mover la paleta hacia arriba.
-- S - Mover la paleta hacia abajo.
-- A - Mover la paleta hacia la izquierda.
-- D - Mover la paleta hacia la derecha.
*/


#include <stdio.h> //Simple constumbre....
#include <ncurses.h> //Utilizar ncurses.
#include <math.h> //Funciones para la obtención de números aleatorios ( rand() ).
#include <pthread.h> //Ejecución con varios hilos.
#include <time.h> //Proporciona time() que nos devuelve la hora.

/*******************************/
int salir_ncurses(); //Cierra el modo ncurses.
void dibujar_marco(); //Dibuja el marco.
void *hiloposiciones(); //Se encarga de mover la paleta y dibujar la paleta y la pelota.
void *hilomoverpelota(); //Se encarga de mover la pelota.
void dibujar_pelota(); //Dibuja la pelota en una posición aleatoria (la primera vez).
void pintar_paleta(); //Dibuja la paleta (la primera vez).
void direc_aleatoria(); //Una dirección aleatoria para la bola (la primera vez).
void escojer_dificultad(); //Se encarga de la dificultad del juego.
/*******************************/


/******   VARIABLES   *******/
int x_pelota, y_pelota, x_paleta, y_paleta, dpx_pelota, dpy_pelota, dificultad;
char key; //Guarda la tecla que pulsamos.
/*** Variables para los hilos ***/
pthread_t idhiloposiciones; //Identificador del hilo hiloposiciones
pthread_t idhilomoverpelota; //Identificador del hilo hilomoverpelota.
int error_hilo1, error_hilo2; //Para comprobar que no ha habido errores en los hilos.
/****************************/


int main()
{
initscr(); //Entramos en ncurses.
noecho(); //Que no salgan las teclas pulsadas.

       dibujar_marco(); //Dibujamos las paredes.
pintar_paleta(); //Pintamos la paleta.
       dibujar_pelota();  //Dibujamos la pelota.
direc_aleatoria(); //Para que se mueva la pelota por primera vez (Solo la llamamos aquí).
escojer_dificultad(); //Le preguntamos al jugador la dificultad que quiere que tenga el juego (irá en función de la velocidad de la bola).

srand( time(NULL) ); //Cambiamos la semilla de rand.

error_hilo1 = pthread_create(&idhiloposiciones, NULL, hiloposiciones, NULL); //Lo creamos.
error_hilo2 = pthread_create(&idhilomoverpelota, NULL, hilomoverpelota, NULL); //Lo creamos.

if (error_hilo1 != 0 && error_hilo2 != 0) //Si ha habido error, no podemos seguir adelante.
{
clear();
move(LINES/2,COLS/2);
printw("ERROR AL CREAR HILOS DE EJECUCIÓN.");
return -1;
}

while( key != 'e' && key != 'E' )//Si pulsamos E, nos vamos.
{
key = getch();
if (key == 'w' || key == 'W') { x_paleta = x_paleta - 1; }
if (key == 's' || key == 'S') { x_paleta = x_paleta + 1; }
if (key == 'a' || key == 'A') { y_paleta = y_paleta - 1; }
if (key == 'd' || key == 'D') { y_paleta = y_paleta + 1; }
}

salir_ncurses(); kill(&idhiloposiciones); kill(&hilomoverpelota); return 0; //Hemos salido pulsando E, salimos de ncurses, matamos los hilos y nos vamos.

}

void *hiloposiciones()
{
for(;;)
{
   int i; //Para contar.

   clear(); //Borramos la pantalla para renovar todas las posiciones.
   dibujar_marco(); //Volvemos a dibujar el marco.
         
           /*************** PALETAS ***********/
           if (y_paleta != 0 && y_paleta <= COLS -1 && x_paleta != 0 && (x_paleta - 3) != LINES - 1) //No vas a atravesar el marco, no¿?
   {
    for( i=0; i<4; i++ )
       {
move(x_paleta + i, y_paleta);
printw("#");
       }
   } else
    {
                  if (y_paleta <= 0)
  {
y_paleta = 1; //Volvemos a ajustarla a 1 (para que no pueda salir del marco por la izquierda).
  for( i=0; i<4; i++ )
               {
move(x_paleta + i, y_paleta);
printw("#");
          }
  }

              if (y_paleta >= COLS - 1)
  {
  y_paleta = COLS - 2; //Volvemos a ajustarla a COLS - 2 (para que no pueda salir del marco, pero esta vez por la derecha).
  for( i=0; i<4; i++ )
              {
move(x_paleta + i, y_paleta);
printw("#");
          }
  }

              if (x_paleta <= 0) //Para que no se salga por arriba.
  {
  x_paleta = 1;
  for( i=0; i<4; i++ )
              {
move(x_paleta + i, y_paleta);
printw("#");
          }
  }
             
  if ( (x_paleta + 3) >= LINES - 1) //Para que no se salga por debajo.
  {
  x_paleta = LINES - 4;
  for( i=0; i<4; i++ )
              {
move(x_paleta + i, y_paleta);
printw("#");
          }
  }
     }

    /***************** PELOTA ******************/
    move(x_pelota, y_pelota); //Segun las posiciones marcadas por el hilo hilomoverpelota...
    printw("O"); // ...pintamos las pelota.

/*     //----LO UTILIZO PARA VER LOS ERRORES EN LAS VARIABLES Y EN LAS POSICIONES.
    move(3,3);
    printw("-DEBUG: dpx_pelota=%d; dpy_pelota=%d; x_pelota=%d; y_pelota=%d; x_paleta=%d; y_paleta=%d;", dpx_pelota, dpy_pelota, x_pelota, y_pelota, x_paleta, y_paleta); //DEBUG
*/

    if (y_pelota <= 0) //Significa que no ha parado la pelota, se acaba el juego.
    {
     kill(idhiloposiciones); kill(idhilomoverpelota);
   clear();
     move(LINES/2,COLS/2);
     printw("FIN DEL JUEGO!");
    }

    if ( (y_pelota == y_paleta) && ((x_pelota == x_paleta) || (x_pelota == x_paleta + 1) || (x_pelota == x_paleta + 2)  || (x_pelota == x_paleta + 3)) )
    {
        dpy_pelota = - dpy_pelota; //Si rebota contra la pala, tenemos que cambiar su sentido.
      y_pelota = y_pelota + dpy_pelota; //Después de cambiar su sentido hay que volver a actualizar la posición de la pelota.
    }

    usleep(20*1000); //sleep() trabaja con segundos, por eso usamos usleep(), que trabaja con milisegundos.
    refresh(); //Mostramos los cambios en las posiciones.

}
}

/*************************** MOVIMIENTO PELOTA ***************************/
void *hilomoverpelota()
{
for(;;)
{
    if (!( (y_pelota == y_paleta) && ((x_pelota == x_paleta) || (x_pelota == x_paleta + 1) || (x_pelota == x_paleta + 2)  || (x_pelota == x_paleta + 3))) )
    {  
                    x_pelota = x_pelota + dpx_pelota; //Si no está rebotando con la pala, tiene que continuar su camino, por lo que sigue por su camino.
    y_pelota = y_pelota + dpy_pelota;
    }

    if (x_pelota <= 1) //Para que la pelota rebote contra la pared.
    {
    dpx_pelota = - dpx_pelota;
    }

    if (x_pelota >= LINES - 1) //Para que la pelota rebote contra la pared.
    {
    dpx_pelota = - dpx_pelota;    
    }

    if (y_pelota >= COLS - 1) //Para que la pelota rebote contra la pared.
    {
    dpy_pelota = - dpy_pelota;    
    }

    usleep( dificultad*1000 );
}
}





/************ Funciones secundarias como dibujar objetos, salir de ncurses, ... ******************/

int salir_ncurses()
{
endwin();
return 0;
}

void dibujar_marco()
{
int i;
       for(i=0;i<LINES;i++) //Pintamos las paredes: LINES indica el numero de lineas de la terminal y COLS el de columnas (proporcionados por la librería ncurses).
       {
        move(i,0);
        printw("|");
        move(i,COLS - 1);
        printw("|");
       }

for(i=0;i<COLS-1;i++)
{
move(0,i);
printw("_");
move(LINES -1,i);
printw("_");
}
}

void dibujar_pelota() //Dibujamos la pelota (en una posicion aleatoria dentro de un margen).
{
x_pelota = (int) ( rand() % ((LINES/2+4)-(LINES/2-4)+1) + (LINES/2 - 4) ); //Escojemos un numero aleatorio con rand().
y_pelota = (int) ( rand() % ( (((COLS-1) - COLS/9) + 4)-(((COLS-1) - COLS/9) - 4)+1 ) + (((COLS-1) - COLS/9) - 4) );
move(x_pelota, y_pelota);
printw("O");
}


void pintar_paleta() //Pintamos la paleta.
{
int i;
y_paleta = 3; // Eje y > columnas
x_paleta = LINES/2 - 3; // Eje x >> líneas

for( i=0; i<4; i++ )
{
move(x_paleta + i, y_paleta);
printw("#");
}
}

void direc_aleatoria() //Elejimos una primera dirección aleatoria para la pelota.
{
dpx_pelota = ( rand() % (+1 - (-1) +1) + (-1) );
dpy_pelota = -1;

}


void escojer_dificultad() //Escojemos la dificultad del juego.
{
char d;
clear();
move(3,3);
printw("\n-Creado por Juan Escudero Pedrosa.\n"
      "-Indique el nivel de dificultad:\n"
      "\t1 - Fácil.\n"
      "\t2 - Medio.\n"
      "\t3 - Difícil.\n\n"
      "\t(Los controles son W,S,A y D)");
d = getch();
switch(d)
{
case '1': dificultad = 200; break;
case '2': dificultad = 100; break;
case '3': dificultad = 50; break;
default:
clear();
move(3,3);
printw("No se ha seleccionado ningún nivel de dificultad, se tomará por defecto el nivel 2 (Medio). Pulse una tecla para continuar.");
               dificultad = 100;
getch();
break;
}
     
}