[resolvido]Área de uma cor do sprite

Olá.
Pretendo fazer um inimigo que é, basicamente, um círculo branco. A cada ataque do jogador, o sprite é modificado, de modo a apresentar uma parte preta no local do ataque.
Se for possível, gostaria que a derrota desse inimigo fosse quando uma porcentagem de seu sprite estiver preta. Existe alguma forma rápida de fazer essa verificação? De preferência, sem o uso de DLLs, mas isso não é uma regra.

Calcular de verdade quanto porcento está preto, acho que é bastante complicado. Mas a solução que eu vejo é algo assim:

No início, você calcula qual é a área do sprite do inimigo: area_total = pi*raio*raio (se ele for um círculo mesmo, não um "ovo").
Então, a cada ataque, você aumenta alguma variável para saber quanto dele já foi atingido. Por exemplo, se fosse um ataque que deixa um circulo preto de 10px de raio no inimigo: area_afetada += pi*10*10.
Então, a cada step, verifique se a area_afetada é p porcento da area total:
if (area_afetada >= area_total*p/100)
// Morre ò.ó

É claro que pode haver alguns problemas, principalmente porque eu não sei como são os ataques. Se isso não servir, coloque imagens para eu entender melhor como deve funcionar.

Ah, esqueci de mencinar: os ataques podem ser no mesmo lugar, que já está preto. Daí, isso não influencia na área. É uma forma da fzer o boss ir ficando mais difícil com o tempo sem mudar nada na jogabilidade, só dificultar as opções - algumas áreas e padrões serão mais fáceis de atingir do que outros.

Edit: exemplos:
- o disco fica se movimentando pra cima e pra baixo e o jogador corta linhas pretas com o mouse. Em pouco tempo, o meio do disco estará coalhado de linhas pretas verticais (porque é só fica com o mouse parado pra acertar), mas pra abranger uma área maior, já serão necessárias linhas horizontais.
- o disco atravessa a tela da direita pra esquerda e o player joga umas bolas nele pra pintar o ponto que a bola atingiu de preto. A face esquerda rapidamente estará coalhada de manchas pretas e a face direita, branquinha. Pra terminar de pintar, o player precisa se virar pra pegar o boss depois dele passar.

Ok, me saltaram à mente mais duas soluções, um pouco complicadas, mas vamos lá...

Primeira:
Você pode distribuir "pontos" pelo "corpo" do inimigo.

Poderia ser, por exemplo, um objeto (obj_Ponto) com sprite (invisível) de 4x4 pixels. Você distribuiria instâncias desse objeto por todo o sprite do inimigo, neste caso, um a cada quadrado de 4x4 pixels. Então, quando um ataque acertasse o inimigo, essas instâncias informariam de algum jeito que foram acertadas (só na primeira vez), e assim você poderia calcular quanto por cento já foi atingido.

Eu usei como exemplo um objeto de 4x4 pixels, porém dá para usar outros tamanhos. Só que, quanto menor, mais instâncias serão necessárias e consequentemente, diminuirá o desempenho. Quanto maior, menos precisão.

Para distribuir essas instâncias pelo sprite do inimigo, você poderia usar um código assim:

// No inimigo:
// Create:
quant = 0; // Total de "pontos" criados, para poder tirar a porcentagem
tam = 4; // Largura e altura dos "pontos"
for (a = 0; a < bbox_bottom-bbox_top; a += tam)
for (l = 0; l < bbox_right-bbox_left; l += tam)
{
// Cria a instância na sua posição
ponto = instance_create(bbox_left+l, bbox_top+a, obj_Ponto);
// Para que a instância sempre saiba sua posição certa em relação ao inimigo
ponto.xx = l;
ponto.yy = a;
with (ponto)
{
// Como é um círculo, há pontos que
// não fazem parte do corpo, então
// não devem existir.
// Se tal ponto faz parte do sprite do inimigo,
// declara a existência de mais um ponto,
// senão,
// é deletado.
if (place_meeting(x, y, other))
other.quant += 1;
else
instance_destroy();
pai = other.id;
// Vamos chamar o inimigo a quem ele "serve" de pai dele.
// Quando ele for atingido por um golpe, enviará
// essa informação para o seu pai e se destruirá.
}
}

// No obj_Ponto
// Begin Step:
// Para ficar sempre na posição certa
x = pai.bbox_left+xx;
y = pai.bbox_top+yy;
if (foi atingido)
{
... // Códigos para informar ao pai que foi atingido
instance_destroy(); // Destrói-se
}

Assim, como escrevi acima, quando um golpe acertasse o inimigo, acertaria também os pontos, e eles informariam à instância do obj_Inimigo que foram acertados e se destruiriam, de modo que não poderiam ser acertados novamente. Assim, você dividiria quantos já foram destruidos por quantos havia no início, tendo a porcentagem que quer.


Uff, tá quase acabando...

Segunda:
Essa eu creio que seja um pouco mais simples de explicar, porém um pouco mais complicada de aplicar.

Quando a opção Interpolate color between pixels está ativada e você diminui o image_x/yscale até a imagem ter apenas 1 pixel (image_(x ou y)scale = 1/(largura ou altura)), esse pixel resultante é uma mistura de todas as cores do sprite.
Desse modo, se, por exemplo, o sprite original era 100% branco (tudo (255, 255, 255)) e exatamente metade dele foi pintada de 100% preto (0, 0, 0), esse pixel resultante seria da cor (127, 127, 127), ou seja, cinza 50%.

Eu fiz o teste aqui, com um sprite de 32x32, dividido em 4 partes iguais: duas brancas (255, 255, 255), uma azul (0, 0, 255) e uma verde (0, 255, 0), e como esperado, o pixel resultante foi a média dessas cores: (127, 191, 191).

Se estou certo, esse método não acarretaria problema nenhum com relação ao desempenho. Entretanto, como eu disse, o complicado é aplicar isso. Se você não está usando o interpolate blablabla no seu jogo, você teria que ativar temporariamente, desenhar o sprite em uma surface, pintar o fundo de preto, considerar isso na porcentagem inicial (já que o sprite não é um quadrado perfeito), colocar tudo em cálculos para saber se já chegou na porcentagem necessária para morrer.
Acho que você não vai querer fazer desse jeito, mas se quiser se aventurar, vá em frente


Enfim, foram essas as ideias que eu tive. Espero que uma delas (mais provável que a primeira) sirva. Se quiser alguma explicação melhor, só pedir. Boa sorte

A primeira seria muito lenta, eu penso em usar sprites GRANDES. A segunda é maravilhosa e ainda permite que eu use tons de cinza pra fazer uns chamuscados, dando o mesmo resultado.Ah, e eu posso colocar essa checagem só nos eventos de dano, o que prejudica ainda menos o processamento. Vou fazer alguns testes e ver no que dá.
Muito obrigado, eu jamais pensaria nisso!

Hmm... Más notícias :|

Fazendo uns testes "mais aprimorados", deu pra perceber que o pixel resultante não é, de fato, a média de todos os pixels. Num sprite de 32x32, a cor dele foi a média apenas dos 4 pixels centrais do sprite. Um sprite todo vermelho com dois pontinhos pretos e dois brancos no centro ficou cinza ao ser reduzido.
A não ser que nas versões posteriores do GM (a minha é 6.1) seja diferente e você esteja usando uma delas, não dá certo.

É, um ponto preto no meio de um sprite 10x10 resultou em 100% preto.
O mesmo ponto preto na borda do sprite resultou em 75% branco.
Mas vou continuar tentando, talvez reduções sucessivas dêem um resultado melhor. Se conseguir alguma coisa, volto a postar.

EDIT: nada... até tentei usar um truque de "blur", que aprendi em algum lugar, que é repetir as idas e vindas do zoom até todas as cores estarem mescladas. Nenhum sucesso. Veja o código:

Código:

a=10;
b=10;
lar=10;
alt=10;
rep=20;
s100=surface_create(100, 100);
surface_set_target(s100);
draw_clear_alpha($ffffff, 1);
draw_rectangle(a, b, a+lar, b+alt, 0);
surface_reset_target();

s10=surface_create(10, 10);
surface_set_target(s10);
draw_clear_alpha(0, 0);
draw_surface_ext(s100, 0, 0, .1, .1, 0, $ffffff, 1);
surface_reset_target();
   
repeat(rep){
    surface_set_target(s100);
    draw_clear_alpha(0, 0);
    draw_surface_ext(s10, 0, 0, 10, 10, 0, $ffffff, 1);
    surface_reset_target();
    surface_set_target(s10);
    draw_clear_alpha(0, 0);
    draw_surface_ext(s100, 0, 0, .1, .1, 0, $ffffff, 1);
    surface_reset_target();
    }

s1=surface_create(1, 1);
surface_set_target(s1);
draw_clear_alpha(0, 0);
draw_surface_ext(s10, 0, 0, .1, .1, 0, $ffffff, 1);
surface_reset_target();

cor=surface_getpixel(s1, 0, 0);
branco=$ffffff;
porc=cor/branco;

Mandei mostrar a surface de lado=100. Tentei com e sem a opção "interpolate colors between pixels", só pareceu que podia funcionar com a opção ligada. Nesse caso, ficou um monte de pixels transparentes e uma pontinha nebulosa. No segundo caso, a impressão é que nada havia sido feito.
Não sei porque no primeiro caso o branco do sprite sumiu. Talvez a resposta tenha a ver com isso.

É, pelo que parece, não dá pra fazer assim. Creio que o único jeito de isso funcionar seria dividir a imagem em vários pedacinhos de 2x2, diminuir todos, formar uma nova imagem e repetir esse processo até ter só 1 pixel, o que certamente não é uma boa ideia.

Eu continuo achando, agora mais do que nunca, que a primeira ideia é a melhor solução (antes de apelar para uma dll). Você disse que seria muito lenta porque que quer usar sprites grandes, mas talvez não seja. Eu fiz testes, com aqueles códigos que postei, usando um "inimigo" com sprite de 256x256 e distribuindo os pontos em quadrados de 16x16, como na imagem, e rodou bem (ignore a coloração aleatória dos pontos , se fossem todos pretos seriam visualmente incômodos):



Se você não precisar de muito mais precisão, seus inimigos não forem (muito) maiores do que isso e não aparecerem uns 4 de uma vez só na tela, pode ser que não dê problema no fps. Além de que, se for como eu penso, os ataques viriam pelos lados, então uma boa porção no centro não seria atingida nunca, diminuindo a quantidade de pontos necessários.

Tá legal, vou fazer uns testes na minha carrocinha e ver até qual velocidade roda. Os "inimigos" serão bosses, então não devem haver mais de 4 ativos na mesma tela, e isso exagerando.

Quando à posição, sim, toda a área é atingível. O principal ataque do player (até o momento) basea-se em collision_line e, nesse boss, pretendo desenhar o efeito da collision_line. O que eu espero é que, no começo da luta, essas linhas fiquem quase paralelas mas depois, vendo que linhas paralelas só se sobrepõem, sem aumentar significativamente a área colorida, o jogador procure atingi-lo em outras direções.

Funcionou!
Eu sou meio avesso a encher a room de objetos do game maker, porque cada intância, ao ser criada, tem um bocado de funções pré-programadas (atualizar speed, gravity, direction, essas coisas).
Então fiz algo baseado na sua idéia: ao invés de criar os objetos, criei uma grid com tantas casas quantos pixels na sprite e coloco nesses casas, a informação da cor do sprite (por enquanto estou usando 0 pra preto e 1 pra branco, mas acho que dá pra usar o valor real da cor). A cada ataque bem-sucedido, da mesma forma que eu atualizo a aprite, atualizo a grid.
Por enquanto, uso a grid pra desenhar uma surface à parte, pra testar se ela fica parecida com a sprite e, sim, ela fica!
Não fica idêntica, porque eu tive que usar algumas funções de floor e ceil, uns arredondamentos forçados, então acaba que alguns ataques ficarão mais eficientes que os outros, mas na média, dará certo.
Usarei algumas funções de ds_grid que parecem que foram feitas pra alguém com o meu boss e voilà.
O computador que eu escrevi o script está sem modem, então vou colocar o script só à noite, mas até lá, já sei que vou dormir mais tranquilo. Quando eu colocar, fecho o tópico.

Muito obrigado!

Edit Tá aqui:

Código:

//outBoss(x1, y1, x2, y2, lifeGrid);
//creates a new sprite by drawing a line over the object's sprite that collides with the line defined by arguments.


//var X1, Y1, X2, Y2, lifeGrid, i, j;

//the coordinates that will be taken in acoount
X1=argument0-bbox_left;//x+sprite_xoffset;//
Y1=argument1-bbox_top;//y+sprite_yoffset;//
X2=argument2-bbox_left;//x+sprite_xoffset;//
Y2=argument3-bbox_top;//y+sprite_yoffset;//
//the grid that controls the percentage
lifeGrid=argument4

//now that the coordinates have been transfered, determine the line constants
//y=a*x+b
if (X1!=X2){ //if the cutting line is not vertical
   var a, b;
   //a=dy/dx
   a=(Y2-Y1)/(X2-X1);
   b=Y1-(a*X1);

   if a<=1{ //j=a*i+b
      for(i=0; i<ds_grid_width(lifeGrid); i+=1){
         if ((floor(a*i+b)>=0 && floor(a*i+b)<=ds_grid_height(lifeGrid) && i==median(X1, X2, i)){
            ds_grid_set(lifeGrid, i, floor(a*i+b), 0);
            }
         }
      }
      else{ //a>1; i=(j-b)/a
         for(j=0; j<=ds_grid_height(lifeGrid); j+=1){
            if (floor((j-b)/a>=0 && floor((j-b)/a)<=ds_grid_width(lifeGrid) && j==median(Y1, Y2, j)){
               ds_grid_set(lifeGrid, floor((j-b)/a), j, 0);
               }
            }
         }
   else{ //the cutting line is vertical
      for (j=0; j<ds_grid_height(lifeGrid); j+=1){
         if (j==median(Y1, Y2, j)){
            ds_grid_set(lifeGrid, X1, j, 0);
            }
         }
      }