Ir para conteúdo

POWERED BY:

Arquivado

Este tópico foi arquivado e está fechado para novas respostas.

gRoOvE

Jogo batalha naval

Por , em C/C++

Recommended Posts

gRoOvE    0

gRoOvE
Postado

Estou fazendo um trabalho para facul que é o jogo de batalha naval, com inteligencia artificial do PC, de acordo com o enunciado:

Dados

a) tabuleiro 10x10

b.) 6 submarinos apenas 1 casa, representado pela letra "S"

c) 4 fragatas, 2 casas, letra "F"

d) 3 destroiers, 4 casas, letra "D"

e) 1 porta aviões, 6 casas, letra "A"

 

Construir um grid na tela para representar o tabuleiro, sendo que na posição horizontal deve aparecer uma representação alfabética e na vertical uma representação numérica:

 

A B C D E

1

2

3

O usuário deverá informar uma posição, fornecendo letra e número. Ex:A4, caso exista um alvo ou parte dele na posição marcada, a letra correspondente ao alvo deverá aparecer no grid. Ex:

 

A B C D E

1

2 D

3

 

Indicando que parte de um destroier foi atingido na posição B-2.

 

A CPU deverá tomar decisões de sua jogada baseada no seguinte mecanismo de inteligência:

 

a) Se a CPU atingir um alvo, e este ocupar mais de uma casa, suas próximas jogadas irão tentar achar as outras partes, bombardeando as casas vizinhas:

 

x

x D x

x

 

x = próximas jogadas

d = destroier

 

b.) Ao encontrar a próxima parte as jogadas seguintes deverão ocorrer em linha, visando a destruir a embarcação:

 

x D D x

 

x = próximas jogadas

d = destroier

 

Organzei da seguinte forma: dois tabuleiros para cada jogador, um para guardar as posições e outro para mostrar, estou tendo dificuldade pra fazer a AI do pc de acordo com o pedido, acho que to usando muito código em linha sendo que dava pra quebrar em funções. Segue o que já fiz:

#include <iostream>
#include <stdlib.h>
#include <time.h>
using namespace std;

#define TAM_LIN 11
#define TAM_COL 10

void construirTabuleiro(char tabuleiro[TAM_LIN][TAM_COL]);
void mostrarTabuleiro(char tabuleiro[TAM_LIN][TAM_COL]);
void inserirPeca(char tabuleiro[TAM_LIN][TAM_COL], char tipoPeca, int qtdPeca); // INSERIR VERTICAL, IMPLEMENTAR
void jogar(char tabuleiro[TAM_LIN][TAM_COL], char posicao[TAM_LIN][TAM_COL], int cordX, int cordY);
void jogarCPU(char tabuleiro[TAM_LIN][TAM_COL], char posicao[TAM_LIN][TAM_COL], int *CPUAcerto);
int converteIntChar(char letra);

int main () {
	char tabuleiroJogador[TAM_LIN][TAM_COL];
	char guardarPosicaoJogador[TAM_LIN][TAM_COL];
	char tabuleiroCPU[TAM_LIN][TAM_COL];
	int posX, posY, i,j;
	int jogadaX, jogadaY;
	int CPUAcerto[3] = {0, 0, 0};

	cout << "*** JOGO INICIADO ***" << endl;
	cout << "Jogador entre com as posições das respectivas peças: " << endl;

	construirTabuleiro(tabuleiroJogador);
	//inserirPeca(guardarPosicaoJogador, 'S', 3);
	//inserirPeca(guardarPosicaoJogador, 'F', 6);
	inserirPeca(guardarPosicaoJogador, 'D', 2);
	//inserirPeca(guardarPosicaoJogador, 'A', 2);

	/*
	for (i=0; i<6; i++) {
		cout << "entre com sua jogada: ";
		cin >> jogadaX >> jogadaY;
		jogar(tabuleiroJogador, guardarPosicaoJogador, jogadaX, jogadaY);
	}
	*/
	jogarCPU(tabuleiroJogador, guardarPosicaoJogador, CPUAcerto);
	system("sleep 0.8");
	jogarCPU(tabuleiroJogador, guardarPosicaoJogador, CPUAcerto);
	system("sleep 0.8");
	jogarCPU(tabuleiroJogador, guardarPosicaoJogador, CPUAcerto);
	system("sleep 0.8");
	jogarCPU(tabuleiroJogador, guardarPosicaoJogador, CPUAcerto);
	system("sleep 0.8");
	jogarCPU(tabuleiroJogador, guardarPosicaoJogador, CPUAcerto);
	system("sleep 0.8");
	jogarCPU(tabuleiroJogador, guardarPosicaoJogador, CPUAcerto);
	system("sleep 0.8");
	jogarCPU(tabuleiroJogador, guardarPosicaoJogador, CPUAcerto);
	system("sleep 0.8");
	jogarCPU(tabuleiroJogador, guardarPosicaoJogador, CPUAcerto);
	system("sleep 0.8");
	jogarCPU(tabuleiroJogador, guardarPosicaoJogador, CPUAcerto);
	system("sleep 0.8");
	jogarCPU(tabuleiroJogador, guardarPosicaoJogador, CPUAcerto);
	system("sleep 0.8");
	jogarCPU(tabuleiroJogador, guardarPosicaoJogador, CPUAcerto);
	system("sleep 0.8");
	jogarCPU(tabuleiroJogador, guardarPosicaoJogador, CPUAcerto);
	system("sleep 0.8");
	jogarCPU(tabuleiroJogador, guardarPosicaoJogador, CPUAcerto);
	system("sleep 0.8");
	jogarCPU(tabuleiroJogador, guardarPosicaoJogador, CPUAcerto);
	system("sleep 0.8");
	jogarCPU(tabuleiroJogador, guardarPosicaoJogador, CPUAcerto);
	
	

	mostrarTabuleiro(tabuleiroJogador);

	
 
	return 0;
}

void construirTabuleiro(char tabuleiro[TAM_LIN][TAM_COL]) {
	int i,j, auxASC;
	auxASC = 65; //inicia no A
	
	for (i=0; i<TAM_LIN; i++) { //construindo tabuleiro

 	for (j=0; j<TAM_COL; j++) {
 	if (i==0) {
 	tabuleiro[i][j] = auxASC;
 	auxASC++;
 	} else {
 	tabuleiro[i][j] = '_';
 	}
 	}
	}
}

void mostrarTabuleiro(char tabuleiro[TAM_LIN][TAM_COL]) {
	int i,j, auxASC;
	auxASC = 65; //inicia no A
	
	for (i=0; i<TAM_LIN; i++) { //construindo tabuleiro
 	cout << i << " ";
 	for (j=0; j<TAM_COL; j++) {
 	if (i==0) {
 	tabuleiro[i][j] = auxASC;
 	auxASC++;
 	cout << tabuleiro[i][j] << " ";
 	} else {
 	cout << tabuleiro[i][j] << " ";
 	}
 	}
	cout << endl;
	}
}

void inserirPeca(char tabuleiro[TAM_LIN][TAM_COL], char tipoPeca, int qtdPeca) {
	int i, posX;
	char posY;
	char posicaoHorVer;
	switch (tipoPeca) {
		case 'S':
		 for (i=0; i<qtdPeca; i++) {
				cout << "Submarino(letra numero): ";
				cin >> posY >> posX;
				tabuleiro[posX][converteIntChar(posY)] = 'S';
			}		
			break;
		case 'F':
		 for (i=0; i<qtdPeca; i++) {
				cout << "Fragata(letra numero Posicao): ";
				cin >> posY >> posX >> posicaoHorVer;
				if (posicaoHorVer == 'H') {
					tabuleiro[posX][converteIntChar(posY)] = 'F';
					tabuleiro[posX][converteIntChar(posY)+1] = 'F';
				} else if (posicaoHorVer == 'V') {
					tabuleiro[posX][converteIntChar(posY)] = 'F';
					tabuleiro[posX+1][converteIntChar(posY)] = 'F';
				}
			}
			break;
		case 'D':
		 for (i=0; i<qtdPeca; i++) {
				cout << "Destroier(letra numero posicao): ";
				cin >> posY >> posX >> posicaoHorVer;
				if (posicaoHorVer == 'H') {
					tabuleiro[posX][converteIntChar(posY)] = 'D';
					tabuleiro[posX][converteIntChar(posY)+1] = 'D';
					tabuleiro[posX][converteIntChar(posY)+2] = 'D';
					tabuleiro[posX][converteIntChar(posY)+3] = 'D';
				} else if (posicaoHorVer == 'V') {
					tabuleiro[posX][converteIntChar(posY)] = 'D';
					tabuleiro[posX+1][converteIntChar(posY)] = 'D';
					tabuleiro[posX+2][converteIntChar(posY)] = 'D';
					tabuleiro[posX+3][converteIntChar(posY)] = 'D';
				}
			}
			break;
		case 'A':
		 for (i=0; i<qtdPeca; i++) {
				cout << "Porta Aviões(letra numero Posicao): ";
				cin >> posY >> posX >> posicaoHorVer;
				if (posicaoHorVer == 'H') {
					tabuleiro[posX][converteIntChar(posY)] = 'A';
					tabuleiro[posX][converteIntChar(posY)+1] = 'A';
					tabuleiro[posX][converteIntChar(posY)+2] = 'A';
					tabuleiro[posX][converteIntChar(posY)+3] = 'A';
					tabuleiro[posX][converteIntChar(posY)+4] = 'A';
					tabuleiro[posX][converteIntChar(posY)+5] = 'A';
				} else if (posicaoHorVer == 'V') {
					tabuleiro[posX][converteIntChar(posY)] = 'A';
					tabuleiro[posX+1][converteIntChar(posY)] = 'A';
					tabuleiro[posX+2][converteIntChar(posY)] = 'A';
					tabuleiro[posX+3][converteIntChar(posY)] = 'A';
					tabuleiro[posX+4][converteIntChar(posY)] = 'A';
					tabuleiro[posX+5][converteIntChar(posY)] = 'A';
				}
			}
		break;
		default:
			cout << "ERRO PARAMETRO.";
	}
}

void jogar(char tabuleiro[TAM_LIN][TAM_COL], char posicao[TAM_LIN][TAM_COL], int cordX, int cordY) {
	switch (posicao[cordX][cordY-1]) {
		case 'S':
			tabuleiro[cordX][cordY-1] = 'S';
			break;
		case 'F':
			tabuleiro[cordX][cordY-1] = 'F';
			break;
		case 'D':
			tabuleiro[cordX][cordY-1] = 'D';
			break;
		case 'A':
			tabuleiro[cordX][cordY-1] = 'A';
			break;
		default:
			tabuleiro[cordX][cordY-1] = 'X';
	}
}

void jogarCPU(char tabuleiro[TAM_LIN][TAM_COL], char posicao[TAM_LIN][TAM_COL], int *CPUAcerto) {
	int cordX, cordY, i;

	if (CPUAcerto[0]==0 && CPUAcerto[1]==0 ) {
		srand(time(NULL));
		cordX = rand()%10+1;
		cordY = rand()%10+1;

		switch (posicao[cordX][cordY-1]) {
			case 'S':
				tabuleiro[cordX][cordY-1] = 'S';
				break;
			case 'F':
				tabuleiro[cordX][cordY-1] = 'F';
				CPUAcerto[0] = cordX;
				CPUAcerto[1] = cordY-1;
				break;
			case 'D':
				tabuleiro[cordX][cordY-1] = 'D';
				CPUAcerto[0] = cordX;
				CPUAcerto[1] = cordY-1;
				break;
			case 'A':
				tabuleiro[cordX][cordY-1] = 'A';
				CPUAcerto[0] = cordX;
				CPUAcerto[1] = cordY-1;
				break;
			default:
				tabuleiro[cordX][cordY-1] = 'X';
		}
	} else {
		switch (posicao[CPUAcerto[0]][CPUAcerto[1]]) {
			case 'F':
				if (posicao[CPUAcerto[0]][CPUAcerto[1]+1] == 'F') {
					tabuleiro[CPUAcerto[0]][CPUAcerto[1]+1] = 'F';
					CPUAcerto[0] = 0;
					CPUAcerto[1] = 0;
					return;
				} else if (posicao[CPUAcerto[0]][CPUAcerto[1]-1] == 'F') {
					tabuleiro[CPUAcerto[0]][CPUAcerto[1]-1] = 'F';
					CPUAcerto[0] = 0;
					CPUAcerto[1] = 0;
					return;
				} else if (posicao[CPUAcerto[0]+1][CPUAcerto[1]] == 'F') {
					tabuleiro[CPUAcerto[0]][CPUAcerto[1]-1] = 'F';
					CPUAcerto[0] = 0;
					CPUAcerto[1] = 0;
					return;
				} else if (posicao[CPUAcerto[0]-1][CPUAcerto[1]] == 'F') {
					tabuleiro[CPUAcerto[0]][CPUAcerto[1]-1] = 'F';
					CPUAcerto[0] = 0;
					CPUAcerto[1] = 0;
					return;
				}
			break;
			case 'D':
				if (posicao[CPUAcerto[0]][CPUAcerto[1]+1] == 'D') {
					i = 0;
					while (posicao[CPUAcerto[0]][CPUAcerto[1]+i] == 'D') {
						tabuleiro[CPUAcerto[0]][CPUAcerto[1]+i] = 'D';
						i++;
					}
					CPUAcerto[0] = 0;
					CPUAcerto[1] = 0;
					return;
				} else if (posicao[CPUAcerto[0]][CPUAcerto[1]-1] == 'D') {
					i = CPUAcerto[1];
					while (posicao[CPUAcerto[0]][CPUAcerto[1]-i] == 'D') {
						tabuleiro[CPUAcerto[0]][CPUAcerto[1]-1] = 'D';
						i--;
					}
					CPUAcerto[0] = 0;
					CPUAcerto[1] = 0;
					return;
				} else if (posicao[CPUAcerto[0]+1][CPUAcerto[1]] == 'D') {
					i = 0;
					while (posicao[CPUAcerto[0]+1][CPUAcerto[1]] == 'D') {
						tabuleiro[CPUAcerto[0]+i][CPUAcerto[1]] = 'D';
						i++;
					}
					CPUAcerto[0] = 0;
					CPUAcerto[1] = 0;
					return;
				} else if (posicao[CPUAcerto[0]-1][CPUAcerto[1]] == 'D') {
					i = CPUAcerto[0];
					while (posicao[CPUAcerto[0]-1][CPUAcerto[1]] == 'D') {
						tabuleiro[CPUAcerto[0]-i][CPUAcerto[1]] = 'D';
						i--;
					}
					CPUAcerto[0] = 0;
					CPUAcerto[1] = 0;
					return;
				}
			break;
		}

	}
}

int converteIntChar(char letra) {
	switch (letra) {
		case 'A':
			return 0;
		break;
		case 'B':
			return 1;
		break;
		case 'C':
			return 2;
		break;
		case 'D':
			return 3;
		break;
		case 'E':
			return 4;
		break;
		case 'F':
			return 5;
		break;
		case 'G':
			return 6;
		break;
		case 'H':
			return 7;
		break;
		case 'I':
			return 8;
		break;
		case 'J':
			return 9;
		break;
	}
}

Compartilhar este post

Link para o post
Compartilhar em outros sites

quitZAUMMM    18

quitZAUMMM
Postado

Acho melhor primeiro você explicar como está tentando fazer, qual sua lógica..

ai caimos para seu código ok?

 

[]s

Compartilhar este post

Link para o post
Compartilhar em outros sites

gRoOvE    0

gRoOvE
Postado

quit, entreguei o trabalho semana passada, infelizmente o prazo era curto "/

Vlw pelo interesse, abraço.

Compartilhar este post

Link para o post
Compartilhar em outros sites

quitZAUMMM    18

quitZAUMMM
Postado

Tranquilo brother ;D

É que estou vendo isso na faculdade agora "IA" e poderia ter te ajudado melhor!

 

[]s

Compartilhar este post

Link para o post
Compartilhar em outros sites
Ir para a lista de tópicos C/C++
×

Informação importante

Ao usar o fórum, você concorda com nossos Termos e condições.

  Aceito