TRABALHO

// Algoritmo: Jogo dos pontinhos
// Função: Jogo eletrônico baseado no "jogo dos pontinhos"
// Autores: Beatriz Dionizio, Fernando Ângelo, Joana Cândida, Marcos Alexandre e Vinícius Seabra
// Data: 25/06/2018
programa
{
	// Bibliotecas
	inclua biblioteca Util --> ut
	inclua biblioteca Texto --> txt
	inclua biblioteca Tipos --> tp
	inclua biblioteca Arquivos --> arq

	// Declaração de variáveis
	inteiro J1 = 0, J2 = 0 // Valor do placar de cada jogador
	cadeia p1 // O valor que será recebido para indicar a posição de preenchimento de cada rodada
	inteiro lin, col // Valores que serão fornecidos pelo usuário p/ as jogadas.
	logico flag = falso // Flag de controle.
	logico bandeira = verdadeiro // Outra flag de controle
	cadeia nome = "" // Nome do jogador
	caracter inicial = ' ' // Inicial do jogador
	inteiro endereco // Endereço p/ salvar o arquivo
	logico continuar = verdadeiro // Flag p/ continuar jogo ou não.

	// Declaração da variável p/ armazenar valores no vetor
	inteiro cont = 0

	// Declaração de constantes
	const inteiro TAM = 9 // Tamanho da matriz (Tabuleiro)
	const inteiro T = 100 // Tamanho dos vetores

	// Declaração de matrizes
	cadeia mat[TAM][TAM]

	// Declaração de vetores auxiliares
	cadeia vet[T], vetor[T]

	// Função inicial
	funcao inicio(){
		inteiro opcao

		// Apresentação do programa
		escreva("-- JOGO DOS PONTINHOS --\n")

		// Chamar função Interacao
		Interacao(nome)

		se(arq.arquivo_existe(nome+".txt")){
			// Tela inicial do jogo
			escreva("#############################################")
			escreva("\n##          Jogo dos pontinhos             ##")
			escreva("\n#############################################")
			escreva("\n##                                         ##")
			escreva("\n##          1) Novo jogo                   ##")
			escreva("\n##          2) Continuar                   ##")
			escreva("\n##          0) Sair                        ##")
			escreva("\n##                                         ##")
			escreva("\n#############################################")
			escreva("\n>>>>>>>>>>>>>>>>>>>>>>>>>>>> Escolha opção: ")
			leia(opcao)
		}senao{
			// Tela inicial do jogo
			escreva("#############################################")
			escreva("\n##          Jogo dos pontinhos             ##")
			escreva("\n#############################################")
			escreva("\n##                                         ##")
			escreva("\n##          1) Novo jogo                   ##")
			escreva("\n##                                         ##")
			escreva("\n##          0) Sair                        ##")
			escreva("\n##                                         ##")
			escreva("\n#############################################")
			escreva("\n>>>>>>>>>>>>>>>>>>>>>>>>>>>> Escolha opção: ")
			leia(opcao)
		}

		se(opcao == 1){
			comecar()	//Iniciar o jogo
		}senao se(opcao == 0){

		}senao se(opcao == 2){
			load() // Carregar jogo
		}senao{

		}
	}

	// Função principal
	funcao comecar()
	{

		se(bandeira == verdadeiro){ // Decisão do usuário

			// Chamar função Explicacao
			Explicacao(nome)

		}

		// Variável para receber inicial do usuário
		nome = txt.caixa_alta(nome)
		inicial = txt.obter_caracter(nome, 0)

		// Preencher a matriz
		preencherMatriz(mat)

		// Chamar função jogo
		jogo()

	}

	// Função Interacao
	funcao Interacao(cadeia & n)
	{
		// Recebe o nome do usuário
		escreva("\n> Primeiramente, digite seu nome: ")
		leia(nome)
	}

	// Função explicacao
	// Explica ao usuário como o jogo funciona
	funcao Explicacao(cadeia & n)
	{
		// Declaração de variável
		caracter pergunta // Recebe a resposta (sim ou não) para o caso do usuário desejar ver as regras do jogo

		// Explicando o jogo
		escreva("\n> Olá, ",nome,"! Vamos jogar?!\n")
		escreva("\n MENU:\n> Deseja ler as regras do jogo? (S para 'sim' ou N para 'não') \n")
		leia(pergunta)
		pergunta = tp.cadeia_para_caracter(txt.caixa_alta(pergunta+""))
		se(pergunta == 'S')
		{
			limpa()
			escreva("> Objetivos: Formar um quadrado ligando 4 pontos.\n")
			escreva("> Controles: Entre com um número de dois dígitos. \n")
			escreva("O primeiro equivale a linha da determinada posição, e o segundo equivale a coluna.\n")
			escreva("> Exemplo: 81 -- Linha 8, Coluna 1.")

			// Tempo para o usuário olhar a explicação do jogo
			ut.aguarde(10000)
			limpa()
		}senao{
			bandeira = falso
		}
	}

	// Função p/ preencher inicialmente a matriz
	funcao preencherMatriz(cadeia & matriz[][]){
		// Laço para preencher a matriz
		para(inteiro i = 0; i<TAM; i++){
			para(inteiro j = 0; j<TAM; j++){
				se((i%2 == 0) e (j%2 == 0)){
					matriz[i][j] = "+"	// Caracter que indica os pontos
				}senao{
					se((i%2==1)e(j%2 == 0)){
						matriz[i][j] = " "	// Caracter escolhido para organizar visualmente a matriz
					}senao se((i%2 == 1)e(j%2 == 1)){
						matriz[i][j] = "." // Caracter que indica o centro de um possivel quadrado
					}senao{
						matriz[i][j] = "" // Caracter que representa os locais que podem ser jogados
					}
				}
			}
		}
	}

	// Função p/ escrever matriz
	funcao escreverMatriz(cadeia matriz[][]){
		para(inteiro i = 0; i<TAM; i++){
			// Escreve a primeira linha de números antes
			se(i == 0){
				escreva("  ")
				para(inteiro k = 1; k<=TAM; k++){
					escreva(k +" ")
				}
				escreva("\n")
			}

			// Escreve a coluna de números
			escreva(i+1+" ")
			// Escreve matriz
			para(inteiro j = 0; j<TAM; j++){
				cadeia item = mat[i][j]
				se((item == "")ou(item == ".")){
					escreva("   ")
				}senao{
					escreva(item)
				}
			}

			// Quebra de linha
			escreva("\n")
		}
	}
	// Função escreverPlacar
	// Imprime na tela o placar da partida
	funcao escreverPlacar(){
		escreva("\n\n>>>>>>>>>>>>>>>> Placar <<<<<<<<<<<<<<<<\n")
		escreva("Jogador Humano - ",J1," x ",J2," - Jogador Máquina\n")
	}
	// Função apresentacao
	// Imprime na tela a apresentação do jogo
	funcao apresentacao(){
		escreva("\n  ########################\n")
		escreva("  ## Jogo dos pontinhos ##\n")
		escreva("  ########################\n")
		escreva("\n")
	}
	// Função jogadaUsuario
	//
	funcao jogadaUsuario(){

		escreva("-- Jogador Humano --\n")
		escreva("Entre com uma posição (0 para salvar e sair): ")
		leia(p1) // Receber a posição desejada

		// Verifica se a posição inserida é válida
		se(ut.numero_elementos(vet)!=0){
			para(inteiro b = 0; b<cont; b++){
				se(vet[b] == p1){
					// Elemento encontrado
					flag = verdadeiro
					pare
				}
			}
		}

		se(flag == falso){ // Caso o elemento não tenha sido encontrado

			se(p1!="0"){ // Caso o usuário não tenha pedido p/ sair
				se(txt.numero_caracteres(p1) != 2){
					// Caso o usuário tenha informado uma cadeia com mais de 2 dígitos
					limpa()
					escreva("Número inválido.\n\n")
					ut.aguarde(2000)
					jogadaUsuario()

				}senao{
					// Elemento não encontrado
					lin = tp.cadeia_para_inteiro(txt.obter_caracter(p1, 0)+"", 10) // Extrai a linha que o usuário escolheu
					col = tp.cadeia_para_inteiro(txt.obter_caracter(p1, 1)+"", 10) // Extrai a coluna que o usuário escolheu

					// Validação da linha e da coluna
					se((lin!=0)e(col!=0)){
						se(lin%2 == 1){
							se(col%2 == 0){ // Caso a jogada seja na horizontal
								mat[lin-1][col-1] = "---"
							}senao{
								// Posição inválida
								limpa()
								escreva("Essa posição é inválida!\n")
								ut.aguarde(2000)
								limpa()
								jogadaUsuario()
							}
						}senao{
							se(col%2 == 1){ // Caso a jogada seja na vertical
								mat[lin-1][col-1] = "|"
							}senao{
								// Posição inválida
								limpa()
								escreva("Essa posição é inválida!\n")
								ut.aguarde(2000)
								limpa()
								jogadaUsuario()
							}
						}
					}senao{
						// Posição inválida
						limpa()
						escreva("Essa posição é inválida!\n")
						ut.aguarde(2000)
						limpa()
						escreverMatriz(mat)
						jogadaUsuario()
					}
				}
			}senao{
				// Função p/ salvar o jogo atual
				salvar()
			}
		}senao{ // Caso o elemento tenha sido encontrado
			escreva("Posição inválida.\n")
			escreva("\n")
			flag = falso
			jogadaUsuario()
		}

		// Atualiza o vetor com as jogadas
		atualizarVetor()
		atualizarPontuacao(verdadeiro)
	}

	// Jogada da máquina
	funcao jogadaMaquina(){
		//p1 = ""
		// Armazena em um vetor os valores possíveis de serem escolhidos
		inteiro c = 0, linha, coluna
		para(inteiro i = 0; i<TAM; i++){
			para(inteiro j = 0; j<TAM; j++){
				se((mat[i][j] == "")ou(mat[i][j] == " ")){ // Caso a posição seja válida
					// Concatena cadeias p/ guardar o resultado.
					linha = i+1
					coluna = j+1
					vetor[c] = linha+""
					vetor[c] += coluna

					// Variável p/ controlar a quantidade de opções
					c++
				}
			}
		}

		se(c>0){ // Se existe alguma jogada possível
			p1 = ""
			inteiro l, co // Variáveis correspondentes a linha(l) e a coluna(co) da posição
			para(inteiro i = 0; i<TAM; i++){ // Laço para verificação da matriz
				para(inteiro j = 0; j<TAM; j++){
					se(mat[i][j] == "."){// P/ cada centro de quadrado da matriz verefica se ele está cercado por...
						se(mat[i-1][j]!=""){ //...traço superior...
							se(mat[i+1][j]!=""){ //...traço inferior...
								se(mat[i][j-1]!=" "){ //...traço da esquerda...
									se(mat[i][j+1] == " "){ //e não tem o traço da direita
										// Preenche com o traço da direita
										l = i+1 //linha
										co = j+2 //coluna
										p1 = l+"" //linha + concatenação
										p1 += co
										pare
										pare
									}
								}senao se(mat[i][j+1]!=" "){//...Ou (caso não tenha o traço da esquerda) se tem o traço da direita
									// Em caso afirmativo, preenche com o traço da esquerda
									l = i+1 //linha
									co = j //coluna
									p1 = l+"" //linha + concatenação
									p1 += co
									pare
									pare
								}
							}senao se((mat[i][j-1]!=" ")e(mat[i][j+1]!=" ")){//...Ou (caso sem o traço inferior) se tem os traços laterais
								//Em caso afirmativo, preenche com o traço inferior
								l = i+2 //linha
								co = j+1 //coluna
								p1 = l+"" //linha + concatenação
								p1 += co
								pare
								pare
							}
						}senao se((mat[i+1][j]!="")e(mat[i][j-1]!=" ")e(mat[i][j+1]!=" ")){//Caso que não tem o traço superior e tem todos os outros
							//Preenche com o traço superior
							l = i //linha
							co = j+1 //coluna
							p1 = l+"" //linha + concatenação
							p1 += co
							pare
							pare
						}
					}
				}
			}

			se(p1 == ""){
				inteiro valor = ut.sorteia(0, c) // Escolhe um valor aleatório p/ posição do elemento no vetor
				p1 = vetor[valor] // Armazena a jogada da posição aleatória
			}
			escreva("-- Jogador Computador -- Jogada na posição:", p1,"\n")

			lin = tp.cadeia_para_inteiro(txt.obter_caracter(p1, 0)+"", 10)-1 // Extrai a linha
			col = tp.cadeia_para_inteiro(txt.obter_caracter(p1, 1)+"", 10)-1 // Extrai a coluna

			// Escrever jogada na matriz
			se(col%2 == 1){ // Caso a jogada seja na horizontal
				mat[lin][col] = "~~~"
			}senao{ // Caso a jogada seja na vertical
				mat[lin][col] = "!"
			}

			// Atualiza o vetor com as jogadas
			atualizarVetor()

			// Atualiza pontuação do jogo
			atualizarPontuacao(falso)
		}
	}

	//Função p/ atualizar vetor
	funcao atualizarVetor(){
		cont = 0
		inteiro  l, c

		// Para cada elemento da matriz...
		para(inteiro i = 0; i<TAM; i++){
			para(inteiro j = 0; j<TAM; j++){
				se((mat[i][j]=="---")ou(mat[i][j] == "~~~")ou(mat[i][j] == "|")ou(mat[i][j] == "!")){ // Testa se ele já foi uma jogada
					// Concatena os valores referentes a jogada p/ armazenar no vetor
					l = i+1
					c = j+1
					vet[cont] = l+""
					vet[cont] += c

					//Variável de controle de tamanho do vetor
					cont++
				}

			}
		}
	}

	// Função p/ atualizar pontuação
	funcao atualizarPontuacao(logico humano){
		// Variável p/ controle de nova jogada por parte de quem pontuou
		logico jogarNovamente = falso

		// Para cada item da matriz...
		para(inteiro i = 0; i<TAM; i++){
			para(inteiro j = 0; j<TAM; j++){
				// Testa se é o centro de um "quadrado"
				se(mat[i][j] == "."){
					// A cada centro encontrado, verifica se as suas margens estão "preenchidas"
					se((mat[i-1][j]!="")e(mat[i+1][j]!="")e(mat[i][j-1]!=" ")e(mat[i][j+1]!=" ")){
						se(humano == verdadeiro){ // humano: variável de diferenciação entre usuário e máquina
							//Pontua o jogador
							J1++

							// Escreve a inicial do jogador no centro
							mat[i][j] = " "+inicial+" "

							// Caso o jogo não tenha acabado, permite ao jogador mais uma jogada
							se(J1+J2<16){
								jogarNovamente = verdadeiro
							}
						}senao{
							// Pontua a máquina
							J2++

							// Escreve um demarcador p/ indicar pontuação
							mat[i][j] = "PC "

							// Permite que a máquina faça outra jogada
							jogarNovamente = verdadeiro
						}
					}
				}
			}
		}

		se(jogarNovamente == verdadeiro){ // Nova jogada do pontuador
			se(humano == verdadeiro){
				limpa()
				// Caso em que o usuário pontuou
				escreverMatriz(mat)
				jogadaUsuario()
			}senao{
				// Caso em que a máquina pontuou
				jogadaMaquina()
			}
		}
	}

	// Função p/ salvar jogo
	funcao salvar(){
		endereco = arq.abrir_arquivo(nome+".txt", arq.MODO_ESCRITA) // Abrir novo arquivo

		arq.escrever_linha("> Nome do jogador:", endereco) // Linha p/ organização do arquivo

		arq.escrever_linha(nome, endereco) // Salvar nome do jogador

		arq.escrever_linha("> Inicial do jogador:", endereco) // Linha p/ organizar o arquivo

		arq.escrever_linha(inicial+"", endereco) // Salvar inicial do jogador

		arq.escrever_linha("> Pontuação do jogador:", endereco) // Linha p/ organização do arquivo

		arq.escrever_linha(J1+"", endereco) // Salva pontuação do jogador

		arq.escrever_linha("> Pontuação da máquina:", endereco) // Linha p/ organização do arquivo

		arq.escrever_linha(J2+"", endereco) // Salva pontuação da máquina

		arq.escrever_linha("> Tabuleiro:", endereco) // Linha p/ organização do arquivo

		// Para cada elemento da matriz...
		para(inteiro i = 0; i<TAM; i++){
			para(inteiro j = 0; j<TAM; j++){
				arq.escrever_linha(mat[i][j], endereco) // ...Salvar
			}
		}
		arq.fechar_arquivo(endereco) // Fechar arquivo

		continuar = falso // Finalizar jogo
	}

	// Função p/ ler jogo
	funcao load(){
		endereco = arq.abrir_arquivo(nome+".txt", arq.MODO_LEITURA) // Abrir arquivo salvo

		arq.ler_linha(endereco) // Pular linha de organização

		nome = arq.ler_linha(endereco) // Ler nome do usuário

		arq.ler_linha(endereco) // Pular linha

		inicial = tp.cadeia_para_caracter(arq.ler_linha(endereco)) // Obter inicial do jogador

		arq.ler_linha(endereco) // Pular linha de organização

		J1 = tp.cadeia_para_inteiro(arq.ler_linha(endereco), 10) // Lê pontuação do usuário

		arq.ler_linha(endereco) // Pular linha de organização

		J2 = tp.cadeia_para_inteiro(arq.ler_linha(endereco), 10) // Lê pontuação da máquina

		arq.ler_linha(endereco) // Pular linha de organização

		// Ler matriz salva
		para(inteiro i = 0; i<TAM; i++){
			para(inteiro j = 0; j<TAM; j++){
				mat[i][j] = arq.ler_linha(endereco) // Ler cada caracter da matriz salva
			}
		}

		arq.fechar_arquivo(endereco)

		jogo()
	}

	funcao jogo(){
		faca{
				// Limpar tela
				limpa()

				// Apresentação
				apresentacao()

				// Escrever a matriz
				escreverMatriz(mat)

				// Escrever placar
				escreverPlacar()

				// Nova jogada do usuário
				jogadaUsuario()

				se(continuar == verdadeiro){
					// Vez do pc
					jogadaMaquina()
				}senao{
					J1 = 16
				}

			}enquanto(J1+J2<16) // Final do jogo

			se(continuar == verdadeiro){
				// Resultado final
				se(J1>J2){
					escreva("\nParabéns ,", nome,", você venceu! :D\n ")
				}senao se(J2>J1){
					escreva("\nQue pena ,", nome,"! Você perdeu. :(\n ")
				}senao{
					escreva("\nEmpate! :/ \n")
				}
			}
	}
}