[resolvido] EXportar sprite de fonte

Eu estou tentando criar uma sprite pra ser importada como fonte. A fonte já existe, mas eu quero que ela apareça colorida numa textura específica.
Então estou tentando criar uma sprite com todas as letras equidistantemente separadas pra importar depois, como fonte.

Então a idéia é:
- criar uma surface do tamanho necessário pra desenhar todas as letras
- cobrir essa surface com a textura
- a cada espaço, desenhar uma letra, num blend mode tal que fique a cor da textura no formato da letra
- como isso gera alguns espaços retangulares com a textura, eliminar esses espaços

Então criei o seguinte script:

Código:

//criaSpriteFonte(fonte, sprite da textura, primeira, última, altura, largura, save);
//retorna uma surface com o desenho dos caracteres (do inicial ao final) coloridos com a textura
//ainda requer alguns arranjos (eu preferiria usar fa_top e criar a surface na altura da sprite, mas não tem funcionado)

//prepara o jeito de desenhar (fonte e alinhamento)
draw_set_font(argument0);
draw_set_valign(fa_bottom);
draw_set_halign(fa_left);

var textura, inicial, final, altura, largura, larSurface, Surf, Surf2, pdx;
textura = argument1; //sprite com a textura

inicial = argument2; //a primeira letra (em ascii code)
final = argument3; //a última letra (em ascii code)
altura = argument4; //altura da fonte (não consegui usar algo como "font_get_height")
largura = argument5; //espaço entre uma letra e outra na imagem;
larSurface = (final - inicial + 1) * largura; //tamanho das surfaces

//Cria a surface
Surf = surface_create(larSurface, altura + 5); //não sei porque somar 5 na altura
surface_set_target(Surf)

//cobre a textura com a surface
pdx = 0; //ponto de desenhar
while (pdx < larSurface){
   draw_sprite_ext(sprTextura, 0, pdx, 0, 1, 1, 0, $ffffff, 1); //usei o "_ext" pra poder mudar a cor e/ou alpha, mas depois achei bobagem
   pdx += sprite_get_width(sprTextura);
   }

// draw_set_blend_mode_ext(bm_zero, bm_src_alpha);
// desenha cada uma das letras
pdx = 0; //ponto de desenhar
for(i = inicial; i <= final; i +=1){
   draw_set_blend_mode_ext(bm_dest_color, bm_zero); //letras na cor da tela, tela em alpha zero
   draw_text_color(pdx, altura + 5, chr(i), $ffffff, $ffffff, $ffffff, $ffffff, 1); //não sei porque somar 5 na altura
   draw_set_blend_mode(bm_subtract); //pra tirar a rebarba
   draw_rectangle_color(pdx + string_width(chr(i)), 0, pdx + largura, altura + 5, $0, $0, $0, $0, 0);
   pdx += largura;
   }

draw_set_blend_mode(bm_normal);

//como o fundo fica na cor da textura, apesar do alpha ser zero, o paint mostra a imagem como se fosse um retângulo no padrão da textura
//o resto do code é pra consertar isso.
Surf2 = surface_create(larSurface, altura + 5);
surface_set_target(Surf2)
draw_clear_alpha($ffffff, 0);
draw_surface(Surf, 0, 0); //desenha na cor da imagem, no alpha do fundo; o que elimina as áreas de alpha=0 da imagem.
surface_reset_target();

surface_free(Surf); //a primeira surface realmente perde a utilidade, aqui

if (argument6 == true){ //se é pra criar um arquivo
   surface_save(Surf2, "alfabeto.png");
   }

return(Surf2);

Bom, acontece um monte de coisa errada:
- o texto não aparece na parte de baixo da surface (por isso eu somei 5 em várias linhas do texto)
- o retângulo branco come o começo de algumas letras (fica maior do que devia na letra anterior, provavelmente)
- o retângulo branco NÃO come todo o espaço entre as letras (fica menor do que deveria na letra em questão)

Eu poderia sim, criar um script pra ser usado no draw_event, que exibisse a surface que está sendo criada. Mas dependendo do tamanho do texto, eu temo que isso venha a deixar o jogo lento. Então gostaria de resolver esses problemas, se for possível.
Você sabe o que está errado no script?

Pelo que eu testei, parece que isso não é um problema de cálculo. O cálculo do script tá certinho, o lance aí parece ser um problema com os blend modes (não erro seu, e sim alguma coisa ao sei lá, processar esses pixels das beiradas, vai saber...). Isso já aconteceu comigo desenhando sprites, ficava uma "beirada", uma linha em volta do sprite que eu até usei pra efeitos.

Com caracteres onde as beiradas não são muito arredondadas, isso não acontece:



Quando ao width e height de cada texto, o que eu faço normalmente é dar um loop em todos os caracteres e pegar o valor maior de tudo, com string_width e string_height.

Eu tava tentando criar algo como isto, só que deu um Unexpected Error.

Spoiler:

Percebi que o erro estava dando ao criar a sprite... Mas não consigo resolver...
O que eu realmente mudei foi que eu tirei o retangulo que se colocava depois do texto, a adição da fonte já no final e algumas mudançinhas no código.

@luiz_eldorado

Luiz, acho que o problema no seu código é que você está tentando pegar tudo (a tabela toda). Tem alguns caracteres que não são impressos. Talvez seja isso. Tente reduzir esse número e veja se funciona...

Se não funcionar, abra um tópico pra gente te ajudar, assim fica mais organizado responder cada dúvida separadamente. o/

@saim

Saim, montei uma ideia base aqui, veja se resolve ou se pelo menos ajuda nisso que você quer. Eu acho que o problema pode ter sido o blend, como comentei antes. Desenhei a fonte e o fundo como se fosse uma máscara em preto e branco e depois apliquei a textura.

Também usei o draw_primitive pra texturizar, acho que fica mais legal e dá mais possibilidades de efeitos.



Falou!

Ninja8086 escreveu:Pelo que eu testei, parece que isso não é um problema de cálculo. O cálculo do script tá certinho, o lance aí parece ser um problema com os blend modes (não erro seu, e sim alguma coisa ao sei lá, processar esses pixels das beiradas, vai saber...).

Talvez seja o tal do "jogo genérico" que eu uso. Ele tem uns comportamentos estranhos, mesmo. Se ajuda, eu testei as fontes Haettenschwiler e arial (a que eu quero mesmo é a Haettenscheiler). O problema ficou bem mais evidente com a arial, mas o "A" (maiúsculo) teve metade se sua imagem comida pela "@" anterior (mesmo que eu aumentasse MUITO o espaço entre as letras) nas duas fontes.

luiz_eldorado escreveu://pegar todas as letras (acho que não é preciso colocar argumentos no script)

Eu posso precisar desse script no futuro, então acho melhor generalizar (se for uma fonte que só escreva uma ou outra palavra, dá pra diminuir a sprite).

luiz_eldorado escreveu://saim: se achou bobagem porque ainda deixou lá?

O comentário é mais pra mim mesmo. É que eu testei um monte de alternativas, uma delas funcionou, no sentido de não deixar as rebarbas de textura. Eu mantive a forma original de desenhar pra me lembrar das alternativas existentes.

luiz_eldorado escreveu://tudo bem, eu não sei nada sobre blend modes.

Tem um tutorial na minha assinatura!

luiz_eldorado escreveu:Surf2=surface_create(largura*255,altura)
(...)
spr=sprite_create_from_surface(Surf2,0,0,surface_get_width(Surf2),surface_get_height(Surf2),0,0,0,0)
//^ Aqui dá o erro

Acho que não, os argumentos da função estão ok. Unexpected errors normalmente acontecem quando a gente esquece de usar um argumento num script. O game maker usa o valor "zero" e o script pode não funcionar direito.
A dica do Ninja também tem fundamento, os primeiros caracteres não são imprimíveis. Não acho que seja essa a causa, mas vale a pena testar. Ah, se for procurar uma tabela ascii, ignore os valores acima de 127. Eles não batem.

Ninja8086 escreveu:Saim, montei uma ideia base aqui, veja se resolve ou se pelo menos ajuda nisso que você quer. Eu acho que o problema pode ter sido o blend, como comentei antes. Desenhei a fonte e o fundo como se fosse uma máscara em preto e branco e depois apliquei a textura.

Também usei o draw_primitive pra texturizar, acho que fica mais legal e dá mais possibilidades de efeitos.

Valeu, Ninja, mas o conetúdo do seu link está bloqueado aqui, pra mim. Vou dar uma olhada em casa.
Agora, essa idéia de desenhar o texto primeiro e aplicar a textura depois, eu já testei (usando draw_set_blend_mode_ext(bm_dest_alpha, bm_zero), se não me engano) e o resultado ficou razoável, mas não muito bom. As partes em que a fonte têm um alpha diferente de um ficaram meio pretas, prejudicando o resultado final.
Se bem que talvez isso tenha acontecido porque eu desenhei a fonte em preto... Agora eu não lembro. Vou testar seu link à noite e falo se é a mesma coisa, se o problema era a cor do texto e se o caso está resolvido!
Valeu!!!

Quanto às primitives, eu também acho que dá pra fazer muita coisa bacana, mas nesse caso, não sei o que poderia acrescentar. Talvez um alpha em degradê de cima pra baixo, sumindo com a sprite, mas não muito mais que isso. Lembrando que a sprite vai gerar uma fonte, que pode ser usada em qualquer ordem (então não dá pra criar algum efeito radial, por exemplo).



Edit: quase lá!!!
Alterei um pouco os blend modes. Agora eu crio uma mask pra ser removida na surface com a textura, o que, teoricamente, deixa só a imagem das letras.
Funciona bem bonitinho.
Mas o código parou de gravar o arquivo .png. Não sei porque. O arquivo simplesmente não aparece mais.
Cheguei a pensar que eu estivesse entrando com o argumento errado, mas não. Coloquei um outro comando (mostrar uma mensagem) pra só ser executado se o primeiro também fosse. A mensagem aparece na tela, mas o arquivo não aparece em lugar nenhum. Onde foi que eu errei agora?
Eis o novo script:

Código:

//criaSpriteFonte(fonte, sprite da textura, primeira, última, save);
//retorna uma surface com o desenho dos caracteres (do inicial ao final) coloridos com a textura
//ainda requer alguns arranjos (eu preferiria usar fa_top e criar a surface na altura da sprite, mas não tem funcionado)

//prepara o jeito de desenhar (fonte e alinhamento)
draw_set_font(argument0);
draw_set_valign(fa_top);
draw_set_halign(fa_left);

var textura, inicial, final, altura, largura, larSurface, Surf, Surf2, pdx; //
textura = argument1; //sprite com a textura
inicial = argument2; //a primeira letra (em ascii code)
final = argument3; //a última letra (em ascii code)

//define a altura e largura máximas dos caracteres
altura = 0; largura = 0;
for(i = inicial; i <= final; i += 1){
   altura = max(string_height(chr(i)), altura); largura = max(string_width(chr(i)), largura);
   }
larSurface = (final - inicial + 1) * largura; //tamanho das surfaces

//Cria a surface pra ser usada como tesoura
Surf = surface_create(larSurface, altura);
surface_set_target(Surf);
draw_clear_alpha($ffffff, 1);
draw_set_blend_mode(bm_subtract);
px = 0; //posição do desenho
for(i = inicial; i <= final; i += 1){
   draw_text_color(px, 0, chr(i), $ffffff, $ffffff, $ffffff, $ffffff, 1)
   px += largura;
   }
draw_set_blend_mode(bm_normal);

//cria a surface pra ser recortada
Surf2 = surface_create(larSurface, altura);
surface_set_target(Surf2);
//cobre a textura com a surface
pdx = 0; //posição do desenho
while (pdx < larSurface){
   draw_sprite_ext(sprTextura, 0, pdx, 0, 1, 1, 0, $ffffff, 1); //usei o "_ext" pra poder mudar a cor e/ou alpha, mas depois achei bobagem
   pdx += sprite_get_width(sprTextura);
   }
// recorta a surface anterior
// draw_set_blend_mode_ext(bm_zero, bm_inv_src_alpha); // -> NÃO É a mesma coisa que bm_subtract!!! (jurava que era...)
draw_set_blend_mode(bm_subtract);
draw_surface(Surf, 0, 0);
draw_set_blend_mode(bm_normal);

//agora volta com o resultado pra uma surface limpa, pra não dar confusão quando abrir no paint
surface_set_target(Surf);
draw_clear_alpha($ffffff, 0);
draw_surface(Surf2, 0, 0);
surface_reset_target();

surface_free(Surf2);

if (argument4 == true){ //se é pra criar um arquivo
   surface_save(Surf, "alfabeto.png");
   show_message("devia");
   }

return(Surf);

Agora, essa idéia de desenhar o texto primeiro e aplicar a textura depois, eu já testei (usando draw_set_blend_mode_ext(bm_dest_alpha, bm_zero), se não me engano) e o resultado ficou razoável, mas não muito bom. As partes em que a fonte têm um alpha diferente de um ficaram meio pretas, prejudicando o resultado final.

Mas nesse caso, você estaria usando uma fonte por sprites (tipo um png)? Se sim, acho que o ideal seria que você usasse ela por inteiro (sem alpha) e deixasse pra aplicar o alpha como a última coisa. Aí ela não perde a qualidade em nada, porque fonte é um vetor no fim das contas (embora sejam convertidas pra imagens quando incorporadas no projeto, mas enfim... não perde qualidade)

Quanto aos efeitos das primitives.... Um dos que eu pensei foi redimensionar a textura pra cada caractere da fonte. Outro: rotacionar a textura, coisa que seria mais difícil "plotando" as imagens uma a uma dentro de um loop. Enfim, é opcional.

Mas o código parou de gravar o arquivo .png. Não sei porque. O arquivo simplesmente não aparece mais.

Estranho... eu já vi acontecer o contrário. Mas o que não aparece é o arquivo ou o conteúdo dele? Se for o arquivo, será que ele está gravando na pasta temporária (porque você não especificou um caminho...). Tenta lá, se for isso mesmo:

Código:

surface_save(Surf, working_directory + "\alfabeto.png");

Falou!

Ninja8086 escreveu:você estaria usando uma fonte por sprites (tipo um png)?

Não, fontes normais, mas com bordas arredondadas e linhas inclinadas (Haettenschweiler e Arial). Você perguntou isso porque eu mencionei o alpha != 1, né? Esses detalhes de suavização é que usam o canal alpha. Houve até uma lista de fontes pixeladas, sugeridas no concurso preto-e-branco, pra evitar que houvessem pixels semi-transparentes, resultando em tons de cinza.

Ninja8086 escreveu:Quanto aos efeitos das primitives....

É, você tem razão. Já que o script vai ser guardado pra reuso, nada mais sensato que deixá-lo maleável, não é mesmo? Basta lembrar que pra usar texturas, o lado da sprite tem que ser uma potência de 2, mas isso eu acho que nem precisa acrescentar um comentário.

Ninja8086 escreveu:Mas o que não aparece é o arquivo ou o conteúdo dele? Se for o arquivo, será que ele está gravando na pasta temporária (porque você não especificou um caminho...). Tenta lá, se for isso mesmo:

Código:

surface_save(Surf, working_directory + "\alfabeto.png");

É o arquivo, cara! Coisa mais estranha do mundo, num momento, ele grava tudo lindamente, depois parece simplesmente ignorar o comando. Até achei que estivesse faltando algum argumento ou que houvesse algum risco da surface estar totalmente limpa (o GM tem um comportamento bizarro, nesse caso), mas fiz diversos testes (inclusive escrever o endereço completo, como você sugeriu) e nada.
O pior é que antes ESTAVA gravando! O show_message ESTÁ mostrando a mensagem!
Adicionei a linha "surface_save(canvas, "teste.png");" no seu script e o arquivo foi gravado!

Aliás, seu script é muito bom, mas ainda dá aquele problema das beiradas escuras. Realmente é um problema de blending, mas não sei qual combinação usar. Quando eu crio uma máscara branca (com o texto como "buracos") e uso pra recortar (bm_subtract) uma surface com a textura, as beiradas ficam na cor esperada. Já que não estou conseguindo consertar o meu script, acho que vou adaptar o seu pra fazer isso. Assim que der certo (claro que vai dar!) eu volto aqui, posto o script corrigido e peço pra trancar o tópico.
Ah, você fez uma pequena confusão com sprite e textura, no script (definiu o argumento como a textura, mas usou sprite_get_width/height). Eu testei e até funciona, mas a textura fica esticadona. Modifiquei pra usar a sprite como argumento, posto a versão alterada assim que chegar no resultado completo.


Edit: Resolvido!!!
O problema era a cor do fundo, não os blend modes. Colocando branco, resolveu tudo!
Eu achei que branco seria um problema, porque estávamos usando bm_dest_color em src, mas revi o manual e bm_dest_color leva em conta o valor de alpha, também. No paintbrush, ficamos com a impressão que nada foi feito (a textura aparece inteirinha, sem letras), mas acrescentei algumas linhas pra redesenhar a surface sobre outra totalmente limpa e gravei o novo resultado. Foi mais simples do que eu esperava.

Código:

/*
--------------------------------------------------------------
criaSpriteFonte(fonte, sprite da textura, primeira, última, save);
retorna uma surface com o desenho dos caracteres (do inicial ao final) coloridos com a textura
--------------------------------------------------------------
*/

var c, sheet_font, sheet_sprt, sheet_patt, inicial, final, gravar, maxw, maxh, text_length, ch, canvas, canvas2, xrepmax, yrepmax;

sheet_font := argument0; // Fonte
sheet_sprt := argument1; // sprite da textura
sheet_patt := sprite_get_texture(sheet_sprt, 0); // Padrão da textura
inicial := argument2; // primeira letra
final := argument3; // última letra
gravar := argument4; // se é pra criar o arquivo da fonte
maxw := 0;
maxh := 0;

text_length := final - inicial + 1; // Pega quantos caracteres há no texto
// Anula se não houver nenhum
if (text_length <= 0){
   exit;
   }

draw_set_font(sheet_font);
draw_set_valign(fa_top);
draw_set_halign(fa_left);

// Máximo vertical e horizontal
for (c := inicial; c <= final; c += 1){
   ch := chr(c);
   maxw := max(string_width (ch), maxw);
   maxh := max(string_height(ch), maxh);
   }

canvas := surface_create(maxw * text_length, maxh);
surface_set_target(canvas);
draw_clear_alpha(c_white, 0);

// Prepara pra "desenhar" o texto
draw_set_alpha(1);
// draw_set_color(c_white);

for (c := 0; c <= text_length; c += 1){
   ch := chr(c + inicial);
   draw_text_color(c * maxw, 0, ch, $ffffff, $ffffff, $ffffff, $ffffff, 1); // Escreve o caractere na posição apropriada
   }

draw_set_blend_mode_ext(bm_dest_color, bm_inv_src_alpha);

/*
Achei essa forma de aplicar a textura mais maleável
número de repetições, etc
*/

xrepmax := (maxw * text_length) / sprite_get_width(sheet_sprt); // quantas vezes a textura vai se repetir na horizontal
yrepmax := maxh / sprite_get_height(sheet_sprt); // quantas vezes a textura vai se repetir na vertical

texture_set_blending(bm_normal);
texture_set_repeat(true); // Repita automaticamente

// Desenha pegando os pontos da textura (0 a 1)
draw_primitive_begin_texture(pr_trianglestrip, sheet_patt);
draw_vertex_texture(0, 0, 0, 0);
draw_vertex_texture(0, maxh, 0, yrepmax);
draw_vertex_texture(maxw * text_length, 0, xrepmax, 0);
draw_vertex_texture(maxw * text_length, maxh, xrepmax, yrepmax);
draw_primitive_end();

draw_set_blend_mode(bm_normal);

// desenha o resultado numa surface limpa (pra visualizar a fonte no paint, que não conhece o que é alpha)
canvas2 := surface_create(maxw * text_length, maxh);
surface_set_target(canvas2);
draw_clear_alpha($ffffff, 0);
draw_surface(canvas, 0, 0);

// Reseta e retorna a surface, com o texto já texturizado
surface_reset_target();

surface_free(canvas);

if (gravar == true){
   surface_save(canvas2, "alfabeto.png");
   }

return (canvas2);

Edit2: Ah, e parece que o problema dele não gravar mais é por causa do game genérico mesmo! Eu já tinha notado que o game genérico tem um limite de caracteres pra texto, mas não imaginei que isso fosse influenciar nesse caso (já que cada texto tem apenas um caractere). Parece que o limite existe também com relação ao tamanho das surfaces... Bastou diminuir a diferença entre a letra inicial e a final. Acho que quando eu criar um arquivo com o game maker propriamente dito, essa limitação some.

Hoy!
eu não entendi muito bem o que você esta tentando fazer.
mesmo assim eu fiz um script que transforma font para sprite texturizada com background

Código:


/*********
font_to_sprite(first,prop,texture);
example:
font=font_to_sprite(32,127,Background);


Writed by Washiro Seito.
*********/
var cW,cH,c,surf,_spr,_sprtex,_sprtmp;cW=0;cH=0;_spr=-1;
for(i=argument0;i<argument1;i+=1;)
{c=chr(i);
cW=max(string_width(c),cW);
cH=max(string_height(c),cH);
}surf=surface_create(cW,cH);
surface_set_target(surf);draw_set_color(c_white);
draw_set_halign(fa_center);
for(i=argument0;i<argument1;i+=1;)
{draw_clear(0);draw_clear_alpha(0,0);
draw_text(cW/2,0,chr(i));//draw_point(cW-1,cH-1);
if(i==vk_space){draw_point(0,cH-1)draw_point(cW-1,cH-1);}
_sprtmp=sprite_create_from_surface(surf,0,0,cW,cH,0,0,0,0);
draw_clear(0);draw_clear_alpha(0,0);
draw_background_tiled(argument2,-i*cW,0);
_sprtex=sprite_create_from_surface(surf,0,0,cW,cH,0,0,0,0);
sprite_set_alpha_from_sprite(_sprtex,_sprtmp);sprite_delete(_sprtmp);_sprtmp=_sprtex;
    if(_spr==-1)_spr=_sprtmp;else{sprite_merge(_spr,_sprtmp);sprite_delete(_sprtmp)};};
surface_reset_target();
sprite_index=_spr;draw_set_halign(fa_left);
surface_free(surf);
return(font_add_sprite(_spr,argument0,argument1,0));


é muito simples de usar

Código:


font=font_to_sprite(32,127,Background);
draw_set_font(font);
draw_text(mouse_x,mouse_y,"Fonte de Sprite Texturizado!");


funciona com os 255 caracteres de qualquer fonte

Uau, Jiraya, você foi além do necessário. O que eu queria mesmo era exportar um arquivo, pra poder importar em outro jogo, como fonte.
Mas agora, pensando bem, eu posso simplesmente importar a fonte-base e a textura e, com seu script (alterando aqui e ali), criar a fonte logo no começo de cada jogo.

Eu estava evitando esse raciocínio porque achei que seria demorado pra iniciar, mas pensando bem, a demora é pequena. O ganho no tamanho de arquivo é pequeno (uma imagem de "0" a "z", tamanho da fonte = 36 resultou num arquivo de 52Kb, enquanto a textura por si só - 128 x 128 -ocupa 44 Kb). Agora não sei qual a melhor abordagem pra padronizar, parece que tanto faz.

Agora, tenho umas perguntas quanto ao seu script (ainda não testei pra ver como funciona):
- pra que usar draw_clear se logo em seguida você usa draw_clear_alpha?
- como funciona a função sprite_set_alpha_from_sprite? Eu já usei ela antes, mas nunca entendi o que ela faz, exatamente. O manual fala em "valores de intensidade", o que não quer dizer nada, pra mim
- eu achei que vk_space fosse só o valor da TECLA, não do caractere. Coincidência ou existe uma relação aí?

Ainda quero entender melhor seu script, mas tenho que ir. Ficam essas perguntas, por enquanto. Acho que surgirão mais.

- pra que usar draw_clear se logo em seguida você usa draw_clear_alpha?

isso era apenas para ter certeza que a surface seria completamente limpa.
mas pessoalmente acho que só o draw_clear_alpha resolvia.

- como funciona a função sprite_set_alpha_from_sprite? Eu já usei ela antes, mas nunca entendi o que ela faz, exatamente. O manual fala em "valores de intensidade", o que não quer dizer nada, pra mim

isso faz uma sprite remover a area apartir dos pixels de outra sprite
técnicamente seria como se vc recorta-se uma figura de uma folha de papel.

- eu achei que vk_space fosse só o valor da TECLA, não do caractere. Coincidência ou existe uma relação aí?

sim vk_space é apenas um atalho para ord(" ")
o game maker parece ter um problema na hora de usar sprites como fonte.
ou seja, ele ignora imagens vazias, e n desenha no draw_text, resultando em um texto todo "grudado"
então eu coloquei dois pontos literalmente, nas imagem vazias, assim a imagem n seria ignorada, na hora de desenhar o texto.

saim escreveu:Ah, e parece que o problema dele não gravar mais é por causa do game genérico mesmo! Eu já tinha notado que o game genérico tem um limite de caracteres pra texto, mas não imaginei que isso fosse influenciar nesse caso

Ué, sério? Caramba, isso eu não sabia! Já aconteceu algumas coisas estranhas comigo também usando só código externo, mas agora que você comentou isso é que eu liguei as coisas. Jamais imaginaria... Se for realmente esse o problema, vou pensar seriamente em parar de usar scripts em txt's.

Jiraya escreveu:

- como funciona a função sprite_set_alpha_from_sprite? Eu já usei ela antes, mas nunca entendi o que ela faz, exatamente. O manual fala em "valores de intensidade", o que não quer dizer nada, pra mim

isso faz uma sprite remover a area apartir dos pixels de outra sprite
técnicamente seria como se vc recorta-se uma figura de uma folha de papel.

Parece que não sou o único que não entende completamente essa função... Ela vai além disso! Quando eu usei, foi pra remover gradualmente o alpha de uma sprite, usando as funções de draw. Quando você desenha uma sprite que vai do branco ao preto , ambos totalmente opacos, e usa essa função numa outra sprite também totalmente opaca, o alpha resultante é uma gradação de totalmente opaco a totalmente transparente, onde o preto original é o transparente resultante. Acho que é daí que vem o "intensidade" (e não "opacidade" ou "alpha") do manual. Variações no alpha original, obviamente, também impactam o resultado. Não sei como prever o que cores diferentes dos tons de cinza e/ou com alphas intermediários causariam no resultado final.
Será que "intensidade" é uma média entre vermelho, verde, azul e alpha? Ou será a média das cores MULTIPLICADA pelo valor de alpha (0-1)? Hmmm... Isso dá pra descobrir testando, na base da tentativa-e-erro... Se ninguém se manifestar enquanto eu testo, volto a postar aqui.
Edit: Aparentemente, ele aplica a média das cores de uma sprite (independente do valor de alpha) no valor de alpha da outra sprite (independente das cores). Mas essa média é não uma média muito precisa. Teoricamente, as cores $ff8800 e $888888 seriam iguais, mas um olhar atento identifica uma diferença sutil.
Um fundo branco com alpha zero resultou num alpha de 100%, ao ser aplicado numa sprite de alpha 100%.
Edit2: Hm, achei que ele vinha ignorando o comando de desenhar o quadrado preto-transparente sobre o fundo branco-transparente, mas agora voltei à estaca zero quanto ao alpha... desenhei um quadrado branco(50% alpha) num funto preto e apliquei essa sprite como fonte. Se fosse só a cor, o resultado seria 100% opaco, mas saiu semi-transparente. Porque, então, o branco-transparente usado como fonte resulta numa opacidade de 100%?...

Ninja8086 escreveu:vou pensar seriamente em parar de usar scripts em txt's.

Heheh! Deve ser alguma salvaguarda do programa, pra evitar que alguém crie um tal de "jogo genérico" e use isso como um crack meia-boca...