Jogo Da Velha em C e C

ADALBERTO MOUTINHO PINHEIRO
http://novojeitonerd.blogspot.com.br/2013/12/jogo-da-velha-emcc_24.html
JOGO DA VELHA EM C/C++
CARIACICA-ES 20013
Objetivo
Fazer um jogo da velha em c/c++, e explicar como funciona e como formar um raciocnio para
este programa.
Jogo da Velha em C e C++

1. Origem Jogo da Velha ou Jogo do Galo.
Jogo, com Regras simples , recebeu este nome na Inglaterra quando um grupo de mulheres
que se reuniam para conversar e bordar , as idosas por causas das debilidades e suas vises,
jogavam este jogo. Por isto o nome Jogo da Velha por que em maiorias eram as idosas que
jogavam , como no poderiam bordar e fazer outras coisas nos seus momentos de distraes.
Este Jogo foi encontrados em diversas culturas da antiguidade, um deles foram encontrados
no Egito com data do sculo XIV antes de Cristo. E na china com data de 500 A.C.
Tambm encontradas na Amrica Pr-Colombiana.
Referncias (acessado em 22/12/2013 as 15:35)

http://mundoestranho.abril.com.br/materia/qual-ea-origem-do-jogodavelha
http://www.jogos.antigos.nom.br/jvelha.asp
http://pt.wikipedia.org/wiki/Jogo_da_velha
2. Explicao Jogo da Velha:

Este jogo consiste em um campo com 9 posies em que 2 jogadores normalmente jogadores
1 usa X, e jogador 2 usa O , o objetivo do jogo alinhar 3 X ou 3 O , podendo ser na
horizontal, vertical ou nas diagonais . E um alinhamento significa que o jogador Venceu.
Caso nenhum dos dois consiga alinhar significa que Deu Velha, ou seja, nenhum dos dois
ganhou.
A figura ao lado mostra como composto o campo do Jogo
da Velha
Alinhamentos nas horizontais
Alinhamentos nas verticais
Alinhamentos das diagonais
Uma regra que ao ficou clara acima que um jogador realiza uma jogada de cada vez, assim o
primeiro realiza uma jogada a e depois o outro.
E todos os alinhamentos podem ser feitos por qualquer um jogador.
3. Programa Jogo Da Velha

Ser mostrado diversos programas de jogos da velha. Alguns bem trabalhados e outros
simples.Ser analisado algumas forma de fazer o programas at a efetuar jogadas,
simulando uma inteligncia artificial.
Algumas funes do jogo da velha ser a mesma para todos ento ser descrito a
seguir.
3.1. Funoes padres para todos os programas
Aqui ser mostrada e explicadas, as funes comum a todos os programas Jogo da
Velha.
3.1.1. funo de iniciao
Esta funo tem o objetivo de esvaziar (ou preencher com um caractere conhecido
) a matriz do jogo.
O campo do Jogo da Velha, representada por uma matriz 3 por 3.
Segue a declarao desta matriz.

char matrix[3][3];
para evitar possveis erros de lgica uma boa forma de evitar isto inicializar a
matriz.
O comando for utilizado para efetuar repetio e assim preencher a matriz de
uma forma rpida.
void iniciacao()
{
for(int x=0;x<3;x++)
for(int y=0;y<3;y++)
matrix[x][y]=' ';
}
Na linha void iniciacao() , esta uma forma declarao de funo o void significa que
ir retornar vazio , ou seja que no retornara nada.
O comando:
Tem a funo de percorrer toda a matriz , como esta matriz em questo 3 por 3 , foi
declarada assim significa que a matriz que a primeira posio dela em x 0 e a ultima
2, (lembrando que a matriz comea a contar do 0, no do 1 como estamos
acostumados), o mesmo vale para o y.
A figura mostra como comportamento da matriz, e suas posio [x][y] correspondente.

Este trecho poderia ser assim tambm:
for(int x=0;x<=2;x++)
for(int y=0;y<=2;y++)
o comando acima s mudou a condio mas acaba sendo a mesma coisa j que x e y so
inteiros.
O comando
matrix[x][y]=' ';
este comando se encontra dentro do for ou seja com a variao de x e y vai preenchendo
todas as posies com (vazio).
3.1.2. Funo mostrar.
Objetivo desta funo mostrar a matriz com os seus devidos valores preenchidos, esta
funo foi feita de uma bem simples.
void mostrar()
{
system("cls");
cout<<" "<< matrix[0][0] <<" | "<< matrix[0][1] <<"| "<< matrix[0][2] <<"\n"
<<" --|--|--\n"
<< " "<< matrix[1][0] <<" | "<< matrix[1][1] <<"| "<< matrix[1][2]<<"\n"
<<" --|--|--\n"
<< " "<< matrix[2][0] <<" | "<< matrix[2][1] <<"| "<< matrix[2][2]<<"\n"<<endl;
}
O que pode ser reparado aqui neste trecho a funo system(cls), esta funo limpa a
tela, o comando, cout<< ,tem a funo de mostra na tela, pode reparar diversos
espaos vazios , eles tem a simples funo te dar algum espao para ficar as linhas e
colunas ficarem bem alinhados.
O comando <<endl ele normalmente usado com o cout como mostra acima e ele serve
para forar o cout a jogar os dados na tela.
Pode reparar que a funo mostrar segue este idia da figura

ao lado.
3.1.3. Funo de preenchimento

Esta funo tem com o objetivo de ns entrarmos com o dado, ou seja nos
falarmos aonde ser marcado o X
Como toda funo inicia com o
tipo de retorno e nome da funo()
no caso; void preenchimento() significa que retornar nada e a funo tem o nome
de preenchimento.
Esta funo tem algumas coisas interessantes foi levado em considerao como
nos interpretamos. Ao invs de nos considerar que inicie com 0 podemos
considerar que a contagem comece com 1 , a figura abaixo mostra este fato, se
torna muito mais fcil pensar que a contagem comece com 1 .
Para corrigir este erro foi feito o seguinte subtrado 1 da posio x e y no

momento em que gravado o valor x na posio cdigo abaixo:
matrix[x-1][y-1]='X';
simplesmente foi subtrado 1 das posies x e y , fica como a figura abaixo.
Aps o recebimento dos dados feito pelo comando cin>>, feito a analise
Com o comando IF , a condio analisada se x e maior que zero e menor
igual que 3, e se y maior que zero e menor igual a 3, se o campo em questo se
encontra como (vazio). Feito pelo comando abaixo:
matrix[x-1][y-1]==' ', se esta e as outras condies forem verdadeiras ento
armazenada o X na posio digitada.
Caso for falsa a condio dentro do comando if executado o bloco de comando
dentro do else que chama a prpria funo preenchimento como mostra trecho
de programa abaixo:
else
{
cout<<"\n posicao invalida";
preenchimento();
}
Funo completa cdigo abaixo:

void preenchimento()
{
int x=0,y=0;
cout<<"Entre com a Posico X e Y \n Posicao X:";
cin>>x;
cout<<"Posicao Y:";
cin>>y;
if((x<=3)&&(x>0)&&(y<=3)&&(y>0)&&(matrix[x-1][y-1]==' '))
{
}else
{
preenchimento();
}
}
3.1.4. Funo teste
O objetivo desta funo e verificar se houve vencedor , como so poucas coisas a
analisar foi feito um a um de forma que fique bem clara a analise.
Mais uma vez levando a considerao a figura.
Fica fcil perceber quais as condies a testar , por exemplo considerando a

horizontal e s testar se o valor qus esta na posio [0][0] igual a[0][1] e igual
a[0][2], assim testando linha por linha na vertical,uma coisa interessante a reparar
que alem dos trs terem que serem iguais eles tem quer ser diferente de (vazio)
Segue a funo completa abaixo repare qus esta bem explicada, ento no
preciso entrar em muito detalhes na parte de quem ganhou.
void teste()
{
//teste horizontal
if((matrix[0][0]==matrix[0][1])&&(matrix[0][1]==matrix[0][2])&&(matrix[0][0]!
=' '))
{
termino=1;
venceu=matrix[0][0];
fimjogo();
}
=' '))
{
termino=1;
fimjogo();
}
=' '))
{
termino=1;
fimjogo();
}
//teste vertical
=' '))
{
termino=1;
fimjogo();
}
=' '))
{
termino=1;
fimjogo();
}
=' '))
{
termino=1;
fimjogo();
}
//teste na digonal
=' '))
{
termino=1;
fimjogo();
}
=' '))
{
termino=1;
fimjogo();
}
// teste sedeu velha
if ((jogada==5)&&(venceu==' '))
{
system("cls");
cout<<"\n\n de Velha \n digite s para Jogar de novo:";
char denovo;
cin>>denovo;
if(denovo=='s')
{
termino=0;
jogada=0;
jogo();
}
}
}
Um ponto importante a salientar o teste se deu velha, uma observao, Maximo de jogadas
que um jogador consegue realizar 5 , ento se o numero de jogada for igual a 5 e venceu
iagual a (vazio) entaoo jogo deu velha.
Outro ponto importante deste cdigo, a possibilidade de jogar de novo a partida sem ter que
sair do programa e entrar de novo. Para isto foi declarado uma varivel chamada denovo se
a pessoa digitar s coloca a varivel termino como 0, e jogada tambm como 0, e chama a
funo jogo(), esta funo chama as demais funo do jogo, mais a frente ser falado dela.
3.2. Funes de movimento do Jogador O.

At o momento foi utilizada somente o movimento do jogador X( o movimento da
pessoa ), esta parte do trabalho e para fazer as jogadas do jogadorO , em 2 de 3
programas aqui tratados o jogador O ser o computador.
Ao contrario o que se pensa o mero de jogadas possveis no Jogo da Velha muito
grande, ento no vivel analisar cada situao para o computador realizar a jogada.
Ser abordados 3 tipos de possibilidades de jogador O:
Computador Sem analise
Computador com analise
Segunda pessoa jogando.
3.2.1. Computador sem analise (jogada burra).

Esta jogada, o tipo mais simples de jogada feito pelo computador, esta consiste
simplesmente no computador passar a matriz e primeiro espao vazio que
encontrar colocar o O;
O conceito bem simples, embora tem que tomar cuidados com alguns conceitos
lgicos, para contornar este conceitos foi criado uma varivel com o nome de
cond e iniciado com 0, assim depois de que efetuado a jogada do computador,
colocado e dentro desta varivel ai no acontecera mais movimento pelo
computador neste momento.
O trecho do cdigo mencionado segue abaixo:
if((cond==0)&&(matrix[x][y]==' '))
{
matrix[x][y]='O';
cond=1;
}
S acontece o movimento se cond igual a 0 e matrix*x+*y+== (vazio), elogo
coloca 1 dentro da varivel cond desta forma no executa mais de uma jogada
por vez.
Cdigo completo da funo segue abaixo:
void movimento()
{
int cond=0;
for (int x=0;x<=2;x++)
for (int y=0;y<=2;y++)
{
{
matrix[x][y]='O';
cond=1;
}
}}
3.2.2. Segunda Pessoa Jogando.

Esta segue o mesmo principio do explicado a funo preenchimento() ,
anteriormente mencionado, ento no entrarei em detalhes.
Segue o cdigo completo.
void movimentopessoa()
{
int x=0,y=0;

cin>>x;
cout<<"Posicao Y:";
cin>>y;
if((x<=3)&&(x>0)&&(y<=3)&&(y>0)&&(matrix[x-1][y-1]==' '))
{
matrix[x-1][y-1]='O';
}else
{
preenchimento();
}
}
3.2.3. Computador Com Analise (Inteligncia Artificial)
Foi deixado por ultimo por ser a parte mais complexa. Esta parte o tenta fazer o
computador parecer inteligente (por isto utilizei o termo Inteligncia Artificial).
Como j mencionei o mximo de jogadas um jogador pode fazer so 5 jogadas em
uma partida. Mas como a contagem comea do 0 ento se encontrar 4 e por causa
disto.
bem provvel que tenha como fazer isto de maneira mais dinmica, mas por
causa do fator tempo, vou demonstrar a analise por analise e desta forma fica
mais fcil de entender.
Vamos a analise ponto a ponto.
3.2.3.1. Analise da primeira jogada
Normalmente a primeira jogada feita pelas laterais
Caso a primeira jogada seja, em uma das 4 condies acima

O computador o marcar o quadrado do meio.
Caso seja marcado, o centro o computador marcar o quadrado do meio

esquerdo, conforme a figura abaixo:
Caso seja marcado algum outro quadrado o computador marcar o meio. Como j
definido anteriormente.
Trecho do cdigo da primeira jogada.
if(jogada==0)
{
if((matrix[0][0]==' ')&&(matrix[0][2]==' ')&&(matrix[2][0]=='
')&&(matrix[2][2]==' '))
{
if(matrix[1][1]==' ')
{
matrix[0][0]='O';
cond=1;
}else{
matrix[1][0]='O';
cond=1;
}
}else
{
matrix[1][1]='O';
cond=1;
}
}
Repare que possui uma varivel, cond e ela recebe 1, ES todas as condies esta
varivel, foi uma forma de encontra do jogador jogar s uma vez por partida. No
momento em a funo chamada inicia esta varivel com 0, e ento no inicio da
funo tem uma condio que s executar estes comandos caso cond for 0, e no
momento que acontece uma jogado do PC ele coloca 1 na cond e no executa
mais este bloco de cdigos.
3.2.3.2. Outras jogadas.
Apartir da segunda jogada o computador j tem material para analise.
E assim efetuar uma jogada de acordo com as condies, devo lembrar que as
combinaes de jogadas so muito grandes, mas tentei fazer isto pensar nas
jogadas mais comuns.
Separei a lgica basicamente em 3 situaoes:
Para fim de ganhar
Para atrapalhar
Jogada para preencher.
Pode reparar que basicamente ns quando estamos jogando usamos tambm,
esta estratgia, se no posso ganhar, vou tentar atrapalhar o outro ganhar , e um
terceira opo em que ainda no tem as condies suficiente para analisar para
efetuar as duas estatgia de cima , jogamos por jogar sem levar muita coisa em
considerao.
3.2.3.2.1.
Para fim de ganhar.

So as jogadas para completar o alinhamento.
Ela analisa as condies de alinhamento o que falta nestas e preenche.
E lembrando o mapa :
possvel, fazer o cdigo a seguir:

if((matrix[0][0]=='O')&&(matrix[0][2]=='O')&&(matrix[0][1]==' '))
{
matrix[0][1]='O';
cond=1;
}else
{
matrix[0][2]='O';
cond=1;
}else
{
matrix[0][0]='O';
cond=1;
}else
{
matrix[1][0]='O';
cond=1;
}else
{
matrix[2][0]='O';
cond=1;
}else
{
matrix[0][0]='O';
cond=1;
}else
{
matrix[2][1]='O';
cond=1;
}else
{
matrix[2][2]='O';
cond=1;
}else
{
matrix[2][0]='O';
cond=1;
}else
{
matrix[1][2]='O';
cond=1;
}else
{
matrix[0][2]='O';
cond=1;
}else
{
matrix[2][2]='O';
cond=1;
}else
{
matrix[1][1]='O';
cond=1;
}else
{
matrix[2][1]='O';
cond=1;
}else
{
matrix[0][1]='O';
cond=1;
}else
if((matrix[0][0]=='X')&&(matrix[2][2]=='X')&&(matrix[1][1]==' '))
{
matrix[1][1]='O';
cond=1;
}else
{
matrix[2][2]='O';
cond=1;
}else
{
matrix[0][0]='O';
cond=1;
}else
{
matrix[1][1]='O';
cond=1;
}else
{
matrix[2][0]='O';
cond=1;
}else
{
matrix[0][2]='O';
cond=1;
}
O cdigo acima bem simples, ento no vejo por que explicar cada linha. No geral s analisa
cada linha como demonstrei as situaes possveis na figura das jogadas para ganhar, e
preenche o que faltar para poder fazer o alinhamento.
3.2.3.2.2.
Para atrapalhar.
Esta situao consiste aquele momento em que o adversrio esta quase
formando um alinhamento e vc vai La e atrapalha.
As condies so a mesma para ganhar se que neste momento , analisado a
situao das peas do adversrio, e ento vai La e atrapalha.
Figura de possibilidades:
Estas so as possibilidades, ento o PC (computador) vai analisar estas

condies assim que encontrar algumas desta ele preenche da com O assim
atrapalhando.
Cdigo abaixo:
{
matrix[0][1]='O';
cond=1;
}else
{
matrix[0][2]='O';
cond=1;
}else
{
matrix[0][0]='O';
cond=1;
}else
{
matrix[1][0]='O';
cond=1;
}else
{
matrix[2][0]='O';
cond=1;
}else
{
matrix[0][0]='O';
cond=1;
}else
{
matrix[2][1]='O';
cond=1;
}else
{
matrix[2][2]='O';
cond=1;
}else
{
matrix[2][0]='O';
cond=1;
}else
{
matrix[1][2]='O';
cond=1;
}else
{
matrix[0][2]='O';
cond=1;
}else
{
matrix[2][2]='O';
cond=1;
}else
{
matrix[1][1]='O';
cond=1;
}else
{
matrix[2][1]='O';
cond=1;
}else
{
matrix[0][1]='O';
cond=1;
}else
{
matrix[1][1]='O';
cond=1;
}else
{
matrix[2][2]='0';
cond=1;
}else
{
matrix[0][0]='O';
cond=1;
}else
{
matrix[1][1]='O';
cond=1;
}else
{
matrix[2][0]='O';
cond=1;
}else
{
matrix[0][2]='O';
cond=1;
}
Como j mencionado o cdigo muito simples,no tem nenhuma
complicao.
3.2.3.2.3.
Jogada para preencher

Tenho que admitir esta parte da estratgia um pouco fraca, assim no leva
muita coisa em considerao. esta situao acontece quando as condies as
condies de alinhamento ainda no aconteceu. Ento esta parte do cdigo,
percorre a matriz e o primeiro espao em branco que encontrar preenche com
O, poderia ter alguma analise para realizar algumas jogadas mais
interessantes, mas por falta de tempo (e o que me propus), at este ponto me
dou por satisfeito.
Cdigo abaixo.
for (int x=0;x<3;x++)
for (int y=0;y<3;y++)
{
{
matrix[x][y]='O';
cond=1;
}
}
O cdigo acima, bem simples e j detalhei anteriormente.
Cdigo completo da funo abaixo:

void movimento()
{
int cond=0;
if (cond==0)
{
if(jogada==0)
{
')&&(matrix[2][2]==' '))
{
if(matrix[1][1]==' ')
{
matrix[0][0]='O';
cond=1;
}else{
matrix[1][0]='O';
cond=1;
}
}else
{
matrix[1][1]='O';
cond=1;
}
}
else
{
{
matrix[0][1]='O';
cond=1;
}else
{
matrix[0][2]='O';
cond=1;
}else
{
matrix[0][0]='O';
cond=1;
}else
{
matrix[1][0]='O';
cond=1;
}else
{
matrix[2][0]='O';
cond=1;
}else
{
matrix[0][0]='O';
cond=1;
}else
{
matrix[2][1]='O';
cond=1;
}else
{
matrix[2][2]='O';
cond=1;
}else
{
matrix[2][0]='O';
cond=1;
}else
{
matrix[1][2]='O';
cond=1;
}else
{
matrix[0][2]='O';
cond=1;
}else
{
matrix[2][2]='O';
cond=1;
}else
{
matrix[1][1]='O';
cond=1;
}else
{
matrix[2][1]='O';
cond=1;
}else
{
matrix[0][1]='O';
cond=1;
}else
{
matrix[1][1]='O';
cond=1;
}else
{
matrix[2][2]='O';
cond=1;
}else
{
matrix[0][0]='O';
cond=1;
}else
{
matrix[1][1]='O';
cond=1;
}else
{
matrix[2][0]='O';
cond=1;
}else
{
matrix[0][2]='O';
cond=1;
}else
//para atrapalhar o oponente a ganhar
{
matrix[0][1]='O';
cond=1;
}else
{
matrix[0][2]='O';
cond=1;
}else
{
matrix[0][0]='O';
cond=1;
}else
{
matrix[1][0]='O';
cond=1;
}else
{
matrix[2][0]='O';
cond=1;
}else
{
matrix[0][0]='O';
cond=1;
}else
{
matrix[2][1]='O';
cond=1;
}else
{
matrix[2][2]='O';
cond=1;
}else
{
matrix[2][0]='O';
cond=1;
}else
{
matrix[1][2]='O';
cond=1;
}else
{
matrix[0][2]='O';
cond=1;
}else
{
matrix[2][2]='O';
cond=1;
}else
{
matrix[1][1]='O';
cond=1;
}else
{
matrix[2][1]='O';
cond=1;
}else
{
matrix[0][1]='O';
cond=1;
}else
{
matrix[1][1]='O';
cond=1;
}else
{
matrix[2][2]='0';
cond=1;
}else
{
matrix[0][0]='O';
cond=1;
}else
{
matrix[1][1]='O';
cond=1;
}else
{
matrix[2][0]='O';
cond=1;
}else
{
matrix[0][2]='O';
cond=1;
}
else{
{
{
matrix[x][y]='O';
cond=1;
}
}
}
}} }
3.3. Tapando as lacunas.

Aps desenvolver, cada funo percebe-se que faltam alguns pontos, como se o
usurio quiser jogar de novo, para isto foi feita mais duas funes.
Funo fim de jogo
Funo jogo
E o main que a funo me de todo programa ela que chama todas as demais
funes.
Funo fim de jogo
Cdigo completo abaixo
void fimjogo()
{
system("cls");
mostrar();
cout<<"o jogador "<<venceu<<" Venceu\n digite s para jogar de novo: ";
char denovo;
cin>>denovo;
if(denovo=='s')
{
venceu=' ';
termino=0;
jogada=0;
jogo();
}
}
Esta funo e chamada pela funo teste, ela tem a funo de mostrar quem
ganhou e se deseja jogar de novo.
Funo jogo
Cdigo da funo abaixo:
void jogo()
{
if (jogada==0) iniciacao();
mostrar();
preenchimento();
teste();
movimento();
teste();
}
Esta funo chama as funes em ordem, lgica.
Repare que logo inicio tem uma condio se a varivel jogada for igual a 0,
chamada a funo iniciao , isto para o caso do usurio quiser jogar de novo ai o
programa limpa a matriz para o novo jogo.
Funo main
Cdigo completo da funo.
int main()
{
while ((jogada<=9)&&(termino!=1))
{
jogo();
jogada++;
}
system("pause");
}
Pode ver que uma funo bem simples por que eu concentrei as chamadas das funes
dentro de outras como por exemplo a funo jogo e a funo teste.
Basicamente esta funo chama a funo jogo, e incrementa a varivel jogada,

E impe a condio que isto vai acontecer enquando o termino ser diferente de 1 e jogada
menor igual a 9.
4. JOGO COMPLETO JOGO DA VELHA, COMPUTADOR INTELIGENTE.
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
using namespace std;
char matrix[3][3];
int termino=0, jogada=0;
char venceu=' ';
void iniciacao();
void mostrar();
void preenchimento();
void movimento();
void jogo();
void fimjogo();
void teste();
int main()
{
{
jogo();
jogada++;
}
system("pause");
}
void iniciacao()
{
matrix[x][y]=' ';
}
void mostrar()
{
system("cls");
<<" --|--|--\n"
<<" --|--|--\n"
<< " "<< matrix[2][0] <<" | "<< matrix[2][1] <<"| "<<
matrix[2][2]<<"\n"<<endl;
}
{
int x=0,y=0;

cin>>x;
cout<<"Posicao Y:";
cin>>y;
if((x<=3)&&(x>0)&&(y<=3)&&(y>0)&&(matrix[x-1][y-1]==' '))
{
}else
{
preenchimento();
}
}
void movimento()
{
int cond=0;
if (cond==0)
{
if(jogada==0)
{
')&&(matrix[2][2]==' '))
{
if(matrix[1][1]==' ')
{
matrix[0][0]='O';
cond=1;
}else{
matrix[1][0]='O';
cond=1;
}
}else
{
matrix[1][1]='O';
cond=1;
}
}
else
{
{
matrix[0][1]='O';
cond=1;
}else
if((matrix[0][0]=='O')&&(matrix[0][1]=='O')&&(matrix[0][2]=='
'))
{
matrix[0][2]='O';
cond=1;
}else
'))
{
matrix[0][0]='O';
cond=1;
}else
'))
{
matrix[1][0]='O';
cond=1;
}else
'))
{
matrix[2][0]='O';
cond=1;
}else
'))
{
matrix[0][0]='O';
cond=1;
}else
'))
{
matrix[2][1]='O';
cond=1;
}else
'))
{
matrix[2][2]='O';
cond=1;
}else
'))
{
matrix[2][0]='O';
cond=1;
}else
'))
{
matrix[1][2]='O';
cond=1;
}else
'))
{
matrix[0][2]='O';
cond=1;
}else
'))
{
matrix[2][2]='O';
cond=1;
}else
'))
{
matrix[1][1]='O';
cond=1;
}else
'))
{
matrix[2][1]='O';
cond=1;
}else
'))
{
matrix[0][1]='O';
cond=1;
}else
{
matrix[1][1]='O';
cond=1;
}else
'))
{
matrix[2][2]='O';
cond=1;
}else
'))
{
matrix[0][0]='O';
cond=1;
}else
'))
{
matrix[1][1]='O';
cond=1;
}else
'))
{
matrix[2][0]='O';
cond=1;
}else
'))
{
matrix[0][2]='O';
cond=1;
}else
if((matrix[0][0]=='X')&&(matrix[0][2]=='X')&&(matrix[0][1]=='
'))
{
matrix[0][1]='O';
cond=1;
}else
'))
{
matrix[0][2]='O';
cond=1;
}else
'))
{
matrix[0][0]='O';
cond=1;
}else
'))
{
matrix[1][0]='O';
cond=1;
}else
'))
{
matrix[2][0]='O';
cond=1;
}else
'))
{
matrix[0][0]='O';
cond=1;
}else
'))
{
matrix[2][1]='O';
cond=1;
}else
'))
{
matrix[2][2]='O';
cond=1;
}else
'))
{
matrix[2][0]='O';
cond=1;
}else
'))
{
matrix[1][2]='O';
cond=1;
}else
'))
{
matrix[0][2]='O';
cond=1;
}else
'))
{
matrix[2][2]='O';
cond=1;
}else
'))
{
matrix[1][1]='O';
cond=1;
}else
'))
{
matrix[2][1]='O';
cond=1;
}else
'))
{
matrix[0][1]='O';
cond=1;
}else
'))
{
matrix[1][1]='O';
cond=1;
}else
'))
{
matrix[2][2]='0';
cond=1;
}else
'))
{
matrix[0][0]='O';
cond=1;
}else
'))
{
matrix[1][1]='O';
cond=1;
}else
'))
{
matrix[2][0]='O';
cond=1;
}else
'))
{
matrix[0][2]='O';
cond=1;
}
else{
{
{
matrix[x][y]='O';
cond=1;
}
}
}
}
}
}
void jogo()
{
mostrar();
preenchimento();
teste();
movimento();
teste();
}
void fimjogo()
{
system("cls");
mostrar();
char denovo;
cin>>denovo;
if(denovo=='s')
{
venceu=' ';
termino=0;
jogada=0;
jogo();
}
}
void teste()
{
//teste horizontal
=' '))
{
termino=1;
fimjogo();
}
=' '))
{
termino=1;
fimjogo();
}
=' '))
{
termino=1;
fimjogo();
}
//teste vertical
=' '))
{
termino=1;
fimjogo();
}
=' '))
{
termino=1;
fimjogo();
}
=' '))
{
termino=1;
fimjogo();
}
//teste na digonal
=' '))
{
termino=1;
fimjogo();
}
=' '))
{
termino=1;
fimjogo();
}
{
system("cls");
char denovo;
cin>>denovo;
if(denovo=='s')
{
venceu=' ';
termino=0;
jogada=0;
jogo();
}
}
}
5. JOGO DA VELHA COMPLETO COMPUTADOR , SEM ANALISE.

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
char matrix[3][3];
char venceu=' ';
void iniciacao();
void mostrar();
void movimento();
void jogo();
void fimjogo();
void teste();
int main()
{
{
jogo();
jogada++;
}
system("pause");
}
void iniciacao()
{
matrix[x][y]=' ';
}
void mostrar()
{
system("cls");
<<" --|--|--\n"
<<" --|--|--\n"
<< " "<< matrix[2][0] <<" | "<< matrix[2][1] <<"| "<<
}
{
int x=0,y=0;

cin>>x;
cout<<"Posicao Y:";
cin>>y;
if((x<=3)&&(x>0)&&(y<=3)&&(y>0)&&(matrix[x-1][y-1]==' '))
{
}else
{
preenchimento();
}
}
void movimento()
{
int cond=0;

{
{
matrix[x][y]='O';
cond=1;
}
}}
void jogo()
{
mostrar();
preenchimento();
teste();
movimento();
teste();
}
void fimjogo()
{
system("cls");
mostrar();
char denovo;
cin>>denovo;
if(denovo=='s')
{
venceu=' ';
termino=0;
jogada=0;
jogo();
}
}
void teste()
{
//teste horizontal
=' '))
{
termino=1;
fimjogo();
}
=' '))
{
termino=1;
fimjogo();
}
=' '))
{
termino=1;
fimjogo();
}
//teste vertical
=' '))
{
termino=1;
fimjogo();
}
=' '))
{
termino=1;
fimjogo();
}
=' '))
{
termino=1;
fimjogo();
}
//teste na digonal
=' '))
{
termino=1;
fimjogo();
}
=' '))
{
termino=1;
fimjogo();
}
{
system("cls");
char denovo;
cin>>denovo;
if(denovo=='s')
{
venceu=' ';
termino=0;
jogada=0;
jogo();
}
}
}
6. JOGO DA VELHA COMPLETO, PESSOA X PESSOA.

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
char matrix[3][3];
char venceu=' ';
void iniciacao();
void mostrar();
void movimento();
void jogo();
void fimjogo();
void teste();
int main()
{
{
jogo();
jogada++;
}
system("pause");
}
void iniciacao()
{
matrix[x][y]=' ';
}
void mostrar()
{
system("cls");
<<" --|--|--\n"
<<" --|--|--\n"
<< " "<< matrix[2][0] <<" | "<< matrix[2][1] <<"| "<<
}
{
int x=0,y=0;

cin>>x;
cout<<"Posicao Y:";
cin>>y;
if((x<=3)&&(x>0)&&(y<=3)&&(y>0)&&(matrix[x-1][y-1]==' '))
{
}else
{
preenchimento();
}
}
void movimento()
{
int x=0,y=0;

cin>>x;
cout<<"Posicao Y:";
cin>>y;
if((x<=3)&&(x>0)&&(y<=3)&&(y>0)&&(matrix[x-1][y-1]==' '))
{
}else
{
preenchimento();
}
}
void jogo()
{
mostrar();
preenchimento();
teste();
movimento();
teste();
}
void fimjogo()
{
system("cls");
mostrar();
char denovo;
cin>>denovo;
if(denovo=='s')
{
venceu=' ';
termino=0;
jogada=0;
jogo();
}
}
void teste()
{
//teste horizontal
=' '))
{
termino=1;
fimjogo();
}
=' '))
{
termino=1;
fimjogo();
}
=' '))
{
termino=1;
fimjogo();
}
//teste vertical
=' '))
{
termino=1;
fimjogo();
}
=' '))
{
termino=1;
fimjogo();
}
=' '))
{
termino=1;
fimjogo();
}
//teste na digonal
=' '))
{
termino=1;
fimjogo();
}
=' '))
{
termino=1;
fimjogo();
}
{
system("cls");
char denovo;
cin>>denovo;
if(denovo=='s')
{
venceu=' ';
termino=0;
jogada=0;
jogo();
}
}
}
7. Concluso
Quis aqui fazer um material completo, sobre este jogo , e explicando passo a passo. E
cada raciocnio que seguir, bem provvel, que se desenvolvesse este cdigo de novo
, varia de outra forma, de uma maneira talvez mais dinmica.
Foi desenvolvido um jogo da velha pode ter algumas melhorias, mas no tempo em que
tive me dou como satisfeito, em obter estes resultados.
Jogo da Velha em C/C++, aqui se encontra o programa completo , e

explicado passo a passo.
So 3 verses, deste programa, eles so:
JOGO DA VELHA,(JOGADOR X JOGADOR)

JOGO DA VELHA,(JOGADOR X COMPUTADOR_BURRO).
JOGO DA VELHA, (JOGADOR X COMPUTADOR_INTELIGENTE ).
Este programa , tem uma verso que simula uma inteligncia artificial. uma
parte interessante do programa.
Jogo da Velha em C e C++
Objetivo
Fazer um jogo da velha em c/c++, e explicar como funciona e como formar um
raciocnio para este programa.
Compilador utilizado: DEV C++ 4.9.9.2.
1.
1. Origem Jogo da Velha ou Jogo do Galo.
Jogo, com Regras simples , recebeu este nome na Inglaterra quando um grupo de
mulheres que se reuniam para conversar e bordar , as idosas por causas das
debilidades e suas vises, jogavam este jogo. Por isto o nome Jogo da Velha por que
em maiorias eram as idosas que jogavam , como no poderiam bordar e fazer outras
coisas nos seus momentos de distraes.
Este Jogo foi encontrados em diversas culturas da antiguidade, um deles foram
encontrados no Egito com data do sculo XIV antes de Cristo. E na china com data de
500 A.C.
Tambm encontradas na Amrica Pr-Colombiana.
Referncias (acessado em 22/12/2013 as 15:35)

http://mundoestranho.abril.com.br/materia/qual-ea-origem-do-jogodavelha
http://www.jogos.antigos.nom.br/jvelha.asp
http://pt.wikipedia.org/wiki/Jogo_da_velha
2.
Explicao Jogo da Velha:
Este jogo consiste em um campo com 9 posies em que 2 jogadores normalmente

jogadores 1 usa X, e jogador 2 usa O , o objetivo do jogo alinhar 3 X ou 3 O ,
podendo ser na horizontal, vertical ou nas diagonais . E um alinhamento significa que
o jogador Venceu. Caso nenhum dos dois consiga alinhar significa que Deu Velha, ou
seja, nenhum dos dois ganhou.
A figura mostra como composto o campo do Jogo da Velha
Alinhamentos nas
horizontais
Alinhamentos nas verticais Alinhamentos das diagonais
Uma regra que ao ficou clara acima que um jogador realiza uma jogada de cada vez,
assim o primeiro realiza uma jogada a e depois o outro.
E todos os alinhamentos podem ser feitos por qualquer um jogador.
1.
3. Programa Jogo Da Velha

Ser mostrado diversos programas de jogos da velha. Alguns bem trabalhados
e outros simples.Ser analisado algumas forma de fazer o programas at a
efetuar jogadas, simulando uma inteligncia artificial.
Algumas funes do jogo da velha ser a mesma para todos ento ser
descrito a seguir.
3.1. Funoes padres para todos os programas

Aqui ser mostrada e explicadas, as funes comum a todos os programas
Jogo da Velha.
3.1.1.
funo de iniciao
Esta funo tem o objetivo de esvaziar (ou preencher com um caractere
conhecido ) a matriz do jogo.
O campo do Jogo da Velha, representada por uma matriz 3 por 3.
Segue a declarao desta matriz.
char matrix[3][3];
para evitar possveis erros de lgica uma boa forma de evitar isto
inicializar a matriz.
O comando for utilizado para efetuar repetio e assim preencher a
matriz de uma forma rpida.
void iniciacao()
{
matrix[x][y]=' ';
}
Na linha void iniciacao() , esta uma forma declarao de funo o void
significa que ir retornar vazio , ou seja que no retornara nada.
O comando:
Tem a funo de percorrer toda a matriz , como esta matriz em questo 3

por 3 , foi declarada assim significa que a matriz que a primeira posio dela
em x 0 e a ultima 2, (lembrando que a matriz comea a contar do 0, no do
1 como estamos acostumados), o mesmo vale para o y.
A figura mostra como comportamento da matriz, e suas posio [x][y]

correspondente.
Este trecho poderia ser assim tambm:

for(int x=0;x<=2;x++)
for(int y=0;y<=2;y++)
o comando acima s mudou a condio mas acaba sendo a mesma coisa j que x e y
so inteiros.
O comando
matrix[x][y]=' ';
este comando se encontra dentro do for ou seja com a variao de x e y vai
preenchendo todas as posies com (vazio).
3.1.2.
Funo mostrar.
Objetivo desta funo mostrar a matriz com os seus devidos valores preenchidos,
esta funo foi feita de uma bem simples.
void mostrar()
{
system("cls");
cout<<" "<< matrix[0][0] <<" | "<< matrix[0][1] <<"| "<< matrix[0][2]
<<"\n"
<<" --|--|--\n"
<<" --|--|--\n"
<< " "<< matrix[2][0] <<" | "<< matrix[2][1] <<"| "<<
}
O que pode ser reparado aqui neste trecho a funo system(cls), esta funo
limpa a tela, o comando, cout<< ,tem a funo de mostra na tela, pode reparar
diversos espaos vazios , eles tem a simples funo te dar algum espao para
ficar as linhas e colunas ficarem bem alinhados.
O comando <<endl ele normalmente usado com o cout como mostra acima e
ele serve para forar o cout a jogar os dados na tela.
Pode reparar que a funo mostrar segue este idia da figura.
3.1.3.
Funo de preenchimento
Esta funo tem com o objetivo de ns entrarmos com o dado, ou seja nos falarmos
aonde ser marcado o X
Como toda funo inicia com o

tipo de retorno e nome da funo()
no caso; void preenchimento() significa que retornar nada e a funo tem
o nome de preenchimento.
Esta funo tem algumas coisas interessantes foi levado em considerao como nos
interpretamos. Ao invs de nos considerar que inicie com 0 podemos considerar que a
contagem comece com 1 , a figura abaixo mostra este fato, se torna muito mais fcil
pensar que a contagem comece com 1 .
Para corrigir este erro foi feito o seguinte subtrado 1 da posio x e y no momento
em que gravado o valor x na posio cdigo abaixo:
simplesmente foi subtrado 1 das posies x e y , fica como a figura abaixo
Aps o recebimento dos dados feito pelo comando cin>>, feito a analise
Com o comando IF , a condio analisada se x e maior que zero e menor igual

que 3, e se y maior que zero e menor igual a 3, se o campo em questo se
encontra como (vazio). Feito pelo comando abaixo:
matrix[x-1][y-1]==' ', se esta e as outras condies forem verdadeiras ento
armazenada o X na posio digitada.
Caso for falsa a condio dentro do comando if executado o bloco de comando
dentro do else que chama a prpria funo preenchimento como mostra trecho de
programa abaixo:
else
{
preenchimento();
}
Funo completa cdigo abaixo:

{
int x=0,y=0;
cin>>x;
cout<<"Posicao Y:";
cin>>y;
if((x<=3)&&(x>0)&&(y<=3)&&(y>0)&&(matrix[x-1][y-1]==' '))
{
}else
{
preenchimento();
}
}
3.1.4.
Funo teste
O objetivo desta funo e verificar se houve vencedor , como so poucas
coisas a analisar foi feito um a um de forma que fique bem clara a analise.
Mais uma vez levando a considerao a figura.
Fica fcil perceber quais as condies a testar , por exemplo considerando

a horizontal e s testar se o valor qus esta na posio [0][0] igual a[0][1]
e igual a[0][2], assim testando linha por linha na vertical,uma coisa

interessante a reparar que alem dos trs terem que serem iguais eles tem
quer ser diferente de (vazio)
Segue a funo completa abaixo repare qus esta bem explicada, ento
no preciso entrar em muito detalhes na parte de quem ganhou.
void teste()
{
//teste horizontal
if((matrix[0][0]==matrix[0][1])&&(matrix[0][1]==matrix[0][2])&&(matrix[0
][0]!=' '))
{
termino=1;
fimjogo();
}
][0]!=' '))
{
termino=1;
fimjogo();
}
][0]!=' '))
{
termino=1;
fimjogo();
}
//teste vertical
][0]!=' '))
{
termino=1;
fimjogo();
}
][1]!=' '))
{
termino=1;
fimjogo();
}
][2]!=' '))
{
termino=1;
fimjogo();
}
//teste na digonal
][0]!=' '))
{
termino=1;
fimjogo();
}
][2]!=' '))
{
termino=1;
fimjogo();
}
{
system("cls");
char denovo;
cin>>denovo;
if(denovo=='s')
{
termino=0;
jogada=0;
jogo();
}
}
}
Um ponto importante a salientar o teste se deu velha, uma observao, Maximo de

jogadas que um jogador consegue realizar 5 , ento se o numero de jogada for igual
a 5 e venceu iagual a (vazio) entaoo jogo deu velha.
Outro ponto importante deste cdigo, a possibilidade de jogar de novo a partida sem
ter que sair do programa e entrar de novo. Para isto foi declarado uma varivel
chamada denovo se a pessoa digitar s coloca a varivel termino como 0, e
jogada tambm como 0, e chama a funo jogo(), esta funo chama as demais
funo do jogo, mais a frente ser falado dela.
3.2. Funes de movimento do Jogador O.

At o momento foi utilizada somente o movimento do jogador X( o
movimento da pessoa ), esta parte do trabalho e para fazer as jogadas do
jogadorO , em 2 de 3 programas aqui tratados o jogador O ser o
computador.
Ao contrario o que se pensa o mero de jogadas possveis no Jogo da
Velha muito grande, ento no vivel analisar cada situao para o
computador realizar a jogada.
Ser abordados 3 tipos de possibilidades de jogador O:
Computador Sem analise
Computador com analise
Segunda pessoa jogando.
3.2.1.
Computador sem analise (jogada burra).
Esta jogada, o tipo mais simples de jogada feito pelo computador, esta consiste
simplesmente no computador passar a matriz e primeiro espao vazio que encontrar
colocar o O;
O conceito bem simples, embora tem que tomar cuidados com alguns conceitos
lgicos, para contornar este conceitos foi criado uma varivel com o nome de cond e
iniciado com 0, assim depois de que efetuado a jogada do computador, colocado e
dentro desta varivel ai no acontecera mais movimento pelo computador neste
momento.
O trecho do cdigo mencionado segue abaixo:
{
matrix[x][y]='O';
cond=1;
}
S acontece o movimento se cond igual a 0 e matrix[x][y]== (vazio), elogo coloca 1
dentro da varivel cond desta forma no executa mais de uma jogada por vez.
Cdigo completo da funo segue abaixo:
void movimento()
{
int cond=0;
{
{
matrix[x][y]='O';
cond=1;
}
}}
3.2.2.
Segunda Pessoa Jogando.
Esta segue o mesmo principio do explicado a funo preenchimento() , anteriormente

mencionado, ento no entrarei em detalhes.
Segue o cdigo completo.
void movimentopessoa()
{
int x=0,y=0;

cin>>x;
cout<<"Posicao Y:";
cin>>y;
if((x<=3)&&(x>0)&&(y<=3)&&(y>0)&&(matrix[x-1][y-1]==' '))
{
}else
{
preenchimento();
}
}
3.2.3.
Computador Com Analise (Inteligncia Artificial)
Foi deixado por ultimo por ser a parte mais complexa. Esta parte o tenta
fazer o computador parecer inteligente (por isto utilizei o termo Inteligncia
Artificial).
Como j mencionei o mximo de jogadas um jogador pode fazer so 5 jogadas em

uma partida. Mas como a contagem comea do 0 ento se encontrar 4 e por causa
disto.
bem provvel que tenha como fazer isto de maneira mais dinmica, mas por causa
do fator tempo, vou demonstrar a analise por analise e desta forma fica mais fcil de
entender.
Vamos a analise ponto a ponto.
3.2.3.1. Analise da primeira jogada
Normalmente a primeira jogada feita pelas laterais
Caso a primeira jogada seja, em uma das 4 condies acima

O computador o marcar o quadrado do meio.
Caso seja marcado, o centro o computador marcar o quadrado do meio esquerdo,

conforme a figura abaixo:
Caso seja marcado algum outro quadrado o computador marcar o meio. Como j
definido anteriormente.
Trecho do cdigo da primeira jogada.
if(jogada==0)
{
')&&(matrix[2][2]==' '))
{
if(matrix[1][1]==' ')
{
matrix[0][0]='O';
cond=1;
}else{
matrix[1][0]='O';
cond=1;
}
}else
{
matrix[1][1]='O';
cond=1;
}
}
Repare que possui uma varivel, cond e ela recebe 1, ES todas as condies esta
varivel, foi uma forma de encontra do jogador jogar s uma vez por partida. No
momento em a funo chamada inicia esta varivel com 0, e ento no inicio da
funo tem uma condio que s executar estes comandos caso cond for 0, e no
momento que acontece uma jogado do PC ele coloca 1 na cond e no executa mais
este bloco de cdigos.
3.2.3.2. Outras jogadas.
Apartir da segunda jogada o computador j tem material para analise.E assim efetuar
uma jogada de acordo com as condies, devo lembrar que as combinaes de
jogadas so muito grandes, mas tentei fazer isto pensar nas jogadas mais comuns.
Separei a lgica basicamente em 3 situaoes:
Para fim de ganhar
Para atrapalhar
Jogada para preencher.
Pode reparar que basicamente ns quando estamos jogando usamos tambm, esta
estratgia, se no posso ganhar, vou tentar atrapalhar o outro ganhar , e um terceira
opo em que ainda no tem as condies suficiente para analisar para efetuar as
duas estatgia de cima , jogamos por jogar sem levar muita coisa em considerao.
3.2.3.2.1.
Para fim de ganhar.
So as jogadas para completar o alinhamento.

Ela analisa as condies de alinhamento o que falta nestas e preenche.
E lembrando o mapa :
possvel, fazer o cdigo a seguir:
{
matrix[0][1]='O';
cond=1;
}else
{
matrix[0][2]='O';
cond=1;
}else
{
matrix[0][0]='O';
cond=1;
}else
{
matrix[1][0]='O';
cond=1;
}else
{
matrix[2][0]='O';
cond=1;
}else
{
matrix[0][0]='O';
cond=1;
}else
{
matrix[2][1]='O';
cond=1;
}else
{
matrix[2][2]='O';
cond=1;
}else
{
matrix[2][0]='O';
cond=1;
}else
{
matrix[1][2]='O';
cond=1;
}else
{
matrix[0][2]='O';
cond=1;
}else
{
matrix[2][2]='O';
cond=1;
}else
{
matrix[1][1]='O';
cond=1;
}else
{
matrix[2][1]='O';
cond=1;
}else
{
matrix[0][1]='O';
cond=1;
}else
{
matrix[1][1]='O';
cond=1;
}else
{
matrix[2][2]='O';
cond=1;
}else
{
matrix[0][0]='O';
cond=1;
}else
{
matrix[1][1]='O';
cond=1;
}else
{
matrix[2][0]='O';
cond=1;
}else
{
matrix[0][2]='O';
cond=1;
}
O cdigo acima bem simples, ento no vejo por que explicar cada linha. No geral
s analisa cada linha como demonstrei as situaes possveis na figura das jogadas
para ganhar, e preenche o que faltar para poder fazer o alinhamento.
3.2.3.2.2.
Para atrapalhar.
Esta situao consiste aquele momento em que o adversrio esta quase formando um
alinhamento e vc vai La e atrapalha.
As condies so a mesma para ganhar se que neste momento , analisado a

situao das peas do adversrio, e ento vai La e atrapalha.
Figura de possibilidades:
Estas so as possibilidades, ento o PC (computador) vai analisar estas

condies assim que encontrar algumas desta ele preenche da com O
assim atrapalhando.
Cdigo abaixo:
{
matrix[0][1]='O';
cond=1;
}else
{
matrix[0][2]='O';
cond=1;
}else
{
matrix[0][0]='O';
cond=1;
}else
{
matrix[1][0]='O';
cond=1;
}else
{
matrix[2][0]='O';
cond=1;
}else
{
matrix[0][0]='O';
cond=1;
}else
{
matrix[2][1]='O';
cond=1;
}else
{
matrix[2][2]='O';
cond=1;
}else
{
matrix[2][0]='O';
cond=1;
}else
{
matrix[1][2]='O';
cond=1;
}else
{
matrix[0][2]='O';
cond=1;
}else
{
matrix[2][2]='O';
cond=1;
}else
{
matrix[1][1]='O';
cond=1;
}else
{
matrix[2][1]='O';
cond=1;
}else
{
matrix[0][1]='O';
cond=1;
}else
{
matrix[1][1]='O';
cond=1;
}else
{
matrix[2][2]='0';
cond=1;
}else
{
matrix[0][0]='O';
cond=1;
}else
{
matrix[1][1]='O';
cond=1;
}else
{
matrix[2][0]='O';
cond=1;
}else
{
matrix[0][2]='O';
cond=1;
}
Como j mencionado o cdigo muito simples,no tem nenhuma
complicao.
3.2.3.2.3.
Jogada para preencher

Tenho que admitir esta parte da estratgia um pouco fraca, assim no
leva muita coisa em considerao. esta situao acontece quando as
condies as condies de alinhamento ainda no aconteceu. Ento
esta parte do cdigo, percorre a matriz e o primeiro espao em branco
que encontrar preenche com O, poderia ter alguma analise para
realizar algumas jogadas mais interessantes, mas por falta de tempo (e
o que me propus), at este ponto me dou por satisfeito.
Cdigo abaixo.
{
{
matrix[x][y]='O';
cond=1;
}
}
O cdigo acima, bem simples e j detalhei anteriormente.
O Cdigo abaixo o cdigo completo da funo misturando os 3

raciocnios de jogadas.
Cdigo completo da funo abaixo:
void movimento()
{
int cond=0;
if (cond==0)
{
if(jogada==0)
{
')&&(matrix[2][2]==' '))
{
if(matrix[1][1]==' ')
{
matrix[0][0]='O';
cond=1;
}else{
matrix[1][0]='O';
cond=1;
}
}else
{
matrix[1][1]='O';
cond=1;
}
}
else
{
'))
{
matrix[0][1]='O';
cond=1;
}else
{
matrix[0][2]='O';
cond=1;
}else
{
matrix[0][0]='O';
cond=1;
}else
{
matrix[1][0]='O';
cond=1;
}else
{
matrix[2][0]='O';
cond=1;
}else
{
matrix[0][0]='O';
cond=1;
}else
{
matrix[2][1]='O';
cond=1;
}else
{
matrix[2][2]='O';
cond=1;
}else
{
matrix[2][0]='O';
cond=1;
}else
{
matrix[1][2]='O';
cond=1;
}else
{
matrix[0][2]='O';
cond=1;
}else
{
matrix[2][2]='O';
cond=1;
}else
{
matrix[1][1]='O';
cond=1;
}else
{
matrix[2][1]='O';
cond=1;
}else
{
matrix[0][1]='O';
cond=1;
}else
'))
{
matrix[1][1]='O';
cond=1;
}else
{
matrix[2][2]='O';
cond=1;
}else
{
matrix[0][0]='O';
cond=1;
}else
{
matrix[1][1]='O';
cond=1;
}else
{
matrix[2][0]='O';
cond=1;
}else
{
matrix[0][2]='O';
cond=1;
}else
{
matrix[0][1]='O';
cond=1;
}else
{
matrix[0][2]='O';
cond=1;
}else
{
matrix[0][0]='O';
cond=1;
}else
{
matrix[1][0]='O';
cond=1;
}else
{
matrix[2][0]='O';
cond=1;
}else
{
matrix[0][0]='O';
cond=1;
}else
{
matrix[2][1]='O';
cond=1;
}else
{
matrix[2][2]='O';
cond=1;
}else
{
matrix[2][0]='O';
cond=1;
}else
{
matrix[1][2]='O';
cond=1;
}else
{
matrix[0][2]='O';
cond=1;
}else
{
matrix[2][2]='O';
cond=1;
}else
{
matrix[1][1]='O';
cond=1;
}else
{
matrix[2][1]='O';
cond=1;
}else
{
matrix[0][1]='O';
cond=1;
}else
{
matrix[1][1]='O';
cond=1;
}else
{
matrix[2][2]='0';
cond=1;
}else
{
matrix[0][0]='O';
cond=1;
}else
{
matrix[1][1]='O';
cond=1;
}else
{
matrix[2][0]='O';
cond=1;
}else
{
matrix[0][2]='O';
cond=1;
}
else{
{
{
matrix[x][y]='O';
cond=1;
}
}
}
}} }
3.3. Tapando as lacunas.

Aps desenvolver, cada funo percebe-se que faltam alguns pontos, como se
o usurio quiser
jogar de novo, para isto foi feita mais duas funes.
Funo fim de jogo
Funo jogo
E o main que a funo me de todo programa ela que chama todas as

demais funes.
Funo fim de jogo
Cdigo completo abaixo

void fimjogo()
{
system("cls");
mostrar();
cout<<"o jogador "<<venceu<<" Venceu\n digite s para jogar de
novo: ";
char denovo;
cin>>denovo;
if(denovo=='s')
{
venceu=' ';
termino=0;
jogada=0;
jogo();
}
}
Esta funo e chamada pela funo teste, ela tem a funo de mostrar
quem ganhou e se deseja jogar de novo.
Funo jogo
Cdigo da funo abaixo:

void jogo()
{
mostrar();
preenchimento();
teste();
movimento();
teste();
}
Esta funo chama as funes em ordem, lgica.
Repare que logo inicio tem uma condio se a varivel jogada for igual a 0,
chamada a funo iniciao , isto para o caso do usurio quiser jogar de
novo ai o programa limpa a matriz para o novo jogo.
Funo main
Cdigo completo da funo.

int main()
{
{
jogo();
jogada++;
}
system("pause");
}
Pode ver que uma funo bem simples por que eu concentrei as chamadas das
funes dentro de outras como por exemplo a funo jogo e a funo teste.
Basicamente esta funo chama a funo jogo, e incrementa a varivel jogada,

E impe a condio que isto vai acontecer enquando o termino ser diferente de 1 e
jogada menor igual a 9.
2.
4. JOGO COMPLETO JOGO DA VELHA, COMPUTADOR INTELIGENTE.

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
char matrix[3][3];
char venceu=' ';
void iniciacao();
void mostrar();
void movimento();
void jogo();
void fimjogo();
void teste();
int main()
{
{
jogo();
jogada++;
}
system("pause");
}
void iniciacao()
{
matrix[x][y]=' ';
}
void mostrar()
{
system("cls");
cout<<" "<< matrix[0][0] <<" | "<< matrix[0][1] <<"| "<<
matrix[0][2] <<"\n"
<<" --|--|--\n"
<< " "<< matrix[1][0] <<" | "<< matrix[1][1] <<"| "<<
matrix[1][2]<<"\n"
<<" --|--|--\n"
<< " "<< matrix[2][0] <<" | "<< matrix[2][1] <<"| "<<
}
{
int x=0,y=0;

cin>>x;
cout<<"Posicao Y:";
cin>>y;
if((x<=3)&&(x>0)&&(y<=3)&&(y>0)&&(matrix[x-1][y-1]==' '))
{
}else
{
preenchimento();
}
}
void movimento()
{
int cond=0;
if (cond==0)
{
if(jogada==0)
{
')&&(matrix[2][2]==' '))
{
if(matrix[1][1]==' ')
{
matrix[0][0]='O';
cond=1;
}else{
matrix[1][0]='O';
cond=1;
}
}else
{
matrix[1][1]='O';
cond=1;
}
}
else
{
{
matrix[0][1]='O';
cond=1;
}else
{
matrix[0][2]='O';
cond=1;
}else
{
matrix[0][0]='O';
cond=1;
}else
{
matrix[1][0]='O';
cond=1;
}else
{
matrix[2][0]='O';
cond=1;
}else
{
matrix[0][0]='O';
cond=1;
}else
{
matrix[2][1]='O';
cond=1;
}else
{
matrix[2][2]='O';
cond=1;
}else
{
matrix[2][0]='O';
cond=1;
}else
{
matrix[1][2]='O';
cond=1;
}else
{
matrix[0][2]='O';
cond=1;
}else
{
matrix[2][2]='O';
cond=1;
}else
{
matrix[1][1]='O';
cond=1;
}else
{
matrix[2][1]='O';
cond=1;
}else
{
matrix[0][1]='O';
cond=1;
}else
{
matrix[1][1]='O';
cond=1;
}else
{
matrix[2][2]='O';
cond=1;
}else
{
matrix[0][0]='O';
cond=1;
}else
{
matrix[1][1]='O';
cond=1;
}else
{
matrix[2][0]='O';
cond=1;
}else
{
matrix[0][2]='O';
cond=1;
}else
{
matrix[0][1]='O';
cond=1;
}else
{
matrix[0][2]='O';
cond=1;
}else
{
matrix[0][0]='O';
cond=1;
}else
{
matrix[1][0]='O';
cond=1;
}else
{
matrix[2][0]='O';
cond=1;
}else
{
matrix[0][0]='O';
cond=1;
}else
{
matrix[2][1]='O';
cond=1;
}else
{
matrix[2][2]='O';
cond=1;
}else
{
matrix[2][0]='O';
cond=1;
}else
{
matrix[1][2]='O';
cond=1;
}else
{
matrix[0][2]='O';
cond=1;
}else
{
matrix[2][2]='O';
cond=1;
}else
{
matrix[1][1]='O';
cond=1;
}else
{
matrix[2][1]='O';
cond=1;
}else
{
matrix[0][1]='O';
cond=1;
}else
{
matrix[1][1]='O';
cond=1;
}else
{
matrix[2][2]='0';
cond=1;
}else
{
matrix[0][0]='O';
cond=1;
}else
{
matrix[1][1]='O';
cond=1;
}else
{
matrix[2][0]='O';
cond=1;
}else
{
matrix[0][2]='O';
cond=1;
}
else{
{
{
matrix[x][y]='O';
cond=1;
}
}
}
}
}
}
void jogo()
{
mostrar();
preenchimento();
teste();
movimento();
teste();
}
void fimjogo()
{
system("cls");
mostrar();
novo: ";
char denovo;
cin>>denovo;
if(denovo=='s')
{
venceu=' ';
termino=0;
jogada=0;
jogo();
}
}
void teste()
{
//teste horizontal
if((matrix[0][0]==matrix[0][1])&&(matrix[0][1]==matrix[0][2])&&(matrix[0][0]
!=' '))
{
termino=1;
fimjogo();
}
!=' '))
{
termino=1;
fimjogo();
}
!=' '))
{
termino=1;
fimjogo();
}
//teste vertical
!=' '))
{
termino=1;
fimjogo();
}
!=' '))
{
termino=1;
fimjogo();
}
!=' '))
{
termino=1;
fimjogo();
}
//teste na digonal
!=' '))
{
termino=1;
fimjogo();
}
!=' '))
{
termino=1;
fimjogo();
}
{
system("cls");
char denovo;
cin>>denovo;
if(denovo=='s')
{
venceu=' ';
termino=0;
jogada=0;
jogo();
}
}
}
35.
JOGO DA VELHA COMPLETO COMPUTADOR , SEM ANALISE.

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
char matrix[3][3];
char venceu=' ';
void iniciacao();
void mostrar();
void movimento();
void jogo();
void fimjogo();
void teste();
int main()
{
{
jogo();
jogada++;
}
system("pause");
}
void iniciacao()
{
matrix[x][y]=' ';
}
void mostrar()
{
system("cls");
matrix[0][2] <<"\n"
<<" --|--|--\n"
<< " "<< matrix[1][0] <<" | "<< matrix[1][1] <<"| "<<
matrix[1][2]<<"\n"
<<" --|--|--\n"
<< " "<< matrix[2][0] <<" | "<< matrix[2][1] <<"| "<<
}
{
int x=0,y=0;

cin>>x;
cout<<"Posicao Y:";
cin>>y;
if((x<=3)&&(x>0)&&(y<=3)&&(y>0)&&(matrix[x-1][y-1]==' '))
{
}else
{
preenchimento();
}
}
void movimento()
{
int cond=0;
{
{
matrix[x][y]='O';
cond=1;
}
}}
void jogo()
{
mostrar();
preenchimento();
teste();
movimento();
teste();
}
void fimjogo()
{
system("cls");
mostrar();
novo: ";
char denovo;
cin>>denovo;
if(denovo=='s')
{
venceu=' ';
termino=0;
jogada=0;
jogo();
}
}
void teste()
{
//teste horizontal
!=' '))
{
termino=1;
fimjogo();
}
!=' '))
{
termino=1;
fimjogo();
}
!=' '))
{
termino=1;
fimjogo();
}
//teste vertical
!=' '))
{
termino=1;
fimjogo();
}
!=' '))
{
termino=1;
fimjogo();
}
!=' '))
{
termino=1;
fimjogo();
}
//teste na digonal
!=' '))
{
termino=1;
fimjogo();
}
!=' '))
{
termino=1;
fimjogo();
}
{
system("cls");
char denovo;
cin>>denovo;
if(denovo=='s')
{
venceu=' ';
termino=0;
jogada=0;
jogo();
}
}
}
6 6 JOGO DA VELHA COMPLETO, PESSOA X PESSOA.

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
char matrix[3][3];
char venceu=' ';
void iniciacao();
void mostrar();
void movimento();
void jogo();
void fimjogo();
void teste();
int main()
{
{
jogo();
jogada++;
}
system("pause");
}
void iniciacao()
{
matrix[x][y]=' ';
}
void mostrar()
{
system("cls");
matrix[0][2] <<"\n"
<<" --|--|--\n"
<< " "<< matrix[1][0] <<" | "<< matrix[1][1] <<"| "<<
matrix[1][2]<<"\n"
<<" --|--|--\n"
<< " "<< matrix[2][0] <<" | "<< matrix[2][1] <<"| "<<
}
{
int x=0,y=0;

cin>>x;
cout<<"Posicao Y:";
cin>>y;
if((x<=3)&&(x>0)&&(y<=3)&&(y>0)&&(matrix[x-1][y-1]==' '))
{
}else
{
preenchimento();
}
}
void movimento()
{
int x=0,y=0;

cin>>x;
cout<<"Posicao Y:";
cin>>y;
if((x<=3)&&(x>0)&&(y<=3)&&(y>0)&&(matrix[x-1][y-1]==' '))
{
}else
{
preenchimento();
}
}
void jogo()
{
mostrar();
preenchimento();
teste();
movimento();
teste();
}
void fimjogo()
{
system("cls");
mostrar();
novo: ";
char denovo;
cin>>denovo;
if(denovo=='s')
{
venceu=' ';
termino=0;
jogada=0;
jogo();
}
}
void teste()
{
//teste horizontal
!=' '))
{
termino=1;
fimjogo();
}
!=' '))
{
termino=1;
fimjogo();
}
!=' '))
{
termino=1;
fimjogo();
}
//teste vertical
!=' '))
{
termino=1;
fimjogo();
}
!=' '))
{
termino=1;
fimjogo();
}
!=' '))
{
termino=1;
fimjogo();
}
//teste na digonal
!=' '))
{
termino=1;
fimjogo();
}
!=' '))
{
termino=1;
fimjogo();
}
{
system("cls");
char denovo;
cin>>denovo;
if(denovo=='s')
{
venceu=' ';
termino=0;
jogada=0;
jogo();
}
}
}
57
Concluso
Quis aqui fazer um material completo, sobre este jogo , e explicando

passo a passo. E cada raciocnio que seguir, bem provvel, que se
desenvolvesse este cdigo de novo , varia de outra forma, de uma
maneira talvez mais dinmica.
Foi desenvolvido um jogo da velha pode ter algumas melhorias, mas no
tempo em que tive me dou como satisfeito, em obter estes resultados.

Jogo Da Velha em C e C

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Jogo Da Velha em C e C

Enviado por

Direitos autorais:

Formatos disponíveis

ADALBERTO MOUTINHO PINHEIRO

JOGO DA VELHA EM C/C++

Jogo da Velha em C e C++

Referncias (acessado em 22/12/2013 as 15:35)

2. Explicao Jogo da Velha:

Alinhamentos nas horizontais

Alinhamentos nas verticais

Alinhamentos das diagonais

3. Programa Jogo Da Velha

Segue a declarao desta matriz.

A figura mostra como comportamento da matriz, e suas posio [x][y] correspondente.

Pode reparar que a funo mostrar segue este idia da figura

3.1.3. Funo de preenchimento

Para corrigir este erro foi feito o seguinte subtrado 1 da posio x e y no

Funo completa cdigo abaixo:

Fica fcil perceber quais as condies a testar , por exemplo considerando a

3.2. Funes de movimento do Jogador O.

3.2.1. Computador sem analise (jogada burra).

3.2.2. Segunda Pessoa Jogando.

cout<<"Entre com a Posico X e Y \n Posicao X:";

Normalmente a primeira jogada feita pelas laterais

Caso a primeira jogada seja, em uma das 4 condies acima

Caso seja marcado, o centro o computador marcar o quadrado do meio

Para fim de ganhar.

possvel, fazer o cdigo a seguir:

Estas so as possibilidades, ento o PC (computador) vai analisar estas

Jogada para preencher

Cdigo completo da funo abaixo:

3.3. Tapando as lacunas.

Basicamente esta funo chama a funo jogo, e incrementa a varivel jogada,

using namespace std;

cout<<"Entre com a Posico X e Y \n Posicao X:";

5. JOGO DA VELHA COMPLETO COMPUTADOR , SEM ANALISE.

using namespace std;

cout<<"Entre com a Posico X e Y \n Posicao X:";

for (int x=0;x<=2;x++)

6. JOGO DA VELHA COMPLETO, PESSOA X PESSOA.

using namespace std;

cout<<"Entre com a Posico X e Y \n Posicao X:";

cout<<"Entre com a Posico X e Y \n Posicao X:";

Jogo da Velha em C/C++, aqui se encontra o programa completo , e

JOGO DA VELHA,(JOGADOR X JOGADOR)

JOGO DA VELHA, (JOGADOR X COMPUTADOR_INTELIGENTE ).

Jogo da Velha em C e C++

Compilador utilizado: DEV C++ 4.9.9.2.

1. Origem Jogo da Velha ou Jogo do Galo.

Referncias (acessado em 22/12/2013 as 15:35)

Explicao Jogo da Velha:

Este jogo consiste em um campo com 9 posies em que 2 jogadores normalmente

A figura mostra como composto o campo do Jogo da Velha

Alinhamentos nas verticais Alinhamentos das diagonais

3. Programa Jogo Da Velha

3.1. Funoes padres para todos os programas

Tem a funo de percorrer toda a matriz , como esta matriz em questo 3

A figura mostra como comportamento da matriz, e suas posio [x][y]

Este trecho poderia ser assim tambm:

Pode reparar que a funo mostrar segue este idia da figura.

Como toda funo inicia com o

simplesmente foi subtrado 1 das posies x e y , fica como a figura abaixo

Com o comando IF , a condio analisada se x e maior que zero e menor igual

Funo completa cdigo abaixo:

Fica fcil perceber quais as condies a testar , por exemplo considerando

e igual a[0][2], assim testando linha por linha na vertical,uma coisa