Array de múltiplas dimensões (GM não tem)

manual escreveu:You can use 1- and 2-dimensional arrays in GML.

Mas e se eu quiser uma array de 3, 4 ou mais dimensões?

É que estou pensando a respeito de jogos de cartas. A maioria das regras envolve naipes e cores das cartas, algumas usam vários decks de baralhos. Minha idéia inicial foi fazer uma array com várias dimensões.
carta[deck, cor, naipe, valor]
Mas tentei e o GM só suporta duas dimensões mesmo.

Claro que posso colocar as cores e naipes em ordem, de forma que eu tenha como calcular alguma coisa, mas... sério que tem que fazer assim?
Por exemplo, se eu coloco os seguintes índices:
0 a 12 - paus (preta)
13 a 25 - espadas (preta)
26 a 38 - copas (vermelha)
39 a 51 - ouros (vermelha)
e quero verificar se a cartaNaMesa sobre a qual estou colocando essa que está na minha mão é um valor acima e de cor invertida (como a maioria das paciências), teria que fazer algo assim:

Código:

if (indice >= 0 && indice < 13){ //paus
   if ((cartaNaMesa . indice == indice + 1 + 26) or (cartaNaMesa . indice == indice + 1 + 39)){ // se é um valor e dois ou três naipes acima
      // movimento permitido
      }
      else {
         //movimento proibido
         }
   }
else if (indice >= 12 && indice < 26){ //espadas
   if ((cartaNaMesa . indice == indice + 1 + 13) or (cartaNaMesa . indice == indice + 1 + 26)){ // se é um valor e um ou dois naipes acima
      // movimento permitido
      }
      else {
         //movimento proibido
         }
   }
else if (indice >= 26 && indice < 39){
   if ((cartaNaMesa . indice == indice + 1 - 13) or (cartaNaMesa . indice == indice + 1 - 26)){ // se é um valor acima e um ou dois naipes abaixo
      // movimento permitido
      }
      else {
         //movimento proibido
         }
   }
else if (indice >= 39 && indice < 52){
   if ((cartaNaMesa . indice == indice + 1 - 26) or (cartaNaMesa . indice == indice + 1 - 39)){ // se é um valor acima e dois ou três naipes abaixo
      // movimento permitido
      }
      else {
         //movimento proibido
         }
      }

Meio chato de programar assim, não é? Alguém teria uma forma mais eficiente de organizar (indexar) as cartas?

Acho que essa seria uma lógica mais correta! Boa sorte com a programação =D

Fiquei com a impressão de que com o que você quer, duas dimensões seriam o suficientes!

Criemos as constantes COR = 0, NAIPE = 1 e VALOR = 2.

Então temos o deck, que é a array em si.

Quanto a primeira das cartas do deck[], deck[0,COR] dá a cor... deck[0,NAIPE] dá o naipe... e deck[0,VALOR] invoca o valor!

Imagine:

IND |COR|NAIP|NUM|
_________________
0 | 2 | 2 | 13 |
_________________
1 | 2 | 2 | 12 |

Sendo que são as duas primeiras cartas do deck[]. Em cor e naipe, ambos são de Copas. Só que a carta 0 é o Rei e a 1 é a Dama!

Você pode trabalhar com constantes pra facilitar também.

Acredito que usar ambos cor e naipe são redundantes?

E se você achar as funções da array limitadas, tente usar ds_grid, que é a mesma coisa só que mais dinâmico!

eu uso o seguinte script

Código:


//vector(x,y,z)
return(argument0*1000*1000+argument1*1000+argument2) div 32000;


após isso, você poderá usar arrays de até 6 dimensões
ex:

Código:


array[vector(0,0,0),vector(0,0,0)]="Hello"
array[vector(0,4,8),vector(0,120,0)]="World"

show_message(array[vector(0,0,0),vector(0,0,0)]+array[vector(0,4,8),vector(0,120,0)]);

carta[vector(deck,cor,naipe)]=valor;


Spoiler:

Jiraya escreveu:eu uso o seguinte script

Código:


//vector(x,y,z)
return(argument0*1000*1000+argument1*1000+argument2) div 32000;


após isso, você poderá usar arrays de até 6 dimensões
ex:

Código:


array[vector(0,0,0),vector(0,0,0)]="Hello"
array[vector(0,4,8),vector(0,120,0)]="World"

show_message(array[vector(0,0,0),vector(0,0,0)]+array[vector(0,4,8),vector(0,120,0)]);

carta[vector(deck,cor,naipe)]=valor;


Spoiler:

Excelente solução! Não pude deixar de comentar, gosto muito de usar este tipo de coisa quando programo em C, pois mesmo tendo suporte a arrays multidimensionais, eu as vezes prefiro fazer desse jeito, pois programava muito acesso direto em tela SVGA $A0000000 e fazia este tipo de mapeamento usando uma função para simular o x e y em um array de uma dimensão (tela). Otimo!

un00brn escreveu:

Você já tentou criar scripts ?
Tente deixar os códigos divididos por scripts
só assim você não iria precisar de ficar repetindo os códigos deixando seu jogo mais pesado!

Acho que essa seria uma lógica mais correta! Boa sorte com a programação =D

Olá, un00brn, obrigado pela participação.
O que eu postei é só um exemplo de como seria mais fácil programar se tivéssemos muitas dimensões na array. Repare que o código não se repete, apenas segue o mesmo raciocínio - mas se tivermos valores diferentes, precisaremos de códigos diferentes, aí não dá pra generalizar.

KinKing escreveu:Fiquei com a impressão de que com o que você quer, duas dimensões seriam o suficientes!

Criemos as constantes COR = 0, NAIPE = 1 e VALOR = 2.

Então temos o deck, que é a array em si.

Quanto a primeira das cartas do deck[], deck[0,COR] dá a cor... deck[0,NAIPE] dá o naipe... e deck[0,VALOR] invoca o valor!

Imagine:

IND |COR|NAIP|NUM|
_________________
0 | 2 | 2 | 13 |
_________________
1 | 2 | 2 | 12 |

Sendo que são as duas primeiras cartas do deck[]. Em cor e naipe, ambos são de Copas. Só que a carta 0 é o Rei e a 1 é a Dama!

Você pode trabalhar com constantes pra facilitar também.

Acredito que usar ambos cor e naipe são redundantes?

E se você achar as funções da array limitadas, tente usar ds_grid, que é a mesma coisa só que mais dinâmico!

Acho que não entendi muito bem o que você quis dizer ou então você fez alguma confusão com as arrays. Eu queria algo como
baralho0 = 0; baralho1 = 1;
preto = 0; vermelho = 1;
paus = 0; espadas = 1;
copas = 0; ouros = 1;
carta[baralho0, preto, paus, 0] = ás de paus;
carta[baralho1, vermelho, copas, 12] = rei de copas;
//por aí vai

Não vejo como fazer essa diferenciação quando COR, NAIPE e VALOR são índices da mesma dimensão da array.

A cor e naipe são importantes porque há momentos em que o jogo acontece em função da cor (organização decrescente, na mesa) e momentos em que acontece em função do naipe (empilhamento crescente, no monte).

Jiraya escreveu:eu uso o seguinte script

Código:


//vector(x,y,z)
return(argument0*1000*1000+argument1*1000+argument2) div 32000;


Jiraya, você vai ter que me explicar melhor esse script! Porque div 32000? Eu entendo que qualquer trio de argumentos vai dar um valor diferente, mas... fiquei confuso com o script. Quando eu paro pra pensar, minha cabeça insiste que o certo seria div 1000, aí eu lembro que existem 3 argumentos e me perco completamente. Pergunta: isso não iria superpopular a array? Lembre-se que existe um limite para o tamanho delas (exatamente o 1000 * 1000... aí tem que ter alguma relação que eu não estou entendendo!)

...

Eu não tinha pensado em div, ainda... acaba que é possível organizar uma array unidimensional e puxar as informações da carta a partir do índice, usando div!
cartaSorteada = carta[irandom(numero_de_cartas)]; //eu vou usar ds_lists, se for fazer um jogo de verdade
baralho = cartaSorteada div 52;
cor = (cartaSorteada - 52 * baralho) div 26; // 0 = preto, 1 = vermelho
naipe = (cartaSorteada - 52 * baralho) div 13; //0 = paus, 1 = espadas, 2 = copas, 3 = ouros
valor = cartaSorteada mod 13; //ás a rei

Com isso no início de cada evento, eu altero um pouco o estilo de programação e checo diretamente pelo valor dessas variáveis, ao invés de extrair o índice delas. Na verdade, acho que essa abordagem é até mais simples. Agora que cheguei nesses cálculos, não lembro mais o que eu queria fazer antes.

Assim que o Jiraya me explicar esse script, o tópico estará resolvido.

saim escreveu:

KinKing escreveu:Fiquei com a impressão de que com o que você quer, duas dimensões seriam o suficientes!

Criemos as constantes COR = 0, NAIPE = 1 e VALOR = 2.

Então temos o deck, que é a array em si.

Quanto a primeira das cartas do deck[], deck[0,COR] dá a cor... deck[0,NAIPE] dá o naipe... e deck[0,VALOR] invoca o valor!

Imagine:

IND |COR|NAIP|NUM|
_________________
0 | 2 | 2 | 13 |
_________________
1 | 2 | 2 | 12 |

Sendo que são as duas primeiras cartas do deck[]. Em cor e naipe, ambos são de Copas. Só que a carta 0 é o Rei e a 1 é a Dama!

Você pode trabalhar com constantes pra facilitar também.

Acredito que usar ambos cor e naipe são redundantes?

E se você achar as funções da array limitadas, tente usar ds_grid, que é a mesma coisa só que mais dinâmico!

Acho que não entendi muito bem o que você quis dizer ou então você fez alguma confusão com as arrays. Eu queria algo como
baralho0 = 0; baralho1 = 1;
preto = 0; vermelho = 1;
paus = 0; espadas = 1;
copas = 0; ouros = 1;
carta[baralho0, preto, paus, 0] = ás de paus;
carta[baralho1, vermelho, copas, 12] = rei de copas;
//por aí vai

Não vejo como fazer essa diferenciação quando COR, NAIPE e VALOR são índices da mesma dimensão da array.

A cor e naipe são importantes porque há momentos em que o jogo acontece em função da cor (organização decrescente, na mesa) e momentos em que acontece em função do naipe (empilhamento crescente, no monte).

Acho que há alguma confusão aí.

Você pode indicar que a 1a carta de um baralho é um ás de paus assim:
meuBaralho[0,0] = "preto"
meuBaralho[0,1] = "paus"
meuBaralho[0,2] = 1

Enquanto que a 8a carta do meuBaralho é um valete vermelho de ouros assim:
meuBaralho[8,0] = "vermelho"
meuBaralho[8,1] = "ouros"
meuBaralho[8,2] = 11

COR (0), NAIPE (1) E VALOR (2) são todos valores que correspondem a carta do primeiro índice (0-29 para um baralho de 30 cartas)

Excelente solução! Não pude deixar de comentar, gosto muito de usar este tipo de coisa quando programo em C, pois mesmo tendo suporte a arrays multidimensionais, eu as vezes prefiro fazer desse jeito, pois programava muito acesso direto em tela SVGA $A0000000 e fazia este tipo de mapeamento usando uma função para simular o x e y em um array de uma dimensão (tela). Otimo!

vlw !
vou dar uma pesquisada sobre SVGA, parece interessante...

Jiraya, você vai ter que me explicar melhor esse script! Porque div 32000?

o gm tem um limite de 32000, isso evita que a array estoure esse limite.
ou seja, o limite do vector é 32000/3~10000
por isso, o 1000*1000, serve como um separador entre cada valor, sendo assim é perfeitamente possivel fazer operação reversa com raiz quadrada e pegar o x,y,z que você colocou nos parametros, como um make_color_rgb ~mas isso não vem ao caso.

Espere... tem uma sintaxe estranha nesse script, só notei agora!
primeiro, ele retorna as somas e multiplicações e, depois, tira o div 32000!
Isso foi testado e tem uma sintaxe nova pra eu aprender ou teve um erro de digitação?

saim escreveu:Espere... tem uma sintaxe estranha nesse script, só notei agora!
primeiro, ele retorna as somas e multiplicações e, depois, tira o div 32000!
Isso foi testado e tem uma sintaxe nova pra eu aprender ou teve um erro de digitação?

Amigo, eu acho que o "div" neste caso está garantindo o que o código gerado (uma espécie de hash code que o Jiraya fez) se mantenha dentro do limite de 32000.
Flws!

(Eu tive que pesquisar o que quer dizer hash code...)

Sim, sim, mas esse div não deveria estar antes, ou melhor, dentro do return? Depois do return, tanto faz se ele excede os 32000 ou não. (certo?)

Veja um exemplo:

Código:

vector(1, 1, 1);

isso vai me retornar 10001001. Depois de retornado, esse valor seria divado (qual o verbo que se usa aqui?) por 32000 SE o return não encerrasse o script. Mas como encerra, o valor nem sequer será divado. Então ou eu entendi errado, ou tem pelo menos um engano na digitação (não estou reclamando, só tentando entender). Da forma que eu vejo a sintaxe, o div jamais chegará a ser executado.

Agora, um hash code, pelo que entendi nas minhas pesquisas, pode retornar o mesmo valor pra diversas entradas, o que não é o que procuramos. Embora o script tenha pouca probabilidade de fazer isso, não é impossível (vector(0, 1, 0) = vector(0, 0, 1000)). No caso do jogo de cartas, eu jamais chegaria a tantas cartas, mas o script parece transceder a demanda. Por exemplo, eu poderia armazenar informações de cada inimigo eliminado pelo jogador, usando vector(tipo, defesa, hp inicial) e armazenando, na posição resultante da array, a id do objeto. Inútil, eu sei, mas é só um exercício pra entender o script. Em código:

Código:

derrotados[vector(tipo, defesa, hp_inicial)] = id;

Assim, um inimigo do tipo "0", defesa "0" e de hp inicial 1024 PODERIA ter sua id sobreposta à do inimigo do tipo "0", defesa "1" e hp inicial "24".
derrotados[vector(0, 0, 1024)] = 1000; //primeira id
-> derrotados[1024] = 1000;
derrotados[vector(0, 1, 24)] = 1001; //segunda id
-> derrotados[1024] = 1001; //sobrescrevendo o valor anterior

Não sei. Estou com a impressão que algo está aqui, na minha cara, e eu não estou vendo.

Acho que o Jiraya confundiu mod com div.
No caso div vai retornar o resto da divisão e o mod que é usado para escalar o numero de acordo com um limite.

Se "vector(0, 1, 0) = vector(0, 0, 1000)" então 0 a 999 deve ser o limite para cada argumento, mas que isso parece retornar valores conflitantes como é o caso do exemplo.
É a primeira vez que vejo essa técnica, bem interessante.

O algoritmo parece ser algo do tipo:
32000 é o limite, então posso usar 3 casas de 0, assim 3 argumentos de 1000 posições

Código:

limite = 32000;
c = 1000;
((argument0*c*c+argument1*c+argument2) mod limite);

Se fosse 320000

Código:

limite = 320000;
c = 10000;
((argument0*c*c*c+argument1*c*c+argument2*c+argument3) mod limite);

4 argumentos de 10000 posições.

Se fosse 5
( (argument0*c*c*c*c) + (argument1*c*c*c) + .... mod limite )

Ah, agora entendi! Então há mesmo um limite a ser observado em cada parâmetro! Era isso que estava me matando!
Porém fico na dúvida entre mod e div. vector(4, 0, 0), usando mod, é igual a vector (0, 0, 0). E vector(1, 0, 0) é igual a vector(0, 0, 31) usando div (se bem que mudar só o último argumento demora um bocado pra fazer alguma diferença com div, isso faz o argumento de que deve-se usar mod ganhar força).
O Jiraya já explicou, acho que estou com problemas em interpretar a resposta dele.

Usando div a formula retorna valores errados.

Código:

// com div
vector(0, 0, 0) = 0
vector(0, 0, 1) = 0
vector(0, 0, 2) = 0
vector(0, 0, n) = 0 // qualquer valor de 0 a 999 é sempre 0

// com mod
vector(0, 0, 0) = 0
vector(0, 0, 1) = 1
vector(0, 0, 2) = 2
....

Mod retorna valores não conflitantes e crescentes de (0,0,0) = 0 a (999,999,999) = 31249.

Para mim vector(4,0,0) retorna 125 e vector(0,0,0) retorna 0 com mod...
Algo esta errado ai do seu lado.

É, foi isso o que eu quis dizer com o comentário entre parênteses.

Mas vector(4, 0, 0) retorna 125 se você usar div. Usando mod retorna 0, mesmo. Mas eu cheguei nesse exemplo na base da tentativa-e-erro. vector(0, 32, 0) também TEM que retornar 0, usando mod, porque (x mod x)=0.

E vector(0, 31, 249) também seria igual a vector(999, 999, 999) - só que, no meu teste, vector(999, 999, 999) é igual a 31999... (que é 1 unidade menor que o limite! Coincidência?)

acho que não heim, pelo que me lembro e faço o "mod" retorna o resto e o div retorna o valor inteiro.

show_message(string(10 div 3))

É isso mesmo...
Gozado, fui verificar no excell se está havendo algum problema no cálculo, obtive mais um resultado diferente. Acho que vou ter que usar lápis e papel pra tirar a dúvida...
No excell, 999.999.999 / 32.000 = 31250; o que de cara, pelos últimos algarismos da equação, sabemos que não pode ser verdade. Ah, não, quando eu mando mostrar muitas casas decimais, dá 31249,99996875, o que chegaria ao valor mostrado pelo kabeção, se ao invés de simplesmente dividir, eu usasse um "div".

Estranho, os meus resultados estarem diferentes... vou verificar mais uma vez, espere um minutinho.

Ah, não, vocês me confundiram todo! O conceito está certo, mod retorna o "resto" e div retorna o "inteiro", mas os resultados estão trocados.
999.999.999 div 32000 é 31249
999.999.999 mod 32000 é 31999
o que faz com que
999.999.999 / 32000 seja QUASE 31250

devaneio do saim:

Mas estou devaneando aqui. A questão é que tanto com mod quanto com div, o script pode retornar resultados iguais pra entradas diferentes, mesmo dentro dos limites de 999 por argumento. Vamos raciocinar com mod, porque eu concordo que mod demora mais pra repetir os resultados. Pequemos vector (0, 32, 0); vector(0, 0, 0); vector(0, 0, 0) e vector(1, 24, 0); (esse último eu tive que calcular). Todos eles vão retornar o mesmo resultado: 0. Adicione o quanto quiser no último argumento de todos os exemplos pra ter resultados diferentes, mas iguais entre si.
Por isso estou com dificuldades pra entender o script. Como o vinians disse, parece ser um hash code. Mas um hash code pode, de fato, retornar resultados iguais pra entradas diferentes, é como dar uma organizada meio geralzona nos argumentos, só pra acelerar a pesquisa.
Eu escolhi alguns poucos exemplos que retornam 0, existem mais alguns. Mas são muito menos que 32000. Se eu quiser procurar um entre 32000 elementos, encontrar entre aqueles cujos argumentos retornam 0 é muito mais rápido que procurar de um a um.
Só que isso serve pra acelerar a pesquisa, não pra aumentar o número de dimensões da array - e é aí que eu me embanano, eu acho que dá, sim, pra aumentar o número de dimensões. Mas tem esses resultados iguais pra argumentos diferentes que me avacalham.

É isso mesmo. Eu que me confundi.

Estamos quebrando a cabeça pra ver se é com mod ou div mas acabei de descobrir que tem que usar os dois em conjunto.
http://gmc.yoyogames.com/index.php?showtopic=414085

@saim

Você pode usar o Google em vez de entrar no Excel:
Veja o resultado.

É só digitar na barra de pesquisa.

O código do Jiraya aparenta funcionar normalmente. Qual seria o problema?

Pelo código:
return(argument0*1000*1000+argument1*1000+argument2) div 32000;

Dá pra ver que o primeiro argumento resulta em no mínimo 1 milhão, logo você não pode usar valores maiores que 1000 no segundo e terceiro argumentos. Isso geraria mais de um número possível.

Edit: agora vi o problema, é o div. Ele sempre arredonda intervalos de 32000 para um mesmo número. O certo seria usar min() ou algo do tipo. Você pode salvar numa variável primeiro, depois ir testando.

Até mais!

Se você usar um intervalo de números maior que o limite, mesmo sendo div ou mod em algum momento dois números próximos vão retornar índices iguais. Além disso, é mais fácil elevar o número na potência da razão inversa pra fazer esse cálculo.

Se o intervalo é de 32000 pro array unidimensional e você quer dividí-lo em 3 índices, seria 32000 ^ 1/3 = 31. Portanto 31 é o alcance máximo de cada índice. Se o array for bidimensional mas usar 6 índices, o resultado é o mesmo, pois é a mesma proporção (dobrou o intervalo de números e dobrou a quantidade de índices).

Acho que um jeito legal seria dividir uma porção de bits pra cada valor. 32000 usa 15 bits, o que daria pra dividir entre dois números de 7 e o array ficaria com: 4 índices e um alcance um pouco maior que 127 pra cada índice (porque vai sobrar um 1 bit se a gente resolver querer usar). Funcionaria, daria menos trabalho e nem gastaria script.

Por exemplo (com 127):

Código:

array[((n1 << 7) | n2, ((n3 << 7) | n4))] // onde n1, n2, n3 e n4 são números de 0 a 127

.

Falou!