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

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!