Como tornar isto possivel

Boa noite, para introduzir a minha pergunta vou uzar um codigo, que nao dá, nem vai dar é so para entender o problema.

Código:

chose0=choose(obj_A,obj_B,obj_C,obj_D)
chose1=choose(obj_A,obj_B,obj_C,obj_D)-chose0
chose2=choose(obj_A,obj_B,obj_C,obj_D)-chose0-chose1
cohse3=choose(obj_A,obj_B,obj_C,obj_D)-chose0-chose1-chose2

acho que com este codigo da para perseber que o que eu quero fazer é, que o GM escola um objeto por min, e guardar qual o objeto na variavel chose0, e a variavel chose1 seria igual á escola pelo GM menos o objeto que ja foi escolhido pelo chose0 ( ou seja chose1 só tiria 3 hipoteses de escolha ) e assim sussecivamente

ds_list

Cada objeto representa um indice:
0 = objA
1 = objB
3 = objC
...

O que você tem que fazer e escolher um indice e exclui-lo das próximas alternativas.
Então cria um lista e adicione os valores

Código:

lista = ds_list_create();
ds_list_add(lista,objA);
ds_list_add(lista,objB);
ds_list_add(lista,objC);
....

Use a função ds_list_size pra saber quantos item a lista tem e ai fica fácil.

Código:

escolha[0] = ds_list_find_value(lista,irandom(ds_list_size(lista)-1));
ds_list_delete(lista,escolha[0]); // Deletar indice

escolha[1] = ds_list_find_value(lista,irandom(ds_list_size(lista)-1));
ds_list_delete(lista,escolha[1]); // Deletar indice

escolha[2]...

E não se esqueça de destruir a lista no final do processo.

Código:

ds_list_destroy(lista)

Já que é pra usar ds_lists, pode-se usar a função ds_list_shuffle, que embaralha a lista toda. Uma vez embaralhada a lista, percorre-se ela toda, em linha reta. O ganho disso é não ter que deletar cada índice que for sendo usado (embora isso não signifique muita coisa, no final das contas).

Existe uma forma de fazer um embaralhamento que funciona com versões lite do game maker, porque usa arrays ao invés de ds_lists. Como vou deixar só a título de curiosidade aqui, num spoiler, não vou traduzir.

embaralhamento lite:

Como nao persebi muito bem isso, dessidi fazer o meu proprio codigo, recorrendo nas probablididades de calhar, fiz todas... por isso ja podem imaginar o tamanho do script xP.

Código:

chose_0=choose(argument0,argument1,argument2,argument3)
if chose_0=argument0 {chose_1=choose(argument1,argument2,argument3)}else{if chose_0=argument1{chose_1=choose(argument0,argument2,argument3)}}
if chose_0=argument2 {chose_1=choose(argument1,argument0,argument3)}else{if chose_0=argument3{chose_1=choose(argument0,argument2,argument1)}}
if chose_0=argument0 and chose_1= argument1{chose_2=choose(argument2,argument3)}
if chose_0=argument0 and chose_1= argument2{chose_2=choose(argument1,argument3)}else{if chose_0=argument0 and chose_1=argument3{chose_2=choose(argument1,argument2)}}
if chose_0=argument1 and chose_1= argument0{chose_2=choose(argument2,argument3)}
if chose_0=argument1 and chose_1= argument2{chose_2=choose(argument0,argument3)}else{if chose_0=argument1 and chose_1=argument3{chose_2=choose(argument0,argument2)}}
if chose_0=argument2 and chose_1= argument0{chose_2=choose(argument1,argument3)}else{if chose_0=argument2 and chose_1=argument1{chose_2=choose(argument0,argument3)}}
if chose_0=argument2 and chose_1= argument3{chose_2=choose(argument0,argument1)}
if chose_0=argument3 and chose_1= argument0{chose_2=choose(argument1,argument2)}else{if chose_0=argument3 and chose_1=argument1{chose_2=choose(argument0,argument2)}}
if chose_0=argument3 and chose_1= argument2{chose_2=choose(argument1,argument0)}
if chose_0=argument0 and chose_1= argument1 and chose_2=argument2{chose_3=argument3}else{if chose_0=argument0 and chose_1=argument1 and chose_2=argument3{chose_3=argument2}}
if chose_0=argument0 and chose_1= argument2 and chose_2=argument1{chose_3=argument3}else{if chose_0=argument0 and chose_1=argument2 and chose_2=argument3{chose_3=argument1}}
if chose_0=argument0 and chose_1= argument3 and chose_2=argument1{chose_3=argument2}else{if chose_0=argument0 and chose_1=argument3 and chose_2=argument2{chose_3=argument1}}
if chose_0=argument1 and chose_1= argument0 and chose_2=argument2{chose_3=argument3}else{if chose_0=argument1 and chose_1=argument0 and chose_2=argument3{chose_3=argument2}}
if chose_0=argument1 and chose_1= argument2 and chose_2=argument0{chose_3=argument3}else{if chose_0=argument1 and chose_1=argument2 and chose_2=argument3{chose_3=argument0}}
if chose_0=argument1 and chose_1= argument3 and chose_2=argument0{chose_3=argument2}else{if chose_0=argument1 and chose_1=argument3 and chose_2=argument2{chose_3=argument0}}
if chose_0=argument2 and chose_1= argument0 and chose_2=argument1{chose_3=argument3}else{if chose_0=argument2 and chose_1=argument0 and chose_2=argument3{chose_3=argument1}}
if chose_0=argument2 and chose_1= argument1 and chose_2=argument0{chose_3=argument3}else{if chose_0=argument2 and chose_1=argument1 and chose_2=argument3{chose_3=argument0}}
if chose_0=argument2 and chose_1= argument3 and chose_2=argument1{chose_3=argument0}else{if chose_0=argument2 and chose_1=argument3 and chose_2=argument0{chose_3=argument1}}
if chose_0=argument3 and chose_1= argument0 and chose_2=argument1{chose_3=argument2}else{if chose_0=argument3 and chose_1=argument0 and chose_2=argument2{chose_3=argument1}}
if chose_0=argument3 and chose_1= argument2 and chose_2=argument0{chose_3=argument1}else{if chose_0=argument3 and chose_1=argument2 and chose_2=argument1{chose_3=argument0}}
if chose_0=argument3 and chose_1= argument1 and chose_2=argument0{chose_3=argument2}else{if chose_0=argument3 and chose_1=argument1 and chose_2=argument2{chose_3=argument0}}

Bem e aqui está ele, testei varias vezes e nao deu erro, mas é possivel ter me enganado, se alguem esta com algum problema como o meu e nao perseber nd de lista pode uzar este scritp e adaptar ao seu gosto

Não chega a ter erro, mas eu recomendo usar o else no código inteiro ou em parte nenhuma. Do jeito que você fez, o resultado será ok, mas nota-se um pouco de indecisão quanto à forma de fazer o código. Eu vou ilustrar usando as 3 primeiras linhas.

Código:

chose_0=choose(obj_A,obj_B,obj_C,obj_D)
if chose_0=obj_A {chose_1=choose(obj_B,obj_C,obj_D)}else{if chose_0=obj_B{chose_1=choose(obj_A,obj_C,obj_D)}}
if chose_0=obj_C {chose_1=choose(obj_B,obj_A,obj_D)}else{if chose_0=obj_D{chose_1=choose(obj_A,obj_C,obj_B)}}

Suponha que, na primeira linha, choose_0 resulte em obj_D. Na linha seguinte, o if-else só prevê as opções "Obj_A" e "Obj_B", portanto o valor de choose_1 não será definido. Na terceira linha, você corrige isso, mas poderia fazer de uma forma mais coerente:

Código:

chose_0=choose(obj_A,obj_B,obj_C,obj_D)
if chose_0=obj_A {chose_1=choose(obj_B,obj_C,obj_D)}
else {if chose_0=obj_B{chose_1=choose(obj_A,obj_C,obj_D)}}
else {if chose_0=obj_C{chose_1=choose(obj_B,obj_A,obj_D)}}
else {if chose_0=obj_D{chose_1=choose(obj_A,obj_C,obj_B)}}

O resultado final é o mesmo, mas o código foi todo feito de uma só vez.

Bom, dito isso, você tem plena concsiência do quanto seu código está mais difícil de digitar do que se tivesse usado ds_lists. Só que, além disso, ele está também mais difícil de processar (mais lento) e menos flexível. Suponha que você tivesse 20 opções ao invés de apenas 4. Agora vale a pena estudar as lists e arrays um pouco mais a fundo?

Bom, pense nas ds_lists ou arrays como um monte de caixinhas colocadas em fila reta. Esse "monte" pode representar qualquer quantidade de caixinhas que você quiser, use um número que você se sinta confortável. Além disso, cada caixinha tem, no chão ao lado dela (não colado nela), um número. Esse número no chão começa em zero e a cada caixinha ele aumenta em uma unidade. Então você terá a caixinha-0, a caixinha-1, a caixinha-2, ...
Você pode colocar o que quiser em cada uma dessas caixinhas, pode até repetir o conteúdo delas (a caixinha-0 conter a mesma coisa que a caixinha-1). Recomenda-se colocar sempre o mesmo tipo de coisa em todas as caixinhas.
Isso é uma ds_list. Isso é uma array.

O que o kabeção sugeriu foi: crie uma linha de caixinhas e escolha aleatoriamente uma caixinha pra tirar o objeto. Quando tirar o objeto, elimine a caixinha. Como estamos falando em uma ds_list, as caixinhas que tiverem número maior que o da caixinha escolhida vão mudar de posição, de forma que a linha de caixinhas diminua e não haja espaço entre as caixinhas.

O que eu sugeri foi: crie uma linha de caixinhas e embaralhe a linha toda, sem mexer nos números no chão. Com a linha embaralhada, vá pegando os objetos de caixinha por caixinha, na ordem dos números no chão.
Depois eu mostrei uma forma complicada de chegar no mesmo resultado usando arrays, mas não vou explicar como fazer isso usando a analogia das caixinhas, a menos que seja realmente necessário.

As ds_lists têm um monte de funções que ajudam a trabalhar com as caixinhas. Você pode saber o tamanho da linha de caixinhas, pode embaralhar a linha, organizar de forma crescente, pode procurar o número da caixinha com determinado conteúdo ou olhar o conteúdo da caixinha com determinado número. São funções com uma sintaxe meio chata, mas a dificuldade toda fica só na sintaxe.

Sim tens razao podia fazer dessa maneira e tb seria menos confuso, mas fiz isto a pressa pq amanha tenho teste global a biologia e tenho de estudar 2 livros (fg), e como tive esta ideia para fazer isto, decidi fazer agora antes que me esquece-me.

Podes aconselhar-me algum tuto sobre Listas??? (arrays ja estou +/- dentro delas)

P.S. se nao fosse o conhecimento de matematica sobre probabilidades ( diagrama de arvore ) estava lixado pois ira se tornar extremamente confuso.

kadini escreveu:Podes aconselhar-me algum tuto sobre Listas???

Não. Felizmente ou infelizmente, não. Acontece que o que eu expliquei acima é basicamente tudo o que você precisa saber, o resto é só exemplo e listagem de funções. ds_lists são realmente tão simples quanto arrays, só mais "turbinadas" com algumas funções que as arrays não têm e portanto permitem chegar em determinados objetivos de forma muito mais simples.
Pra listagem de funções, ninguém melhor que o manual. Eu poderia traduzir o que o manual diz, mas o google faria isso melhor que eu.

Quanto aos exemplos... bom, tem esse seu, que é embaralhar uma série de elementos. Você pode também usar as ds_lists pra fazer inventários, sendo que cada elemento da ds_list armazena um item do inventário - o que permitiria, também, organizar os inventários automaticamente. Outra coisa é que transformar uma ds_list em uma string (usando ds_list_write) e gravar essa string num .ini ou mesmo um .txt é uma forma fácil de gravar dados do jogo sem usar o famigerado game_save.
Mas tem outras utilidades pras ds_lists, que não me vêm à cabeça agora. Na verdade, você vai inventando a utilidade dessas funções à medida que precisa delas.
"Puxa, eu preciso de uma forma de gravar quais esmeraldas o sonic já pegou - ah, vou usar uma ds_list ou uma array!", "seria legal se as esmeraldas ficassem organizadas, em ordem de cor - hm, então vou gravar só as cores numa ds_list e usar ds_list_sort pra organizá-las".
Existem outras estruturas de dados, além das ds_lists que também são muito úteis. Eu gosto do ds_stack pra criar "undos" (embora nunca tenha de fato usado isso), gosto das ds_grids pra trabalhar grandes quantidades de dados e até hoje não encontrei uma utilidade pras ds_maps (quase usei elas pra um highscorelist personalizado, mas esbarrei num probleminha e tive que fazer a coisa na mão mesmo - usando ds_lists). Suponho que um inventário em que se armazene também a quantidade de cada item seria uma boa utilidade pra uma ds_map. Pras ds_queue e ds_priority, ainda não consegui chegar perto de uma utilidade, mas tenho certeza que essas utilidades existem (de outra forma, as funções não seriam inventadas).

Um jeito fácil é esse:

Código:


objetos = ds_list_create()
ds_list_add(objetos, choose(objeto0, objeto1, objeto2, objeto3, objeto4, objeto5) )

for(i=1; i<total_de_escolhas_incluindo_a_primeira; i+=1)
{
escolha[i] = choose(objeto0, objeto1, objeto2, objeto3, objeto4, objeto5)

while (ds_list_find_index(objetos, escolha[i]) ! = -1)
escolha[i] = choose(objeto0, objeto1, objeto2, objeto3, objeto4, objeto5);
}

Até mais!

Pedrø escreveu:

Código:


objetos = ds_list_create()
ds_list_add(objetos, choose(objeto0, objeto1, objeto2, objeto3, objeto4, objeto5) )
escolha[0] = ds_list_find_value(objetos, 0); //faltou essa linha

for(i=1; i<total_de_escolhas_incluindo_a_primeira; i+=1)
{
escolha[i] = choose(objeto0, objeto1, objeto2, objeto3, objeto4, objeto5)

while (ds_list_find_index(objetos, escolha[i]) ! = -1)
escolha[i] = choose(objeto0, objeto1, objeto2, objeto3, objeto4, objeto5);

ds_list_add(objetos, escolha[i]); //faltou essa linha
}

Não testei, mas acho que precisa dessas duas linhas pra dar certo. O resultado é uma array embaralhada, não uma lista. Mas acho que o método tradicional é mais fácil:

Código:

objetos = ds_list_create(); //cria a lista
// adiciona os objetos à lista, um-a-um ou num loop, se for possível. Vou mostrar como fazer um-a-um porque estamos falando de objetos, não de valores.
ds_list_add(objetos, objeto0);
ds_list_add(objetos, objeto1);
ds_list_add(objetos, objeto2);
ds_list_add(objetos, objeto3);
ds_list_add(objetos, objeto4);
ds_list_add(objetos, objeto5);
//com a lista pronta, embaralha-se a lista
ds_list_shuffle(objetos);

Pronto, a lista está completa e embaralhada. Pegar os elementos em ordem de índice vai gerar um resultado aleatório. Supondo que você queira criar os elementos em linha reta, separando-os por uma distância fixa (digamos, 50 pixels), você pode fazer isso num loop:

Código:

var i;
for (i = 0; i < ds_list_size(objetos); i += 1) { //note que ds_list_size te retorna o número de elementos, não o índice do último elemento
instance_create(x + 50 * i, y, ds_list_find_value(objetos, i));
}
// uma vez que a lista não tem mais utilidade, elimina-se a lista
ds_list_destroy(objetos);

ds_stack é uma boa pedida nesse caso. Adoro usar stack em estruturas de pastas, por exemplo. Acho que é o jeito mais fácil de controlar diretórios... Fiz um exemplo aqui usando ds_list e ds_stack. Veja se é isso mesmo que você quer:

http://dl.dropbox.com/u/77818756/escolher_lifo_list_stack.gmk

-> Barra de espaços cria um objeto aleatório.
-> Enter pra reiniciar a room.


Pra criar a lista:

Código:


// Cria a lista com os id's dos objetos (id de recurso);
ListaIDs := ds_list_create();

// Adiciona os objetos na lista:
ds_list_add(ListaIDs, obj_A);
ds_list_add(ListaIDs, obj_B);
ds_list_add(ListaIDs, obj_C);
ds_list_add(ListaIDs, obj_D);

// Embaralha a lista:
ds_list_shuffle(ListaIDs);

// Cria uma pilha "LIFO" nova:
ListaObjetos := ds_stack_create();

// Faz a pilha a partir da lista:
for (n := 0; n < 4; n += 1) ds_stack_push(ListaObjetos, ds_list_find_value(ListaIDs, n));

// Destrói a lista
ds_list_destroy(ListaIDs);


Pra pegar um objeto, criá-lo e já retirá-lo da pilha:

Código:


if ds_stack_size(ListaObjetos) > 0 then
begin
    // Cria o objeto na tela:
    instance_create(
        random(200),
        random(200),
        ds_stack_pop(ListaObjetos));
end;


Hmm, nunca pensei em usar ds_stacks assim. Sempre pensei que o formato das ds_stacks (last-in-first-out) era perfeito pra criar undo's e só pra isso.
Vale a pena comentar que, nesse caso, uma ds_list_queue, que tem um formato quase oposto ao das stacks (first-in-first-out) funcionaria com a mesma eficiência.
Seria bom, também, colocar um "else" nesse "if". SE a pilha é maior que zero, pega-se um valor dela. SENÃO, elimina-se a pilha.

Mas estou comentando isso só pra gerar alguma discussão a respeito das data structures, qual utilidade de cada tipo, etc. Ainda acho que manter o esquema nas ds_lists é mais direto e flexível - por exemplo, você pode reembaralhar a lista após usá-la, deixando infinita a geração aleatória de objetos e só repetindo itens após a primeira rodada.

saim escreveu:Hmm, nunca pensei em usar ds_stacks assim. Sempre pensei que o formato das ds_stacks (last-in-first-out) era perfeito pra criar undo's e só pra isso.

Se for aquele "undo" do "Ctrl + Z", nunca usei pra essa finalidade, mas penso o contrário. Acho que lists seriam melhores pra "undo's" por dois motivos: permitir o acesso à qualquer das etapas em qualquer ordem e possibilitar "redo's" a partir de qualquer posição, já que ela não retiraria itens da lista como é feito no stack.

Há um tempo atrás o dungeon333 postou uma maneira legal de "voltar no tempo" do gameplay, como se fosse um "Prince of Persia Sands of Time". É um outro exemplo interessante de usar stacks.

saim escreveu:Vale a pena comentar que, nesse caso, uma ds_list_queue, que tem um formato quase oposto ao das stacks (first-in-first-out) funcionaria com a mesma eficiência.

"ds_list_queue" é recurso da versão 8.1? Eu não uso a 8.1. Uso a 6.1 e 8.0. Nelas, só tem as "ds_queue's", mas nas ds_lists não tem essa funcionalidade. A intenção, na realidade, é apenas retirar o item da pilha e manter os demais. Pegá-lo do ínicio ou do final, nesse caso, é opcional.

saim escreveu:Ainda acho que manter o esquema nas ds_lists é mais direto e flexível - por exemplo, você pode reembaralhar a lista após usá-la, deixando infinita a geração aleatória de objetos

O trabalho da list ficaria apenas por sortear o conteúdo. Acho que o mecanismo do stack é mais direto do que ter que pegar e retirar itens da lista manualmente, já que o trabalho dele é justamente esse: apenas empilhar e desempilhar.

Se for necessário sortear novamente, é só usar o shuffle da lista outra vez (apesar disso já ter sido feito...). Não desprezei nenhum dos métodos. No exemplo que fiz upload usei ambos os recursos.

Valeu!!

Ninja8086 escreveu:"ds_list_queue" é recurso da versão 8.1?

Erro meu. A ds é só "ds_queue", sem "list". Ela está na 8.0, não sei se está na 6.1.

Quanto aos undo's, você tem razão, não tinha pensado em redo's. O acesso a qualquer etapa também é um avanço que eu não tinha pensado, realmente hoje em dia (isso deve ter pelo menos uma década!) existe uma lita drop-down em que você pode escolher quanta coisa desfazer. Acho que eu parei no tempo...

Você tem um link dessa engine do dungeon333? Eu conheço o uso arrays pra voltar no tempo, com um for "ao contrário" (correndo do último índice ao primeiro). Agora esqueci como faz, mas é bem legalzinho, também.

saim escreveu:Você tem um link dessa engine do dungeon333? Eu conheço o uso arrays pra voltar no tempo, com um for "ao contrário" (correndo do último índice ao primeiro). Agora esqueci como faz, mas é bem legalzinho, também.

Não é um engine, é só uma ideia, mas o tópico é esse: https://gmbr.forumeiros.com/t17454-voltar-no-tempo

A ideia do array é excelente, mas no caso do stack, é só pela facilidade que ele oferece. O conceito é o mesmo.

Lol, ele só quer excluir a possibilidade de um item que ja foi escolhido sair.
entaum ao invés de ds_list, num seria mais fácil usar while não ?

While é lento. Ele iria jogando valores ATÉ sair algum que ainda não tenha saído. Com a ds_list, ele garante que o próximo valor sorteado será válido.

Pra um computador, esse "lento" é bem relativo. Por exemplo, num universo de 50 opções, dificilmente notaria-se alguma coisa, e mesmo se for notado, o lag não deve chegar a um segundo. Mas o método é lento e, portanto, é boa prática evitá-lo.

Hmm.
Utilizo o while, mas a quantidade de escolhas que o envolve é apenas 3, acho que por isso não noto diferença .