BatalhaNaval

#include <iostream>

using namespace std;


// constantes
static const int TAM = 9; // tamanho do campo

// enums
enum Colunas {A=1, B, C, D, F, G, H, I, J};
enum Navio {nenhum = 0, bote, rebocador_horizontal, rebocador_vertical};
enum Status {agua = 1, erro = 2, acerto = 3};

// funçoes
void limparTela(){
	system("clear||cls");
}
	
void limparBuffer(){
	fflush(stdin);
}

struct indice{
	Navio navio;
	Status status;
};

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

// Classe campo
class Campo{
	private:
		indice campo[TAM+1][TAM+1];
		//char bote = 'B'; // 1x1
		//char rebocador_horizontal[2] = {'R', 'R'}; //1x2
		//char rebocador_vertical[2][1] = {{'R'},{'R'}}; // 2x1  
		int bote_qnt_linhas = 1;
		int bote_qnt_colunas = 1;
		int rebocador_horizontal_qnt_linhas = 1;
		int rebocador_horizontal_qnt_colunas = 1;
		int rebocador_vertical_qnt_linhas = 2;
		int rebocador_vertical_qnt_colunas = 1;
	public:
		Campo();
		~Campo();
		void resetCampo();
		void getCampo();
		void getCampoRevelado();
		void setStatus(int linha, int coluna, Status status); 
		Status getStatusValor(int linha, int coluna);
		void getStatus(int linha, int coluna);
		bool testarTiro(int linha, int coluna);
		void setTiro();
		void setNavio(int linha, int coluna, Navio navio);
		Navio getNavioValor(int linha, int coluna);
		void getNavio(int linha, int coluna);	
		bool verificarPosicao(Navio navio, int linha, int coluna, int linhaFim, int colunaFim);
		void setBote();
		void setRebocador_horizontal();
		void setRebocador_vertical();
		
};
	//construtor
	Campo::Campo(){
		resetCampo();
	}
	//destrutor
	Campo::~Campo(){
		
	}
	
	// Metodos
	void Campo::resetCampo (){
		for(int linha = 1; linha <= TAM; linha++){
			for(int coluna = 1; coluna <= TAM; coluna++){
				campo[linha][coluna].status = agua;
				campo[linha][coluna].navio = nenhum;
				}
			}
	}
	
	void Campo::getCampo(){
		cout << "\t\t\t\t\t\t  A B C D F G H I J \n";
			for(int linha = 1; linha <= TAM; linha++){
			cout << "\t\t\t\t\t\t" << linha << " ";
					for(int coluna = 1; coluna <= TAM; coluna++){
						getStatus(linha, coluna);
					}
			cout << endl;
			}
	}
	
	void Campo::getCampoRevelado(){
		cout << "\t\t\t\t\t\t  A B C D F G H I J \n";
			for(int linha = 1; linha <= TAM; linha++){
			cout << "\t\t\t\t\t\t" << linha << " ";
					for(int coluna = 1; coluna <= TAM; coluna++){
						switch(getNavioValor(linha, coluna)){
							case 0:
								switch(getStatusValor(linha, coluna)){
									case 1:
										cout << "~ ";
										break;
									case 2:
										cout << "X ";
										break;
									case 3:
										cout << "# ";
										break;
									default:
										cout << "^ ";
										break;
								}
								break;
							case 1:
								if(getStatusValor(linha, coluna) == 3 ){
									cout << "# ";	
								} else {
									cout << "B ";
								}
								break;
							case 2:
								if(getStatusValor(linha, coluna) == 3 ){
									cout << "# ";	
								} else {
									cout << "R ";
								}
								break;
							case 3:
								if(getStatusValor(linha, coluna) == 3 ){
									cout << "# ";	
								} else {
									cout << "R ";
								}
							default:
								cout << "> ";
								break;			
						}
					}
			cout << endl;
			}	
	}
	
	void Campo::setStatus(int linha, int coluna, Status status){
		campo[linha][coluna].status = status;
	}
	
	Status Campo::getStatusValor(int linha, int coluna){
		return campo[linha][coluna].status;
	}
	
	void Campo::getStatus(int linha, int coluna){
		switch(getStatusValor(linha, coluna)){
			case 1:	// agua
				cout << "~ ";
				break;
			case 2:	// errou o tiro
				cout << "X ";
				break;
			case 3:	// acertou o tiro
				cout << "# ";
				break;
			default:
				cout << "^ ";
				break;
		}
	}
	
	bool Campo::testarTiro(int linha, int coluna){
		if((linha<1) || (linha>TAM) || (coluna<1) || (coluna>TAM)){
			cout << "Lugar invalido, digite novamente.\n";
			return false;
		} else {
			if(campo[linha][coluna].status!=agua){
				cout << "Lugar invalido, digite novamente.\n";
				return false;
			} else {
				return true;
			}
		}
	}
	
	void Campo::setTiro(){
		int linha = 0, coluna = 0;
		bool teste;
		do{
		cout << "\nDigite a linha: ";
		cin >> linha;
		cout << "Digite a coluna: ";
		cin >> coluna;		
		teste = testarTiro(linha, coluna);	
			if(teste == true){
				if (getNavioValor(linha, coluna) == nenhum){
					setStatus(linha, coluna, erro);
					cout << "\n\nErrouuuu!!!\n\n";
				} else {
					setStatus(linha, coluna, acerto);
					cout << "\n\nVoce acertou um ";
					getNavio(linha, coluna);
					cout << "!!!\n\n";	
				}
			}
		}while (teste!=true);
	}
	
	void Campo::setNavio(int linha, int coluna, Navio navio){
		campo[linha][coluna].navio = navio;
	} 
	
	Navio Campo::getNavioValor(int linha, int coluna){	
		return campo[linha][coluna].navio;
	}

	void Campo::getNavio(int linha, int coluna){
			switch(campo[linha][coluna].navio){
			case 0:
				cout << "Nenhum";
				break;
			case 1:
				cout << "Bote";
				break;
			case 2:
				cout << "Rebocador";
				break;
			case 3:
				cout << "Rebocador";
				break;
			default:
				cout << "\n\nBug metodo getNavio\n\n";
				break;
		}	
	}
	
	bool Campo::verificarPosicao(Navio navio, int linha, int coluna, int linhaFim, int colunaFim){
		if((linha<1) || (linha>TAM) || (coluna<1) || (coluna>TAM) || (linhaFim<1) || (linhaFim>TAM) || (colunaFim<1) || (colunaFim>TAM)){
			cout << "Lugar invalido, digite novamente.\n";
			return false;
		} else {
			switch(navio){
				case 1: // bote (1x1)
					if(getNavioValor(linha, coluna) != nenhum){
						cout << "Lugar invalido, digite novamente.\n";
						return false;
					} else {
						return true;
					}
					break;
				case 2:	// rebocador_horizontal (1x2)
					if((getNavioValor(linha, coluna) != nenhum) || (getNavioValor(linha, coluna+1) != nenhum)){
						cout << "Lugar invalido, digite novamente.\n";
						return false;
					} else {
						return true;
					}
					break;
				case 3:	// rebocador_vertical (2x1)
					if((getNavioValor(linha, coluna) != nenhum) || (getNavioValor(linha+1, coluna) != nenhum)){
						cout << "Lugar invalido, digite novamente.\n";
						return false;
					} else {
						return true;
					}
					break;
				default:
					break;	
					
			}
		}
	}
	
	void Campo::setBote(){
		int linha = 0, coluna = 0, linhaFim = 0, colunaFim = 0;
		bool teste;
		
		do{
		cout << "\nDigite a linha: ";
		cin >> linha;
		limparBuffer();
		cout << "Digite a coluna: ";
		cin >> coluna;
		limparBuffer();
		linhaFim = linha;
		colunaFim = coluna;
		
		teste = verificarPosicao(bote, linha, coluna, linhaFim, colunaFim);	
			if(teste == true){
				//for(linha = linha; linha <= bote_qnt_linhas; linha++){
				//	for(coluna = coluna; coluna <= bote_qnt_colunas; coluna++){
						campo[linha][coluna].navio = bote;
				//	}
				//}
			}
		}while (teste!=true);	
	}

	void Campo::setRebocador_horizontal(){
		int linha = 0, coluna = 0, linhaFim = 0, colunaFim = 0;
		bool teste;
		
		do{
		cout << "\nDigite a linha: ";
		cin >> linha;
		limparBuffer();
		cout << "Digite a coluna: ";
		cin >> coluna;
		limparBuffer();
		linhaFim = linha;
		colunaFim = coluna+1;
		
		teste = verificarPosicao(rebocador_horizontal, linha, coluna, linhaFim, colunaFim);	
			if(teste == true){
				//for(linha = linha; linha <= rebocador_horizontal_qnt_linhas; linha++){
				//	for(coluna = coluna; coluna <= rebocador_horizontal_qnt_colunas; coluna++){
						campo[linha][coluna].navio = rebocador_horizontal;
						campo[linha][coluna+1].navio = rebocador_horizontal;   // teste
				//	}
				//}
			}
		}while (teste!=true);	
	}
	
	void Campo::setRebocador_vertical(){
		int linha = 0, coluna = 0, linhaFim = 0, colunaFim = 0;
		bool teste;
		
		do{
		cout << "\nDigite a linha: ";
		cin >> linha;
		limparBuffer();
		cout << "Digite a coluna: ";
		cin >> coluna;
		limparBuffer();
		linhaFim = linha+1;
		colunaFim = coluna;
		
		teste = verificarPosicao(rebocador_vertical, linha, coluna, linhaFim, colunaFim);	
			if(teste == true){
				//for(linha = linha; linha <= rebocador_vertical_qnt_linhas; linha++){
				//	for(coluna = coluna; coluna <= rebocador_vertical_qnt_colunas; coluna++){
						campo[linha][coluna].navio = rebocador_vertical;
						campo[linha+1][coluna].navio = rebocador_vertical;  // teste
				//	}
				//}
			}
		}while (teste!=true);
	}	
	
	
	
	// fim dos metodos

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


	// main
int main(){
	int cont = 0;
	Campo jogador;
	jogador.getCampo();
	
	cout << "Coloque um bote(1x1): \n\n";
	jogador.setBote();
	limparTela();
	jogador.getCampoRevelado();	
	
	cout << "Coloque um bote(1x1): \n\n";	
	jogador.setBote();
	limparTela();
	jogador.getCampoRevelado();		
	
	cout << "Coloque um bote(1x1): \n\n";
	jogador.setBote();
	limparTela();
	jogador.getCampoRevelado();	
	
	cout << "Coloque um rebocador horizontal(1x2): \n\n";
	jogador.setRebocador_horizontal();
	limparTela();
	jogador.getCampoRevelado();	
	
	cout << "Coloque um rebocador horizontal(1x2): \n\n";
	jogador.setRebocador_horizontal();
	limparTela();
	jogador.getCampoRevelado();
	
	cout << "Coloque um rebocador vertical(2x1): \n\n";
	jogador.setRebocador_vertical();
	limparTela();
	jogador.getCampoRevelado();	
	cout << endl;
	system("pause");
	limparTela();
	
	cout << "\n\nVoce tem 15 tentativas pra acertar os navios. \n";
	system("pause");
	limparTela();
	
	do{
		jogador.getCampo();
		jogador.setTiro();
		cout << endl;
		system("pause");
		limparTela();
	
		limparTela();
		if(cont == 7){
			//jogador.resetCampo();
		}
		cont++;
	}while (cont<15);
	
	jogador.getCampoRevelado();
	
	
	
	system("pause");
	return 0;
}