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

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!

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

Spoiler:

Eu não axo que um array de 4dimensões vá resolver o seu problema...
já passei por situações parecidas e em todas elas é preciso lidar com os índices das arrays,porque ela é quem vai identificar a carta.
E varrer uma lista de arrays em busca de índices é meio cansativo!
Eu sugiro que você use arrays separadas,unidimensionais mesmo:
-numero[]
-nipe[]
-cor[]
-valor[]

Mas como eu vou saber quem é quem??

Pelo índice! Cada índice é uma carta.
EX:
Um 2 de copa:
numero[0]=2
nipe[0]=copa
cor[0]=vermelho
valor[0]=0

Nessa carta, eu sei que o índice 0 em qualquer uma das arrays representa o 2 de copa.

Você ainda vai ter a possibilidade de trabalhar com elas separadamente, por exemplo, ao querer comparar o valor, você vai usar apenas a array valor[], ou ao querer escrever o número dela na tela, vai usar apenas a array numero[].

Eu uso assim e sempre funciona nos meus jogos de cartas.

Oi, mrbrum22!
Acho que você usa uma forma diferente da que eu visualizo, pra se organizar. O que eu penso que se faz pra, por exemplo, embaralhar as cartas, é jogar todas elas numa ds_list e usar ds_list_shuffle.
No seu caso, tenho a impressão de que cada carta recebe um índice de uma array, é isso? Tipo, as cartas são objetos e você as cria através de loops em uma-por-uma das arrays, algo como

Código:

with(instance_create(x, y, objCarta){
numero = 2; naipe = copa; cor = vermelho; valor = 0;
}

Se for isso mesmo, como você faz pra embaralhar as cartas e, ao mesmo tempo, garantir que o baralho não tenha dois ases de espadas?

Na verdade, o problema das cartas já foi resolvido. Cheguei à conclusão que se tivermos um número constante de cartas por naipe (e nós temos), basta definir uma constante crescente pra representar as cartas e calcular as variáveis , quando necessário, usando div e mod. Acho que um script assim resolveria:

Código:

carta = argument0;
baralho = carta div 52; //52 cartas/baralho, sem curingas.
cor = (carta - 52 * baralho) div 26; //26 cartas/cor em cada baralho
naipe = (carta - 52 * baralho) div 13; //13 cartas/naipe em cada baralho
valor = carta mod 13; //13 valores pra dividir entre as cartas

Ai, preto = 0; vermelho = 1;
paus = 0; espadas = 1; copas = 2; ouros = 3;
Ás = 0; "2" = 1; "3" = 2; ... ; valete = 10; dama = 11; rei = 12;
Dá pra incluir curingas, também, com algumas modificações mais chatinhas, se colocarmos eles no final do baralho.

Depois que cheguei nessa conclusão, o tópico perdeu o sentido, mas antes disso surgiu o script do Jiraya, que promete tornar possível criar arrays multidimensionais. Mesmo que não seja útil agora, certamente é interessante...

@Kabeção: ainda não consegui ver o link (a yoyogames é bloqueada aqui), por isso ainda não respondi. Mas estou curioso.

@Pedrø: Notou, né? Tanto o div quanto o mod (ver minha última mensagem) apresentam esse problema.
Agora, não entendi suas sugestões. Como usar min, nesse caso? E que tipo de teste eu poderia fazer?

@Ninja8086: Você e seus binários... eu ainda estou tentando entender o que você fez, eu não raciocino em binário com muita velocidade. Tenho que jogar tudo no papel, testar valores, reler os conceitos e operações, etc. Mas eu vou entender, não esquente.

Amigos, o mod é um operador que retorna o resto da divisão. É classico utiliza-lo como uma forma fácil de evitar a extrapolação de limites de um número qualquer. Isso é muito utilizado pois teoricamente uma operação inteira de divisão é mais rapida do que utilizar algum IF da vida para verificar o limite.

Por exemplo se eu quero que um resultado, não importando o tamanho que ele gere sempre seja menor ou igual a 10 basta fazer isso, veja o exemplo:
resultado = (10 * irandom(100) * alguma_coisa) mod 10;
resultado = (100000) mod 10;
resultado = (meu_super_calculo * 10) mod 10;
tudo será menor ou igual a 10.
Ou seja o RESTO de uma divisão por 10 nunca vai ser maior que 10. Foi para isso que o nosso amigo Jiraya colocou o DIV, na verdade ele queria colocar o MOD e se enganou.
Agora quanto ao fato do cálculo gerar valores repetidos comprometendo a utilização do método para usar pseudo arrays multidimensionais ai já outra história.
Mas como diz um amigo meu, uma coisa é uma coisa, outra coisa é outra coisa.
Flws!

@saim
Acho que vc não etendeu corretamente...
Eu crio as cartas através de arrays "abstratas",não uso nenhum objeto pra fazer isso.

Spoiler:

No início do jogo, provavelmente em algum create, eu crio as cartas,através de laços de for aninhados.
EX:
cartas=0
for(i=0;i<=10;i+=1){
for(j=0;j<=4;j+=1){
nipe[cartas]=j
}}
*pra cada nipe,teria 4números de cartas.

O modo de sorteio que eu uso é justamente esse da list.
Eu jogo todos os ids de cartas(provavelmente de 0a39) na lista.
Sorteio a lista.
E vou puxando os valores na medida que eu preciso.

@kabeção: Eu vi o link. Não fui a fundo na teoria, mas deu pra ver que é mais complexo do pensávamos, a princípio. Acho que, com esforço, dá pra refazer, se partirmos do princípio dos limites pra cada argumento, mas... agora bateu aquela preguiça, sabe?

@Ninja8086: Consegui entender a teoria. Tive que rascunhar uma calculadora no GM mesmo, porque o excell não tem os operadores bitwise, mas consegui compreender. Se deixarmos de lado a simetria, podemos ter um limite de (quase) 127 pra um argumento e de 255 pro outro, mas isso excede um pouco os 32000 (dá 32767). Eu imaginei que os 32000 pudessem ser um arredondamento do manual, mas não, realmente dá erro usar esse índice.
Já que 32000 é 1111101 00000000 (125 << , podemos usar o primeiro argumento com limite de 124 (11111100) e o segundo com limite de 255 (11111111), perdendo apenas um índice do limite.
array[n1 << 8 | n2, n3 << 8 | n4]
Mas não dá pra inverter os limites.

@mrbrum22: acho que você quiz dizer:

Código:

for(i=0;i<=10;i+=1){
for(j=0;j<4;j+=1){
nipe[i]=j
}}

certo? (é que não aparece, no código, o que significa "cartas").
Ou, talvez, algo como

Código:

nCartas = 10; //número de cartas por naipe
for(i=0;i<nCartas;i+=1){
for(j=0;j<4;j+=1){
nipe[i + nCartas * j]=j
}}

Aí, nesse caso, os índices da array "nipe" variariam de 0 a 39, sendo que os resultados seriam
nipe[0 a 9] = 0;
nipe[10 a 19] = 1;
nipe[20 a 29] = 2;
nipe[30 a 39] = 3;
É isso? Se for, é mais ou menos a mesma coisa que eu fiz, só que ao contrário. As cartas seriam só índices, ou seja, valores inteiros (abstratos, como você disse), e as cores, naipes e baralhos de onde elas vêm seriam determinados em função da distribuição desses valores dentro dos limites.

Hmm.., talvez dê pra modificar aquele script que eu passei, pra determinar o valor de cada índice da array...

Código:

for(i = 0; i < 52; i += 1){
defineCarta(i)
}

Código:

// script defineCarta
carta = argument0;
baralho[carta] = carta div 52; //52 cartas/baralho, sem curingas.
cor[carta] = (carta - 52 * baralho) div 26; //26 cartas/cor em cada baralho
naipe[carta] = (carta - 52 * baralho) div 13; //13 cartas/naipe em cada baralho
valor[carta] = carta mod 13; //13 valores pra dividir entre as cartas

Daí, posso fazer isso só uma vez no jogo, sem ter que rodar o script a cada ação. Isso melhora bem a performance! E, nos objetos-carta (se houverem), eu coloco uma variável (tipo "indice_carta") e posso fazer testes como

Código:

var corNaMesa, corNaMão, valorNaMesa, valorNaMao;
corNaMesa = cor[cartaNaMesa.indice_carta];
corNaMão = cor[cartaNaMão.indice_carta];
valorNaMesa = valor[cartaNaMesa.indice_carta];
valorNaMao = valor[cartaNaMão.indice_carta ;
if (corNaMesa  != corNaMão && valorNaMesa == (valorNaMao + 1)) {
//movimento permitido
}
else {
//movimento proibido
}

Taí, agora fiquei satisfeito com os resultados! Por mim, podem trancar o tópico. Acho que ainda tem coisa interessante pra vir por aí, mas tudo o que eu queria já foi resolvido.

Não tranquem ainda...

na verdade era aquilo mesmo, mas eu esqueci de incrementar a variável cartas.

Bom esse é o método que eu uso,uma array para cada dado que eu quero recuperar.
Aqui está um código que eu uso no create para criar cartas,com nipe,nome,numero e valor:

Código:

totalcartas=0 //total de cartas

//criando a lista de índice das cartas(40):
cartas=ds_list_create()

//criando as cartas do baralho:
for(i=1;i<=10;i+=1){
for(j=0;j<4;j+=1){
numero[totalcartas]=i
nipe[totalcartas]=j
//adicionando o indice para a lista:
ds_list_add(cartas,totalcartas)
//nomeando as cartas:
if numero[totalcartas]==1 nome[totalcartas]="A"
else if numero[totalcartas]==8 nome[totalcartas]="Q"
else if numero[totalcartas]==9 nome[totalcartas]="J"
else if numero[totalcartas]==10 nome[totalcartas]="K"
else nome[totalcartas]=string(numero[totalcartas])

//pontuando as cartas:
if numero[totalcartas]==1 pontos[totalcartas]=11
else if numero[totalcartas]==7 pontos[totalcartas]=10
else if numero[totalcartas]==8 pontos[totalcartas]=2
else if numero[totalcartas]==9 pontos[totalcartas]=3
else if numero[totalcartas]==10 pontos[totalcartas]=4
else pontos[totalcartas]=0


totalcartas+=1;
}}

ENGINE

Agora sim pode trancar!