HANGMAN

client.c

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


void error(const char *msg)
{
    perror(msg);
    exit(0);
}

typedef struct
{
	char command;
	char __nothing;
	char body[254];
} message;
 
int sockfd, portno, n;
struct sockaddr_in serv_addr;
struct hostent *server;

int points=0,word_lenght=0;

char buffer[256];
 
void send_message(char command, const char *body)
{
    message m;
    
    bzero(&m, sizeof m);
    m.command = command;
    strcpy(m.body, body);
    
    n = write(sockfd,&m,sizeof m);
    if (n < 0)
    {
        error("ERROR - nie mozna bylo zapisac do gniazda!");
    }
}

void receive_message(char *command, char *body)
{
    message m;
	bzero(&m, sizeof m);
    
    n = read(sockfd,&m,sizeof m);
    if (n < 0)
    {
        error("ERROR - nie mozna bylo odczytac z gniazda");
    }
    
  	*command = m.command;
  	strcpy(body, m.body);
}



int main(int argc, char *argv[])
{
    //------------------------------------------------------------------------
    //          Tworzenie polaczenia
    //------------------------------------------------------------------------
    
    if (argc < 3) 
    {
        fprintf(stderr,"usage %s hostname port\n", argv[0]);
        exit(0);
    }
    
    portno = atoi(argv[2]); //numer portu - 2 argument
    
    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0) 
        error("ERROR - nie mozna bylo otworzyc gniazda!\n");
    
    server = gethostbyname(argv[1]); //nazwa hosta - 1 argument
    
    if (server == NULL) 
    {
        fprintf(stderr,"ERROR - nie istnieje podany host!\n");
        exit(0);
    }
    
    bzero((char *) &serv_addr, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    bcopy((char *)server->h_addr, 
          (char *)&serv_addr.sin_addr.s_addr,
          server->h_length);
    serv_addr.sin_port = htons(portno);
    if (connect(sockfd,(struct sockaddr *) &serv_addr,sizeof(serv_addr)) < 0) 
        error("ERROR connecting");
    
    //------------------------------------------------------------------------
    //          Program wlasciwy
    //------------------------------------------------------------------------

    
    
    // Odebranie informacji o poczatkowej ilosci punktow i dlugosci slowa
    
    message response;
    
    receive_message(&response.command, response.body);
    
    if(response.command=='p');
    {
        points = response.body;
        printf("Masz %s punktow.\n", response.body);
    }
   /* else 
    {
        printf("Nie mozna bylo odebrac informacji o ilosci punktow");
    }*/
    receive_message(&response.command, response.body);
    
    if(response.command=='l');
    {
        points = response.body;
        printf("Słowo ma %s liter.\n", response.body);
    }
   /* else
    {
        printf("Nie mozna bylo odebrac informacji o dlugosci slowa");
    }*/
   
    int opcja;
    message submit;
    
    while(1)
    {
        printf("Menu:\n1) Zgaduj literke\n2) Zgaduj haslo\n0) Zakoncz program\n");
        printf("-------------------------\n");
        scanf("%d", &opcja);
        
        switch(opcja)
        {
            case(1):
                
                // wyslanie polecenia z literka
                submit.command = 'g';
                printf("Podaj literke:");
                
                scanf("%s", submit.body);
                send_message(submit.command, submit.body);
                
                
                receive_message(&response.command, response.body);
                
                
                if(response.command=='d')//jesli trafiles literke
                {
                    printf("-------------------------\n");
                    printf("Zgadles literke!\n");
                    printf("Masz %s punktow.\n", response.body);
                    
                    //odbior informacji o stanie wyrazu
                    receive_message(&response.command, response.body);
                    printf("Aktualny stan wyrazu: %s\n", response.body);
                    
                    //odbior informacji o wykorzystanych literkach
                    receive_message(&response.command, response.body);
                    printf("Wykorzystano litery: %s\n", response.body);
                    printf("-------------------------\n");
                    
                }    
                else if(response.command=='v')//jesli wygrales
                {
                    printf("-------------------------\n");
                    printf("Brawo! Zgadles haslo!\n");
                    printf("-------------------------\n");
                    return 0;
                }
                
                else if(response.command=='p')//jesli nie trafiles literki
                {
                    printf("-------------------------\n");
                    printf("Niestety, nie zgadles literki\n");
                    printf("Masz %s punktow.\n", response.body);
                        
                    //odbior informacji o stanie wyrazu
                    receive_message(&response.command, response.body);
                    printf("Aktualny stan wyrazu: %s\n", response.body);
                        
                    //odbior informacji o wykorzystanych literkach
                    receive_message(&response.command, response.body);
                    printf("Wykorzystano litery: %s\n", response.body);
                    printf("-------------------------\n");
                }
                else if (response.command=='e') 
                {
                    printf("-------------------------\n");
                    printf("Niestety, przegrales...\n");
                            
                    receive_message(&response.command, response.body);
                            
                    printf("Haslo to: %s\n", response.body);
                    printf("-------------------------\n");
                    return 0;
                }
                break;
                
                
                
            case(2):
                // wyslanie polecenia z literka
                submit.command = 'w';
                printf("Podaj wyraz:");
                
                scanf("%s", submit.body);
                send_message(submit.command, submit.body);
                
                
                receive_message(&response.command, response.body);
                
                
                /*if(response.command=='d')//jesli trafiles literke
                {
                    printf("Zgadles literke!\n");
                    printf("Masz %s punktow.\n", response.body);
                    
                    //odbior informacji o stanie wyrazu
                    receive_message(&response.command, response.body);
                    printf("Aktualny stan wyrazu: %s\n", response.body);
                    
                    //odbior informacji o wykorzystanych literkach
                    receive_message(&response.command, response.body);
                    printf("Wykorzystano litery: %s\n", response.body);
                    
                }  */  
                if(response.command=='v')//jesli wygrales
                {
                    printf("Brawo! Zgadles haslo!\n");
                    return 0;
                }
                
                else if(response.command=='p')//jesli nie trafiles hasla
                {
                    printf("-------------------------\n");
                    printf("Niestety, nie zgadles hasla\n");
                    printf("Masz %s punktow.\n", response.body);
                    
                    //odbior informacji o stanie wyrazu
                    receive_message(&response.command, response.body);
                    printf("Aktualny stan wyrazu: %s\n", response.body);
                    
                    //odbior informacji o wykorzystanych literkach
                    receive_message(&response.command, response.body);
                    printf("Wykorzystano litery: %s\n", response.body);
                    printf("-------------------------\n");
                }
                else if (response.command=='e') 
                {
                    printf("-------------------------\n");
                    printf("Niestety, przegrales...\n");
                    
                    receive_message(&response.command, response.body);
                    
                    printf("Haslo to: %s\n", response.body);
                    printf("-------------------------\n");
                    return 0;
                }
                break;

                
                break;
            case(0):
                return 0;
                break;
            deafult:break;
        }
        
        
    }
    
    close(sockfd);
    return 0;
}

server.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h> 
#include <sys/socket.h>
#include <netinet/in.h>

#define true 		1
#define false 		0


/* struktura komunikacyjna */
typedef struct
{
	char command;
	char __nothing;
	char body[254];
} message;

/* przechowuje informacje o graczu */
typedef struct
{
	int sock;		/* uchwyt polaczenia gracza */
	int points;		/* liczba punktow gracza */
} player;

player p1;
message response;
/* slowo uzywane w grze */
char word[] = "kopytko";
int letter_count = 7;
/* tablica juz uzytych liter */
char used[256];
int used_count = 0;

char tmp[256];
int i, j, k,length;
const int starting_points = 6;
int sockfd; 	/* deskryptor gniazda */
socklen_t clilen;
struct sockaddr_in server_address, cli_addr;


void error(const char *msg)
{
    perror(msg);
    exit(1);
}

/* funkcja generujaca maske slowa na podstawie wytypowanych juz liter */
void generate_word_mask(char *mask, char *word, char *used, int letter_count, int used_count)
{
	for(j = 0; j < letter_count; ++j)
		mask[j] = '_';
	for(j = 0; j < used_count; ++j)
	{
		char *p = strchr(word, used[j]);
		while (p != NULL)
		{
			mask[p-word] = used[j];
			p = strchr(p+1, used[j]);
		}
	}
}

/* funkcja sprawdza czy slowo juz zostalo odgadniete */
int is_end_of_game(char *word, char *used, int letter_count, int used_count)
{
	bzero(tmp, 256);
	generate_word_mask(tmp, word, used, letter_count, used_count);
	if(strchr(tmp, '_') == NULL)
		return 1; /* nie znaleziono - koniec gry*/
	else
		return 0; /* znaleziono - gra jeszcze trwa*/
}

/* funkcja do wysylania informacji do gracza */
void send_message(player *p, char command, const char *body)
{
	message m;
	bzero(&m, sizeof m);
	m.command = command;
	strcpy(m.body, body);
  	length = write(p->sock, &m, sizeof m);
	if (length < 0)
		error("Nie mozna bylo zapisac do gniazda!");
}

/* odbieranie wiadomości z serwera */
void receive_message(player *p, char *command, char *body)
{
  	char *ptr = body;
	message m;
	bzero(&m, sizeof m);
   	length = read(p->sock, &m, sizeof m);
   	if (length < 0)
   		error("Nie mozna bylo czytac z gniazda!");
  	*command = m.command;
  	strcpy(body, m.body);
  	/* usuwanie znaku nowej linii - przypadek szczegolny w wypadku pracy z aplikacja telnet */
  	while(*ptr != '\0')
  	{
	  	if(*ptr == '\n')
	  		*ptr = '\0';
  		if(*ptr == '\r')
  		{
  			*ptr = '\0';
  			break;
  		}
  		++ptr;
  	}
}

int main(int argc, char *argv[])
{	
    if (argc < 2)
    {
         fprintf(stderr,"Musisz podac numer portu!\nPoprawne wywolanie programu:\n%s port\n", argv[0]);
         exit(1);
    }

    clilen = sizeof(cli_addr);
    bzero((char *) &server_address, sizeof(server_address));
     
    server_address.sin_family = AF_INET;				/* IPv4 */
    server_address.sin_addr.s_addr = INADDR_ANY;		/* adres maszyny lokalnej */
    server_address.sin_port = htons(atoi(argv[1]));		/* port */
    /* otwarcie gniazda */
    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0) 
        error("Nie mozna bylo otworzyc gniazda!");
	/* podlaczamy sie do gniazda */
    if (bind(sockfd, (struct sockaddr *) &server_address, sizeof(server_address)) < 0)
     	error("Nie mozna bylo podlaczyc sie do gniazda!");
     
    /* nasluchujemy polaczenia gracza - tylko 1 gracz */
    listen(sockfd, 1);
    p1.points = starting_points;
    printf("Serwer uruchomiony. Nasluchuje polaczen...\n");
	p1.sock = accept(sockfd, (struct sockaddr *) &cli_addr, &clilen);
	if (p1.sock < 0)
		error("Nie mozna bylo przyjac gracza!\n");
	printf("Gracz polaczyl sie z serwerem.\n");
	sprintf(tmp, "%d", p1.points);
	send_message(&p1, 'p', tmp);

	sprintf(tmp, "%d", letter_count);
	send_message(&p1, 'l', tmp);
    /* rozpoczynamy grę */
    while(true)
    {
    	bzero(&response, sizeof response);
    	receive_message(&p1, &response.command, response.body);
    	switch(response.command)
    	{
    		case 'g':
   				used[used_count++] = *response.body;
    			printf("Strzal gracza: litera: \"%s\"\n", response.body);
    			if(strchr(word, *response.body) == NULL)
    			{/* nie odnaleziono litery */
    				--(p1.points);
    				if(p1.points <= 0)
    				{/* przegrana */
						bzero(&tmp, 200);
						send_message(&p1, 'e', tmp);
						send_message(&p1, 'f', word);
						printf("Koniec gry. Wyraz nie zostal odgadniety.\n");
						goto endofgame;
    				}
					sprintf(tmp, "%d", p1.points);
					send_message(&p1, 'p', tmp);
    			}
    			else
    			{/* odnaleziono */
    				if(!is_end_of_game(word, used, letter_count, used_count))
    				{
						sprintf(tmp, "%d", p1.points);
						send_message(&p1, 'd', tmp);
					}
    			}
    			break;
    		case 'w':
	    		printf("Strzal gracza: wyraz: \"%s\"\n", response.body);
    			if(strstr(word, response.body) == NULL)
    			{/* nie odgadnieto wyrazu */
    				--p1.points;
    				if(p1.points <= 0)
    				{/* przegrana */
						bzero(&tmp, 200);
						send_message(&p1, 'e', tmp);
						send_message(&p1, 'f', word);
						printf("Koniec gry. Wyraz nie zostal odgadniety.\n");
						goto endofgame;
    				}
					sprintf(tmp, "%d", p1.points);
					send_message(&p1, 'p', tmp);
				}
				else
				{/* zwyciestwo */
					bzero(&tmp, 200);
					send_message(&p1, 'v', tmp);
					printf("Koniec gry. Wyraz zostal odgadniety.\n");
					goto endofgame;
				}
    			break;
    		default:
    			printf("Nieznana komenda: \"%c %s\"\n", response.command, response.body);
    	}
		if(is_end_of_game(word, used, letter_count, used_count))
		{/* wygrana */
			bzero(&tmp, 200);
			send_message(&p1, 'v', tmp);
			printf("Koniec gry. Wyraz zostal odgadniety.\n");
			goto endofgame;
		}
		bzero(&tmp, 200);
		generate_word_mask(tmp, word, used, letter_count, used_count);
		send_message(&p1, 'f', tmp);
		send_message(&p1, 't', used);
    }
    endofgame:
	close(p1.sock);
    close(sockfd);
    return 0; 
}

Specyfikacja komunikacji

0) struktura komunikacyjna:
typedef struct
{
	char command;
	char __nothing;
	char body[254];
} message;

gdzie command to jednoliterowa komenda, a body to tablica znaków zawierająca parametr przesyłany w wiadomości, jeżeli przychodzi tekst:
r nick
to zapisując go w strukturze będziesz miał odpowiednio:
command = 'r';
body = "nick";
o nick 6
zostanie zamienione na
command='o';
body="nick 6"; - gdzie nick i 6 jest oddzielone spacją.

1) podłączasz się do serwera i otrzymujesz swoją liczbę punktów(tu: 6) i długośc wyrazu (tu: 7):
p 6
l 7
2) następnie aby zgadywać literę musisz wysłać:
g k
- jeżeli chcesz odgadywać całe hasło musisz wysłać:
w kopytko
2) jeżeli wyraz został trafiony (albo wytypowałeś ostatnią literę) otrzymujesz informację o zwycięstwie:
v
- jeżeli litera została trafiona otrzymujesz informację o swojej punktacji (tu:6), aktualnym stanie wyrazu oraz o juz strzelonych literach:
d 6
f k____k_
t sde
- jeżeli wyraz albo litera nie została trafiona otrzymujesz informację o swojej punktacji, o aktualnym stanie wyrazu oraz o juz strzelanych literach:
p 5
f k____k_
t sde
- jeżeli skończyła Ci się liczba punktów otrzymujesz informację o przegranej:
e
f kopytko
3) wracasz do punktu 2 aż do wygranej / przegranej