Como fazer jogo tipo Lumines Block?

Oi pessoal! Tudo certo? Tomara que sim!
Bem, eu estive jogando um jogo de tetris no celular de um amigo, é resolvi fazer um jogo baseado nele, ele se chama Lumines Block Chellenge!
Aqui tem um vídeo para ficar melhor!

Vídeo:

Como podem ver (eu acho), você tem que colocar 4 blocos juntos (ou mais) para acumular pontos!
Bem, minha duvida é o seguinte, enquanto eu programava o jogo, eu tive duvida de como fazer algum objeto saber que tem cerca de 4 blocos ou mais juntos! (Os 4 blocos tem que ficar junto de uma forma quadriculada!
Vocês podem me ajudar nessa?

bom pra fazer isso primeiro vc nao pode fazer um sprite para as formas,(na verdade pode mas quando colidir com as outras formas ele tenque se tranformar em quadradinho para poder destruir os certos),ai voce checa no quadradinho se tem um certo numero de quadrodos no lado dele, se tiver faz ele se destruir assim todos que formarem um quadrado instantaneamente se destruirão

eu tava pensando em pegar aquele tutorial do mario sabe (pular em cima e mata o inimigo)
e misturar, exemplo:

ao invés de já explodir vc coloca uma checagem de variável
crie 2 variáveis :

Código:

global.junto_horizontal=false\\ checa se tem dois blocos  juntos na horizontal

ai você checa a coalizão com um objeto na direita ou na esquerda (não sei o code direito mais e so digitar collison no code que tem umas opções uma delas e a certa não me lembro qual) ai você muda pra true a variável.
exenplo:

Código:

se colidir com o objeto bloco na horisontal
{
global.junto_horizontal=true
}

ai pega a engine do Mario, de matar quando pulo em cima, e acrescenta mais uma questão

Código:

if  global.junto_horizontal=true

bom acho que percebeu minha logica néh. bom obrigado pela atenção thau

Sua logica faz sentido, mas vou trabalhar nela aqui é digo o resultado!
De qualquer forma, podem continuar mandando sugestões de como fazer!
Obrigado!

minha logica tem uma falha, acho que as vezes vai explodir um triangulo ou até uma fileira que estiver ligado ao grupo :s

Eu estava fazendo de um modo aqui que pode não dar certo tambem! Alguem pode ajudar?

que tal quando cair na base branca ele muda-se de sprite ! tipo pra um maior isso geraria contato com os blocos ao redor!


ai e so meter intance_destroy()

A logica nao é a colisao leyon, mas sim checar quem esta em volta. No step de cada bloco voce deve checar se tem , bloco a direita e embaixo e direita embaixo, ou bloco na esquerda e embaixo e nao esquerda embaixo. Fassa isso para as 4 direçoes ,

Assim ele vai estorar qualquer forma que for grudada por blocos 2x2

superrafao escreveu:Bem, minha duvida é o seguinte, enquanto eu programava o jogo, eu tive duvida de como fazer algum objeto saber que tem cerca de 4 blocos ou mais juntos! (Os 4 blocos tem que ficar junto de uma forma quadriculada!
Vocês podem me ajudar nessa?

Cara isso é complicado... Na verdade, o lumines tem mais a ver com o bejeweled que com o tetris. Eu conheço uma forma recursiva de fazer essa checagem. Vou usar umas respostas do pessoal pra comentar mais a respeito.

RafaelCazarotto escreveu:bom pra fazer isso primeiro vc nao pode fazer um sprite para as formas,(na verdade pode mas quando colidir com as outras formas ele tenque se tranformar em quadradinho para poder destruir os certos),ai voce checa no quadradinho se tem um certo numero de quadrodos no lado dele, se tiver faz ele se destruir assim todos que formarem um quadrado instantaneamente se destruirão

É bem por aí. Cada quadradinho deve ser uma instância do mesmo objeto. Mas aí vem: se são instâncias do mesmo objeto, como fazer pro código verificar tudo certinho? Tem que ser o mesmo código!
Além disso, no lumines você pode apoiar metade do bloco que a outra metade continua caindo, então COM CERTEZA são objetos distintos que aparecem juntos.

pinpi escreveu:No step de cada bloco(...)

Não, não é no step. Você pode até usar o step pra verificar se está na hora de rodar o teste, mas não pode, de jeito nenhum, ficar rodando esse teste o tempo todo. Pelo menos se for fazer do jeito que eu conheço. De qualquer forma, só existe um momento que você PRECISA checar se dá pra eliminar tudo: a hora em que o bloco assenta no lugar.

Mas e o código?
Ele é dividido em duas partes.
A primeira é só pra verificar se tem ALGUMA COISA pra ser eliminada. No lumines, elimina-se alguma coisa quando é formado um quadrado 2x2.
A segunda é, caso exista um bloco 2x2 formado, extender o grupo a ser eliminado pra todos os blocos da mesma cor que tocarem esse bloco.

A primeira é mole. No evento em que o bloco assenta (pode ser uma colisão ou mesmo o step, mas recomendo fazer só no step em que ele assenta), você olha se tem vizinhos da mesma cor.
Cada bloco pode formar um quadrado 2x2 em 4 direções diferentes.
- Pode ser com o bloco à direita, o bloco abaixo e o abaixo e à direita.
- Pode ser com o bloco à direita, o bloco acima e o acima e à direita.
- Pode ser com o bloco à esquerda, o bloco acima e o acima e à esquerda.
- Pode ser com o bloco à esquerda, o bloco abaixo e o abaixo e à esquerda.
Olhe se em alguma dessas combinações a cor de todos os blocos é igual à cor do bloco que está fazendo o teste. Se for, pode parar o código no meio e partir pra segunda parte. Eu gosto de usar trigonometria pra isso.

Código:

var i, dx, dy, vizinho, deuCerto;
deuCerto = false; // essa variável só vai ser true se formar um bloco 2x2
for (i = 0; i < 4; i += 1){ // pra cada alternativa
   // pega a distância até a próxima instância
   switch (i){
      case 0 : {
         dx = sprite_width; dy = sprite_height;
         }; break
      case 1 : {
         dx = - sprite_width; dy = sprite_height;
         }; break
      case 2 : {
         dx = - sprite_width; dy = - sprite_height;
         }; break
      case 3 : {
         dx = sprite_width; dy = - sprite_height;
         }; break
      }

   // olha a cor do vizinho na horizontal
   vizinho = instance_position(x + dx, y, objQuadrado); // objQuadrado é o nome do objeto. Você pode mudar
   if (vizinho != noone) { // se tem mesmo uma instância ali
      if (vizinho . cor != cor){ // Se ele não é da minha mesma cor (pode trocar a variável por image_blend ou uma com outro nome)
         continue; // pára a checagem e já vai direto pra próxima alternativa
         }
      }
      else continue; // se não tem ninguém lá (vizinho == noone), não forma bloco 2x2
   // repete pras outras 2 instâncias
   vizinho = instance_position(x, y + dy, objQuadrado);
   if (vizinho != noone) {
      if (vizinho . cor != cor){
         continue;
         }
      }
      else continue;
   vizinho = instance_position(x + dx, y + dy, objQuadrado);
   if (vizinho != noone) {
      if (vizinho . cor != cor){
         continue;
         }
      }
      else continue;
   
   // se chegamos até aqui, então nenhum "continue" aconteceu,
   // ou seja, FORMOU um bloco 2x2 da mesma cor. Hora de encerrar o script
   deuCerto = true;
   return(deuCerto); // já sabemos que deu certo, não precisa continuar
   }

// se chegamos até esse ponto do script, todas as alternativas tiveram pelo menos um "continue", ou seja, o quadrado que chamou esse script não formou bloco 2x2 em nenhuma direção
return(deuCerto);

Veja, esse script teve que usar muito continue e return pra ser rápido, porque ele vai ser rodado muitas vezes. No momento em que o conjunto que você está controlando tocar o "solo", já são quatro instâncias rodando o script. Aí, cada uma checa a vizinhança 4 vezes por iteração, sendo 4 iterações, dá um total de 64 "instance_position" ANTES de chegarmos na parte recursiva.
Pensando bem, talvez usar ds_grid ou ds_map seja mais rápido... e versátil... Mas agora o script já está feito, eu tento melhorar ele depois.

Caramba, isso cansa!

Na segunda parte, você vai verificar o que esse script retornou e só vai rodar se for "true". Sendo true, você vai soltar um script que vai marcar todas as instâncias vizinhas da mesma cor e vai fazer todas elas rodarem o mesmo script que marca elas, fazendo com que a massa de "marcados" cresça até englobar todos os vizinhos. Tem que fazer isso de um jeito que não entre num loop infinito, ou seja, não pode marcar a mesma instância 2 vezes. Eu vou tentar alguma coisa aqui e já dou um edit.

[edit] Até que o outro script foi mais fácil:

Código:

// o nome desse script é importante, porque vai ser usado no próprio script.
// vou chamar de "checaVizinhos". Você pode usar outro nome, claro

var i, vizinho;

marcado = true; // essa variável deve ser declarada como "false" no create. Ela verifica se a instância já rodou o script.

for (i = 0; i < 4; i += 1){
   vizinho = instance_position(x + lengthdir_x(sprite_width, 90 * i) + 1, y + lengthdir_y(sprite_width 90 * i) + 1, objQuadrado);
   if (vizinho == noone) { // se não tem vizinho
      continue; // vai pra próxima iteração
      }
   
   // não precisa do "else"; se ainda estamos aqui, EXISTE um vizinho
   with (vizinho){
      if (cor == other . cor && marcado == false){ // se ele é igual a mim e ainda não rodou o script
         checaVizinhos(); // faz ele rodar o script
         }
      }
   }

Perceba que quando o vizinho rodar o script, ele também vai checar pelos demais vizinhos. Isso é a tal recursividade que eu tinha falado que ia precisar. É um lance muito lento, por isso não pode ser usado em todos os steps.
Nesse caso, não acho que usar ds_grid ou ds_map possa ajudar, mas posso estar enganado.

Ao terminar de rodar esse script, todo o conjunto vai estar com a variável "marcado" valendo "true". Aí, de fora do script, você pega e elimina a cambada toda!

Código:

with(objQuadrado){
   if (marcado == true){
      // faz alguma coisa com a pontuação e...
      instance_destroy();
      }
   }

Aí, chamando o primeiro script de "checaQuadrados" e o segundo de "checaVizinhos", o evento que acontece no momento em que o bloco assenta ficaria mais ou menos assim:

Código:

if (checaQuadrados() == true) { //se é pra rodar o próximo
   checaVizinhos(); // marca quem for pra eliminar
   }

with(objQuadrado){
   if (marcado == true){
      // faz alguma coisa com a pontuação e...
      instance_destroy();
      }
   }

E, claro, no "instance_destroy" você avisa pra quem estiver em cima que é pra cair.

É vc ta certo, é que eu acabei nao pensando na parte de ir marcando os outros, entao pensei que daria um jeito rodando o codigo no step.

OBS:Fiquei feliz que intendi o codigo sem nem precisar ler as explicações, Saim vc é um genio, eu bolei algo parecido só que com uma logica porca, onde ele checava tambem com o instance position, só que ele tinha valores predefinidos, por tanto eu tinha que rodar o cidigo com valores predefinidos 4 vezes, e ele acabou ficando meio grande... edit basico aqui: outra coisa é que o seu pode se fazer adptaçoes para dar mais pontos por streaks, coisa que o meu tbm nao dava

Obrigado saim, mais estou tendo dificuldades de organizar os scripts!
Eu não sei onde colocar, alias o primeiro script, o que fasso com a variavel "cor"?

superrafao escreveu:Obrigado saim, mais estou tendo dificuldades de organizar os scripts!
Eu não sei onde colocar, alias o primeiro script, o que fasso com a variavel "cor"?

Dê uma releitura aí na mensagem que nela já tem as respostas.
Ah, deixa eu te mostrar!

// Se ele não é da minha mesma cor (pode trocar a variável por image_blend ou uma com outro nome)

Quer dizer, a variável "cor" é a variável que define que cor vai ser o quadrado. Pode ser qualquer outro nome. Eu usei "cor" em todos os scripts, inclusive na correção do primeiro, que vou mostrar daqui a pouco. Claro, ela deve ser definida no create de cada instância.

Quanto à organização dos scripts, também tem um trecho na mensagem que mostra como fazer:

Aí, chamando o primeiro script de "checaQuadrados" e o segundo de "checaVizinhos", o evento que acontece no momento em que o bloco assenta ficaria mais ou menos assim:

Código:

if (checaQuadrados() == true) { //se é pra rodar o próximo
  checaVizinhos(); // marca quem for pra eliminar
  }

with(objQuadrado){
  if (marcado == true){
      // faz alguma coisa com a pontuação e...
      instance_destroy();
      }
  }

Traduzindo:

Código:

SE (é pra eliminar algum bloco, qualquer bloco){
MARCA(todos os blocos que forem pra eliminar)
}

COM (todos os blocos marcados){
dá pontos e...
CABUUUM!
}

Eu substituí esse "evento em que os blocos assentam" pelo clique do mouse, porque não quero me preocupar com a movimentação, por enquanto - simplesmente encho a tela com blocos de cor aleatória e clico onde der pra eliminar alguma coisa. Funcionou.

MAS funcionou com o script a seguir, também. Lembra que eu disse que com ds_grids a coisa provavelmente ficaria mais rápida e versátil? Bom, tem algumas situações em que não é mais rápido (tipo, quando a primeira iteração já retorna true e você sai do script de cara). Mas com certeza usar ds_grids deixa o código mais versátil.
Por exemplo, você pode checar por quadrados 3x3 ou até formações especiais, como um xadrez perfeito ou algo assim.

Ficou assim:

Código:

var dx, dy, referencia, lado, i, j, DSGRID, vizinho, deuCerto;
dx = sprite_width; dy = sprite_height;
deuCerto = false;

referencia = cor; // NESSE CASO é igual a cor, mas no lumines tem um modo que verifica se formou-se um padrão
lado = 3; // o lado (em número de instâncias) do quadrado a ser formado
DSGRID = ds_grid_create(2 * lado - 1, 2 * lado - 1);

// alimenta a grid com os valores dos vizinhos
for (i = - (lado - 1); i <= (lado - 1); i += 1){
   for (j = - (lado - 1); j <= (lado - 1); j += 1){
      vizinho = instance_position(x + i * grid, y + j * grid, objQuadrado); // grid pode ser substituído por sprite_width ou sprite_height. É a medida do lado da sprite.
      if (vizinho != noone){ // se tem alguém
         if (vizinho . cor = referencia){ // se a cor é igual
            ds_grid_set(DSGRID, i + (lado - 1), j + (lado - 1), 1); // coloca um ok
            }
            else { // se a cor é diferente
               ds_grid_set(DSGRID, i + (lado - 1), j + (lado - 1), 0); // coloca um ñ ok
               }
         }
         else { // se não tem ninguém
            ds_grid_set(DSGRID, i + (lado - 1), j + (lado - 1), 0); // coloca um ñ ok
            }
      }
   }

// verifica se um dos quadrados lado x lado está totalmente de acordo com a referência
for(i = 0; i < ds_grid_width(DSGRID) - (lado - 1); i += 1){
   for(j = 0; j < ds_grid_height(DSGRID) - (lado - 1); j += 1){
      if (ds_grid_get_sum(DSGRID, i, j ,i + lado - 1,j + lado - 1) == sqr(lado)){ // se todos estão com o valor 1
         deuCerto = true;
         break; // já foi, não precisa continuar
         }
      }
   }

ds_grid_destroy(DSGRID);
return(deuCerto);

Eu estava fazendo um sistema muito mais simples!kkk
Mas ainda esta incompleto por causa de bug!

Spoiler:

Um dos blocos não respondem, mas o resto fico perfeito!

Faltou x positivo com y negativo...

Ah, consegui! kkkkkkk
Esse codigo funcionou bem!

Código:

if place_meeting(x+16,y,block) && place_meeting(x,y+16,block) && place_meeting(x+16,y+16,block) && cair=false
{ok=true}
if place_meeting(x-16,y,block) && place_meeting(x,y+16,block) && place_meeting(x-16,y+16,block) && cair=false
{ok=true}
if place_meeting(x-16,y,block) && place_meeting(x-16,y-16,block) && place_meeting(x,y-16,block) && cair=false
{ok=true}
if place_meeting(x+20,y,block) && place_meeting(x,y-16,block) && place_meeting(x+18,y-16,block) && cair=false
{ok=true}

O que acham?