Os eventos descritos a seguir ocorreram após a data estelar 3192.1, ou seja, depois que o comandante J.T.Kirk mudou a história de dois planetas, pertencentes ao cluster NGC321, numa clara violação da primeira diretiva de não intervenção.

Na era pré-Kirk, a guerra estre os dois planetas era simulada em computadores e, de acordo com o resultado, as pessoas “atingidas” na simulação deveriam se encaminhar a desintegradores nucleares para serem eliminadas, respeitando os cálculos do computador.

Como é do conhecimento de todos, o comandante J.T.Kirk destruiu todos os computadores do segundo e terceiro planetas, Eminiar VII e Vendikar, que simulavam a guerra. Apesar da paz alcançada, alguns descontentes com a paz, vindos do oriente médio de um dos planetas, saudosos do tempo de guerra limpa e mortes por desintegração nuclear, ainda tentam recuperar os códigos e montar os computadores originais.

Roubando alguns arquivos da nave estelar Enterprise, eles descobriram que no final do século 20 existia uma modalidade de jogo de guerra muito comum entre estudantes desocupados e que deu origem a vários jogos de simulação de guerra.

Conhecedores da fama de um grupo de programadores de uma determinada turma de engenharia de computação, formada no início do século 21, eles voltam no tempo e sequestram esses alunos antes de se formarem, para desenvolver um jogo de simulação semelhante e assim retomar a guerra limpa.

Você faz parte desse grupo!

Incrivelmente desenvolvidos tecnologicamente, os planetas Eminiar VII e Vendikar, vão usar a última palavra em simulação de jogos de guerra:o 2D e a linha de comando!. O modelo dos planetas terá as seguintes regras:

1. 15 casas na vertical e 15 casas na horizontal. As linhas são numeradas de A a 0, e as colunas de 1 a 15.
2. Cada casa representa um quadrante de uma ilha no planeta, onde vivem um milhão de pessoas. As ilhas podem abrigar entre 1 e 5 milhões de habitantes.
3. Por incrivel que possa parecer, os dois planetas têm a mesma quantidade de ilhas e nos mesmos formatos, mas são ilhas móveis, assim, a cada simulação podem estar em posições diferentes no planeta (porém, durante uma batalha elas estão imóveis)
4. Como são planetas distantes, a simulação deverá ser jogada entre os dois lados via Internet, que, no final do século 21 se tornou a forma de comunicação padrão entre todos os planetas da galáxia.

Com um phaser apontado para cabeça, um dos sequestradores dita para você as regras da simulação que você tem que desenvolver:

1. Como, mesmo no século 23, C ainda é a linguagem de programação mais poderosa do Universo, você terá que desnvolver tudo em C ANSI.
2. O program deverá ler de uma arquivo a configuração inicial de seu planeta a partir de uma arquivo (cap. 7 do K&R), que deve ser validada pela rotina de leitura, e conectar a um outro programa na rede para jogar.
3. Haverá duas opções para usar o programa: no modo normal, a conexão deverá permitir que os dois usuários joguem interativamente. Na opção automatica (-a), os programas devem jogar sem a intervenção humana.
4. O programa deve ter como parâmetro obrigatório o nome do arquivo de entrada, com a configuração do planeta para aquela partida. Este arquivo deve ser validado.
5. Deve ser disponível para o usuário, um esquema em matriz com sua configuração. Nesta matriz, deverão ser assinalados os tiros do adversário, indicando quando alguma parte de ilha foi atingida.
6. Também deve ser disponível o campo da matriz do adversário, inicialmente totalmente vazio, e, conforme os tiros forem dados, deve ser assinalado se foi mar ou ilha.
7. Somente quando uma ilha for totalmente destruída é que o programa deve enviar para o adversário a mensagem d qual tipo de ilha foi destruída.
8. Quando jogando automaticamente, o programa deve implementar alguma estratégia para destruir o adversário, assim, quando acertar alguma parte de uma ilha, ele deve tentar acertar as outras partes.
9. Quando um jogador acerta uma ilha, ele deve continuar jogando até errar o alvo. O lado atingido fica esperando o outro errar, sem jogar.
10. A pontuação de cada jogador leva em conta o número de baixas no planeta inimigo. Vence a partida o jogador que primeiro dizimar todo o campo de batalha do planeta inimigo.
11. Na comunicação pela internet, você deve conhecer o endereço de seu adversário. O programa entra em modo talk assim que inicia, se não houver resposta do outro lado, ele deve entrar em modo listen. Se houver resposta, é porque um programa já foi inciado e então você tem o primeiro lance no ataque ao inimigo.
12. Você deve ter duas matrizes na sua tela: uma com seu planeta e as posições de suas ilhas e outra com uma matriz com a tela do inimigo, que deverá estar inicialmente em branco, e, pouco a pouco, deverá ser preenchida com os tiros de bombas de neutrons termonucleares de impacto que forem dados enviados por você, e o resultado deles, se atingiu mar ou uma ilha, além da contagem de baixas do outro lado e do seu.
13. Cada vez que você receber um tiro, você deve enviar uma mensagem dizendo se foi mar ou se foi atingido. Quando um tiro eliminar toda uma ilha, deve ser enviada uma mensagem assinalando tal evento.
14. As mensagens de tiro vêm no formato: LetraNúmero, assim, a mensagem B15, é um tiro na linha B, coluna 15.
15. A ilhas têm diversos formatos, totalizando uma população de 38 milhões de habitantes em cada partida. E cada ilha pode estar na vertical ou horizontal.

Tipo de ilha	formato	quantidade	Mensagem de destruição
ponto		4	Z.
ipequeno		2	Zi
imaior		2	ZI
principal		1	Zp
quadrada		2	Zq
Triangular		3	Zt

A mensagem Z deve vir acompanhada do tipo de ilha destruída, como mostrado na primeira tabela. Observe o ponto após o Z na primeira linha.

Para programar este jogo intergaláctico, você deve usar datagramas com a biblioteca de C.

Os programas a seguir demonstram a base de um listener (ouvinte) e de um talker (falante):

/*
** listener.c -- uma demonstração de servidor com datagrama
*/
 
#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>
 
#define MINHAPORTA 4950    // a porta na qual os usuários vão se conectar
 
#define MAXBUFLEN 100
 
int main(void)
{
    int sockfd;
    struct sockaddr_in meu_endereco;    // a informação de meu endereço
    struct sockaddr_in seu_endereco; // Informação do endereço de quem se conecta
    socklen_t tam_endereco;
    int numbytes;
    char buf[MAXBUFLEN];
 
    if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) == -1) {
        perror("socket");
        exit(1);
    }
 
    meu_endereco.sin_family = AF_INET;         // host byte order
    meu_endereco.sin_port = htons(MINHAPORTA);     // short, network byte order
    meu_endereco.sin_addr.s_addr = INADDR_ANY; // automatically fill with my IP
    memset(meu_endereco.sin_zero, '\0', sizeof meu_endereco.sin_zero);
 
    if (bind(sockfd, (struct sockaddr *)&meu_endereco, sizeof meu_endereco) == -1) {
        perror("bind");
        exit(1);
    }
 
    tam_endereco = sizeof seu_endereco;
    while (1){
      printf("Fala que eu te escuto\n");
      if ((numbytes = recvfrom(sockfd, buf, MAXBUFLEN-1 , 0,
        (struct sockaddr *)&seu_endereco, &tam_endereco)) == -1) {
        perror("recvfrom");
        exit(1);
       }
 
       printf("obteve pacote de %s\n",inet_ntoa(seu_endereco.sin_addr));
       printf("o pacote possui %d bytes\n",numbytes);
       buf[numbytes] = '\0';
       printf("O conteúdo do pacote é: %s\n",buf);
    }
    close(sockfd);
 
    return 0;
}

/*
** talker.c -- um demonstrativo de cliente com datagrama 
*/
 
#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>
 
#define SERVERPORT 4950    // a porta que os usuários vão se conectar
 
#define MAXLINHA 100
int lelinha(char s[],int lim);
 
int main(int argc, char *argv[])
{
    int sockfd;
    struct sockaddr_in seu_endereco; // informação do endereço do conector
    struct hostent *he;
    int numbytes;
 
    int tam, soma=0;
    int lim=MAXLINHA;
    char s[MAXLINHA];
 
    if (argc != 2) {
        fprintf(stderr,"uso: talker hostname\n");
        exit(1);
    }
 
    if ((he=gethostbyname(argv[1])) == NULL) {  // get the host info
        herror("gethostbyname");
        exit(1);
    }
 
    if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) == -1) {
        perror("socket");
        exit(1);
    }
 
    seu_endereco.sin_family = AF_INET;     // ordem do byte do host
    seu_endereco.sin_port = htons(SERVERPORT); // short, network byte order
    seu_endereco.sin_addr = *((struct in_addr *)he->h_addr);
    memset(seu_endereco.sin_zero, '\0', sizeof seu_endereco.sin_zero);
 
while ((tam=lelinha(s,MAXLINHA))>0){
    if ((numbytes = sendto(sockfd, s, strlen(s), 0,
             (struct sockaddr *)&seu_endereco, sizeof seu_endereco)) == -1) {
        perror("sendto");
        exit(1);
    }
 
    printf("enviado %d bytes para %s\n", numbytes, inet_ntoa(seu_endereco.sin_addr));
}
    close(sockfd);
 
    return 0;
}
 
int lelinha(char s[],int lim)
{
  int c,i;
 
  for (i=0; i<lim-1 && (c=getchar())!=EOF && c!='\n';++i)
    s[i]=c;
  if (c=='\n')
   {
    s[i]=c;
    ++i;
   }
  s[i]='\0';
  return i;
}

Os alienígenas raptores propuseram uma competição, entre os afamados programadores: Aquele que desenvolver o melhor algoritmo automático de jogo, que cause o maior número de baixas nos outros adversários, jogando cada um por si,num esquema cada um contra todos, terá como prêmio, ou 70 virgens no paraíso, ou 1 ponto a mais na média da disciplina de Laboratório de Programação I, cursada no primeiro semestre do oitavo ano do século 21, o que o ganhador achar melhor.

Vida longa e próspera!

Nos próximos episódios: excitantes aulas sobre datagramas, sockets ( que não são meias…) e comunicação pela Internet diretamente do século 21!

Como usar as funções de c para a Internet.