Voltamos à implementação do jogo de memorização de sequências de sinais.
Já programamos as funcionalidades de criação e apresentação da sequência de sinais, assim como a interação com o jogo.
Daremos continuidade com a programação do fluxo do jogo.
Parte 1 – Parte 2 – Parte 3 – Parte 4 – Parte 5
Revisando a Construção do Nosso Jogo de Memorização de Sinais
Com minha participação, a última postagem no blog não foi referente a esse conjunto de tutoriais e sim quanto a finalização da implementação do Shark Pong, aquele jogo desenvolvido praticamente do zero. Veja toda a saga aqui.
Dando sequencia aos trabalhos, quanto no último tutorial referente a essa série, nós vimos como adicionar interação no jogo. Fizemos com que a lâmpada referente ao botão apertado pelo jogador acenda, caso ele clique no seu respectivo botão. Além disso, fizemos com que a mesma apagasse quando o jogador tirava o dedo da tela. Isso faz com que a lâmpada fique acesa exatamente enquanto o jogador esteja apertando o botão correspondente a ela.
Nesse tutorial nós implementaremos o fluxo do jogo. Mas como funciona isso? Ele segue a seguinte lógica: o computador mostra a sequência de sinais, depois o jogador a informa por meio dos botões na tela. Essa lógica continua até que o jogador erra a sequência e o jogo é finalizado.
Vamos dividir o tutorial de hoje em: vez do computador e vez do jogador.
Vez do computador
Começaremos a edição do código declarando na classe “HelloWorld” os métodos especializados por fazer a transição entre a vez do computador apresentar a sequência e a vez do jogador apresentá-la. Abra o arquivo “HelloWorldScene.h” e adicione as seguintes linhas de código:
void vezDoComputador();
void vezDoJogador();
logo abaixo dessa:
int idToque;
Após as declarações, vamos começar implementando o método “vezDoComputador”. Abra o arquivo “HelloWorldScene.cpp” e adicione as seguintes linhas de código no final do arquivo.
void HelloWorld::vezDoComputador() {
setTouchEnabled(false);
HelloWorld::aumentaSequencia();
HelloWorld::mostraSequencia();
}
Note que é simples o procedimento necessário para fazer o jogador aumentar a sequência de sinais e apresentá-la na tela. Inicialmente, se impossibilita o jogador de fazer qualquer interação com o jogo desabilitando a tela de toque. Após isso, fazemos a sequência ser aumentada com um sinal a mais no final e, por último, apresentamos a sequência ao jogador.
Com o método “vezDoComputador” implementado, agora podemos dar o início correto ao jogo. Para fazer acontecer, basta chamar esse método logo após todas as inicializações do jogo. Para isso, apague a seguinte linha de código do arquivo “HelloWorldScene.cpp”:
setTouchEnabled(true);
e, nesse mesmo lugar, adicione a seguinte linha de código:
HelloWorld::vezDoComputador();
Após a sequência ter sido ampliada e apresentada ao jogador, precisamos fazer a transição para o jogo esperar a entrada do jogador. Note que é indispensável acionar a tela de toque para que o jogador possa entrar com a sequência. Na verdade, essa é, praticamente, a única necessidade nesse momento. Assim, vamos iniciar a inclusão dessa funcionalidade com a implementação do método “vezDoJogador”. Adicione as seguintes linhas de código no final do arquivo.
void HelloWorld::vezDoJogador() {
setTouchEnabled(true);
}
Para que a tela de toque seja acionada no momento correto, adicione as seguintes linhas de código:
CCDelayTime* tempoJogador = CCDelayTime::create(0.6*(1+HelloWorld::sequencia->count()));
CCCallFunc* chamadaVezDoJogador = CCCallFunc::create(this,callfunc_selector(HelloWorld::vezDoJogador));
CCSequence* seqFim = CCSequence::create(tempoJogador,chamadaVezDoJogador,NULL);
runAction(seqFim);
logo abaixo dessa:
HelloWorld::lampDir->runAction(CCSequence::create(seq4));
Se você analisar esse último código adicionado, perceberá que fizemos o jogo esperar a quantidade exata de tempo necessário para apresentar toda a sequência e, somente após isso, chamamos o método “vezDoJogador”.
Acabamos de incluir a transição entre a apresentação da sequência e a entrada do jogador.
Vez do jogador
Pensando na vez do jogador, nós precisamos identificar quantos botões o jogador já acertou. Isso é importante porque é necessário identificar em qual momento da sequência o jogador se encontra. Assim sendo, precisamos declarar uma variável na classe “HelloWorld” para que isso funcione. Abra o arquivo “HelloWorldScene.h” e adicione a seguinte linha de código:
int conta;
logo abaixo dessa:
int idToque;
Essa variável precisa armazenar zero toda vez que o jogo aumenta em um sinal a mais na sequência. Assim, toda vez que o jogador apresentar a sequência novamente, ela é validada desde o início. Para zerar a variável “conta” no momento correto, abra o arquivo “HelloWorldScene.cpp” e adicione a seguinte linha de código:
HelloWorld::conta = 0;
logo abaixo dessa:
void HelloWorld::vezDoComputador() {
Agora nós precisamos validar cada entrada do jogador com cada elemento da sequência. Isso gerará uma série de mudanças no método “ccTouchesBegan”. Antes de tudo, vamos capturar qual é o próximo sinal da sequência. Adicione a seguinte linha de código:
int v = (static_cast<CCInteger*>(HelloWorld::sequencia->objectAtIndex(HelloWorld::conta)))->getValue();
logo abaixo dessa:
ponto.y = size.height – ponto.y;
Para verificar se o jogador clicou no botão correto, adicione a seguinte linha de código:
if(v==0) {
logo abaixo dessa:
if(HelloWorld::botaoSup->boundingBox().containsPoint(ponto)) {
, adicione a seguinte linha de código:
if(v==1) {
logo abaixo dessa:
} else if(HelloWorld::botaoInf->boundingBox().containsPoint(ponto)) {
, adicione a seguinte linha de código:
if(v==2) {
logo abaixo dessa:
} else if(HelloWorld::botaoEsq->boundingBox().containsPoint(ponto)) {
e adicione a seguinte linha de código:
if(v==3) {
logo abaixo dessa:
} else if(HelloWorld::botaoDir->boundingBox().containsPoint(ponto)) {
Programadores mais experientes notarão que nós abrimos uma estrutura de seleção em cada uma dessas linhas recentemente adicionadas e não fechamos nenhuma. Precisamos fechar cada uma delas para que o jogo funcione corretamente. Para fazer isso, adicione as seguintes linhas de código:
HelloWorld::conta++;
} else {
HelloWorld::menuCloseCallback(this);
}
logo abaixo dessas:
HelloWorld::lampSup->setDisplayFrame(CCSpriteFrameCache::sharedSpriteFrameCache()->spriteFrameByName(“LuzAcesa.png”));
HelloWorld::idToque = (static_cast<CCTouch*>(touches[0]))->getID();
, dessas:
HelloWorld::lampInf->setDisplayFrame(CCSpriteFrameCache::sharedSpriteFrameCache()->spriteFrameByName(“LuzAcesa.png”));
HelloWorld::idToque = (static_cast<CCTouch*>(touches[0]))->getID();
, dessas:
HelloWorld::lampEsq->setDisplayFrame(CCSpriteFrameCache::sharedSpriteFrameCache()->spriteFrameByName(“LuzAcesa.png”));
HelloWorld::idToque = (static_cast<CCTouch*>(touches[0]))->getID();
e dessas:
HelloWorld::lampDir->setDisplayFrame(CCSpriteFrameCache::sharedSpriteFrameCache()->spriteFrameByName(“LuzAcesa.png”));
HelloWorld::idToque = (static_cast<CCTouch*>(touches[0]))->getID();
Note que, se o jogador aperta o botão correto, a respectiva lâmpada é acesa e a variável “conta” é incrementada, para que, na próxima vez, seja validado o próximo sinal da sequência. Caso o jogador aperte em um botão errado, então o jogo é finalizado. Não nos preocupamos com HUD nem com término de jogo ainda já que esse é o tema do próximo tutorial.
Para finalizar o tutorial de hoje, só falta fazer a transição do término da vez do jogador para a apresentação da sequência aumentada. O momento de fazer tal transição é quando o jogador tira o dedo da tela, após apertar o último botão da sequência. Assim, adicione as seguintes linhas de código:
if(HelloWorld::conta==HelloWorld::sequencia->count()) {
HelloWorld::vezDoComputador();
}
logo abaixo dessas:
HelloWorld::lampDir->setDisplayFrame(CCSpriteFrameCache::sharedSpriteFrameCache()->spriteFrameByName(“LuzApagada.png”));
HelloWorld::idToque = -1;
A ideia é simples: caso a variável “conta” for igual ao tamanho do vetor que armazena a sequência, então o jogador terminou de apresentar o último botão. Quando isso acontece, o jogo faz a transição para o computador apresentar a sequência aumentada. Pronto, o fluxo do jogo está devidamente implementado.
Vimos nesse tutorial como implementar o fluxo do jogo de memorização de sequência de sinais. Tivemos que dividir a execução do jogo em duas partes: uma que mostra a sequência de sinais ao jogador e outra em que o jogador apresenta a sequência ao jogo.
No próximo tutorial, nós adicionaremos os elementos de HUD, para deixar o jogo mais intuitivo. Além disso, nós implementaremos o término do jogo apresentando ao jogador até onde ele conseguiu decorar a sequência.
Um grande abraço e até mais. []