[Résolu] Réorganiser une liste celons une variable dans des instances

Bonsoir,
J'essai de réorganiser dans l'ordre croissant une liste en fonction de l'ordre d'une variable dans les instances classée dans la liste.
Voilà le code que j'ai pondu et qui ne fonction pas
nb: la variable dans cet exemple c'est "depth".

Create:

Code:

 
background_color=c_black;
draw_set_color(c_white);

list  = ds_list_create();
stack = ds_stack_create();
obj = object_add();

for({var i, ins; i=0}; i<=13; i+=1){
    ins = instance_create(0,0,obj);
    ins.depth=i;
    ds_list_add(list,ins);
}

Draw:

Code:

if(mouse_check_button_pressed(mb_left)){
    var i, j, f;
   
    //on rajoute 1 à toute les profondeur des obj
    for(i=0; i<ds_list_size(list); i+=1)    with ds_list_find_value(list,i) depth+=1;
       
    // on met une profondeur au hazar à zero.
    with ds_list_find_value(list,random_range(0,ds_list_size(list))) depth =0;
   
    //on "essai" de classer les profondeurs
    for( i=0; i<=ds_list_size(list); i+=1)
        for(j=0; j<ds_list_size(list);j+=1){
            f=ds_list_find_value(list,j);
            if(f.depth==i){ds_stack_push(stack,f); break;}
        }
       
    //on vide la pile et on reorganise la liste
    for(i=0; i<ds_stack_size(stack); i+=1)    ds_list_replace(list,i,ds_stack_pop(stack));
   
}

//on affiche la liste
for({var i, f; i=0}; i<ds_list_size(list); i+=1){
    f = ds_list_find_value(list,i);
    draw_text(16,16+32*i,string(f.id)+" -> "+string(f.depth));
}

A vrai dire je ne vois pas où j'ai fait une erreur...
Et je ne suis pas sur que la méthode que j'essai d'utiliser soit la meilleur.

Tu devrais utiliser ds_list_sort pour ranger ta liste.

Azy fokjlemarke! -> Ha ! onilink_ a faux!

En fait dans ma liste c'est des ID d'instances qui sont stockées, et c'est une variable stocké dans les instances que je dois réorganiser (dans cet exemple c’est "depth").

"ds_list_sort" trie les valeurs contenues dans la liste, donc les ID des instances :'(.

Ben tu met la depth et pas l'id.
Ensuite t'auras qu'a récupérer l'id en fonction de la depth (position dans la liste).
Et si t'as plusieurs id qu'on la même depth c'est pas grave vu qu'il s'agit d'ordre d'affichage.

Fin je dit ça parce que ça te permet de pas te soucier du tri, et d'obtenir un algo bien plus court et simple.

Citation :

Ensuite t'auras qu'a récupérer l'id en fonction de la depth (position dans la liste).

Mais si tu réorganise la liste les positions changent, tu fait comment pour retrouver le bon Id?

grosomodo : if (ds_list_value(list,index)==objet.depth){/*Faire ça*/}

Mmmm mais toutes les profondeurs changent à chaque clic de souris.
Et il me faut absolument les id des instances et non pas les depth dans ma liste.
Bref un truc bien compliqué.

Du coup ça ne fonctionne pas comme système.
Ce que j'ai fait je trouve ça pas mal mais il doit y avoir une erreur quelque part mais je ne vois pas où.

si tu fait un systeme de fenetre tel windows ou XWindow, j'avais deja creer ce style de systeme :
fait 2 list : depth1 et depth2 avec toute les depth dans l'ordre
ensuite tu tries dans l'ordre depth1
et ensuite tu compare depth2.

ce que tu peut faire c'est enlever depth2 pour le remplacer depth car moi je faisais ce systeme en un seul objet
si tu veux je pourrais te passer mon systeme (GM7) mais faut que je le retrouve

Oui c’est pour un gestionnaire de fenêtres/formulaires.
Le code que j'ai actuellement fonctionne bien mais il a un truc qui me plaît pas, en fait les depths descendent à chaque clic sur une fenêtre non active et la fenêtre active reviens à un depth de 0.
Ce qui fait que au bout de 100000 clics en excluant toujours la même fenêtre elle va passer derrière le BG, c'est peut probable mais bon j'aime les trucs carrés.

Sinon, tu fais en sorte que ce soient les fenêtres qui ajustent leur depth à la liste, en fonction de leur position. Tu peux même faire une boucle qui parcourt ta liste à rebours pour en afficher toutes les fenêtres (qui seront alors des objets invisibles, un event Draw au lieu de N). Pour amener une fenêtre à l'avant-plan, suffit de lui faire remonter la liste.

Caly a écrit:

Oui c’est pour un gestionnaire de fenêtres/formulaires.
Le code que j'ai actuellement fonctionne bien mais il a un truc qui me plaît pas, en fait les depths descendent à chaque clic sur une fenêtre non active et la fenêtre active reviens à un depth de 0.
Ce qui fait que au bout de 100000 clics en excluant toujours la même fenêtre elle va passer derrière le BG, c'est peut probable mais bon j'aime les trucs carrés.

je passai cette erreur. (dailleur, ce sont des doubles dans GM donc il n'y a pas de probleme : 1.6*10^306, non pas 100000)
mais si tu y tiens, verifie si la page selectionné a la souris est DEJA ACTIVE avant d'executer le script

Ha tu me donne une idée D-z.

imaginons ma liste (lettres= fenêtres, chiffres=depth):
a-1
b-2
c-3
d-4
e-5

La fenêtre d passe active:
d-1
a-2
b-3
c-4
e-5

et plus qu'à boucler pour attribuer les depth.

Edit :

Citation :

verifie si la page selectionné a la souris est DEJA ACTIVE avant d'executer le script

Déjà fait

alors comment ca se fait que la depth continue a monter ? Si la fenetre est deja active, le script de depth ne devrait pas etre executer

Les depth de toutes les fenêtres sincèrement quand je clic sur une fenêtre non active et la fenêtre active passe à un depth de 0.

ah oui je vois. Tu devrai laisser passer ca, je doute que quelqu'un change de fenetre 1.6*10^306 fois, crois moi !

Citation :

je doute que quelqu'un change de fenetre 1.6*10^306 fois, crois moi !

Moi aussi mais je pensai que c'était plus facile à coder mais bon apparemment c'est assez complexe pour pas grand chose, je verrai ça peut êtres plus tard du coup.

disons que c'est vraiment s'embêter pour rien du tout, tu peut en effet voir ca plus tard ^^

et encore même, je crois que le background est affiché avant tout autre chose, donc même un objet ayant la depth du background serait affiché après. Mais bon, c'est quand même plus propre de gérer ça de manière bornée

Je passe un peu tard et j'ai pas tout lu, mais en théorie une ds_list devrait faire l'affaire, non?


//a l'initialisation de la room

Code:

globalvar windowList;
windowList = ds_list_create();

//quand une nouvelle fenêtre est crée:

Code:

ds_list_insert( windowList , 0 , instance_create(0,0,nouvelleFenetre) );

//pour passer une fenêtre à 'active':

Code:

var index;
index = ds_list_find_index( windowList , id_de_la_fenetre );
ds_list_delete( windowList , index);
ds_list_insert( windowList , 0 , id_de_la_fenetre);

//pour afficher les fenêtres dans l'ordre:

Code:

for (i=0;i<ds_list_size( windowList) ; i+=1)
{
with(ds_list_find_value( windowList , i))
{
//Ici, les event draws de la fenêtre
}
}

Et comme ça, tout s'execute à la depth de l'objet qui fait l'affichage, donc à une depth précise, c'est relativement simple à manipuler.

Bonjour M@d _Doc,

En fait c'est ce que j'avais fait au début. Mais ce système me pose un problème.
Par exemple je créer un bouton avec comme "parent" une fenêtre.

Faut que le bouton ai le depth de la fenêtre -1 et qu'il y ai un décalage de 2 entre les depth des fenêtres pour qu'il n'y pas aucun bug.
Avec le système que tu me propose faut que le "obj_windowManager" gère le draw de tout les type d'input. Ça va être vite le foin dans son code.


Edit: par contre dans ta dernière boucle au lieu de faire un draw je n'ai qu'à attribuer un "depth=i".
Je vais essayer ça et je vous tient au courant.

Edit2:
Ça marche nickel !!

en théorie, pour l'histoire des boutons, une solution consisterai non pas à faire un with() pour appeler le code d'affichage des boutons... mais d'appeler directement l'évenement d'affichage du bouton, pour rester dans la depth de la fenêtre, avec
event_perform_object ou quelquechose comme ça...

Bon, faudrait par contre un peu bidouiller autour, vu que ça execute le script d'affichage direct dans la fenêtre, sans prendre en considération les valeurs des variables du bouton...

ça reste une piste intéressante :

Mmm je vois, oui ça peut être super intéressant, mais beaucoup plus compliqué à coder. Je pense que je vais suivre ton idée. Ça permet d'avoir une seule Depth, donc un truc vraiment stable.

Par contre as tu une idée de comment attribuer une action à une instance?
Genre dans le create:

Code:

win1= scr_create_window();
button1= scr_create_button();

with button1 {
 parent=win1;
 code_in_step="if place_meetin(mouse_x,mouse_y,self) show_message('Hello World');";
}

On est d'accord que c'est un code fictif hein , c'est juste pour te montrer un exemple.

attribuer une action à une instance? tu veux dire rajouter du code dans un event en plein jeu? ça c'est:
object_event_add(ind, evtype, evnumb, codestr)

mais c'est uniquement pour un objet, non pas pour des instances... sinon on perd le concept d'objet
ind : id de l'objet
evtype,evnumb : description de l'event (voir le manuel pour connaitre les constantes)
codestr : bah, ton code dans un string pardi!

...
En y repensant tu demandais peut être ça:
Pour que la window execute le draw du bouton:

1) dans le draw du bouton:
Le code d'affichage, tout en fonction d'un _X et un _Y si possible, pas les x,y de bases, vu qu'on executera pas le code depuis le bouton :p
Je pense qu'il sera aussi bon ton de commencer le code par: if object_index=obj_bouton {return 0;}
Comme ça, le bouton n'affichera rien, mais si ce code est appelé depuis un autre objet, ça executera le code!

2)dans le draw de la window:
Quand c'est au tour du bouton d'être affiché dans ta boucle, on part du principe que tu as: _X,_Y, position où s'affiche le bouton. tu peux les récupérer depuis le bouton lui même.
Après, tu fais un event_perform_object(obj_button , ev_draw , 0);

Ce que ça fait, c'est que ça 'copie' le code qui est dans draw, tel quel. d'où l'intérêt de prévoir le code avec _X et _Y, vu que x,y pour ton bouton, ben c'est pas la même chose pour ta window!


un exemple:

create du bouton:
text="YOUHOU je suis un bouton";
x=parentWindow.x+100;
y=parentWindow.y+20;

draw du bouton:
if object_index=obj_bouton {return 0;}
draw_roundrect(_X,_Y,_X+25,_Y+10,1);
draw_text(_X+1,_Y+1,_TEXT);

draw de la window parent:

'for every button in the window' -> id
{
_X=id.x;
_Y=id.y;
_TEXT=id.text;

}

En fait pour afficher le bouton ça ne me pose pas de problème. C'étai ta première idée dont je parlai.

Citation :

mais c'est uniquement pour un objet, non pas pour des instances

Et c'étai de ce problème ci que je parlai précisément.

J'ai fouillé dans la doc et voici l'idée que j'ai eu

Code:

code_button_draw="/*kod2lamorkitu*/"
for(/*inspection de tout les bouton*/){
    object_event_add(ind,evtype,evnumb,codestr)
    /*exucute code*/
    object_event_clear(ind,evtype,evnumb)
}

Tu en pense quoi? C'est gourmand à utiliser?

hmmm tant qu'à faire ça, je vois plus l'intérêt de passer par un objet bouton...
T'as qu'à garder les boutons pour les collisions/events, mais faire l'affichage cash dans la window, via un draw_button(x,y,text,blabla,etc...) sur la position du bouton (qui est donc invisible, lui).

Parce que là, je crois que ça devient compliqué pour rien :p

Bha en fait je veux mettre tout le code le Create:

Create:
-créer fenêtre1
-créer bouton1
-créer le code du bouton1
-créer bouton2
-créer le code du bouton2
etc...

Step:
boucle pour chaque fenêtre{
afficher la fenêtre

boucle pour chaque bouton dans la fenêtre{
affiche bouton
exécute le code du bouton
}
}

Dans ce cas, le mieux c'est d'utiliser uniquement les objets pour stocker les variables des windows/boutons : un objet est le seul moyen 'simple' à ma connaissance de faire des pseudo-classes et de stocker des variables de différents types.

Limite, crée un objet window vide, et fais ça... ailleurs:


Faut essayer de créer des 'pseudos' objets:


globalvar windowManager;
windowManager=ds_list_create();


A côté de ça, tu fais des fonctions:

//createWindow(x,y,w,h)
var _i,tempList;
_i=instance_create(0,0,window);
tempList=ds_list_create();
with(_i){
x=other.argument0;
y=other.argument1;
w=other.argument2;
h=other.argument3;
itemList = other.tempList;
}
ds_list_insert(windowManager,0,_i);
return _i

//associateItemToWindow(window,item)
ds_list_add(argument0.itemList,argument1);

Bref, etc... Les listes permettent de contenir la liste des instances associées à chaque fois, que ce soit la liste des fenêtre, une liste d'item par fenêtre, etc...

Oui c'est exactement le système que j'ai actuellement.
Le truc que je demandai c'étai comment insérer un code différent pour chaque instances.
Moi la seule solution que j'ai trouvé c'est:

Citation :

object_event_add(ind,evtype,evnumb,codestr)
/*exucute code*/
object_event_clear(ind,evtype,evnumb)

Après je sais pas si c'est vraiment ce qu'il y a de mieux.

le code doit être tellement différent? tu peux pas te débrouiller avec une variable 'type' (par ex. pour tes boutons)
Et dans le drawCode, tu mets un switch, qui affiche autre chose en fonction de la variable type?

Bha pour mon propre projet les codes seront quasi tous les mêmes (changement de variables)
Mais j'aimerai partager le manager avec la communauté donc j'aimerai qu'il soit le plus personnalisable possible même pour des débutants.
D'où mon envie de rien laisser au hasard et que tout soit parfait.