Calcolo corretto delle adiacenze

[nightwish88]

Mi affido a voi, miei amici. Sono giorni che ci penso ma non mi viene in mente una soluzione che mi soddisfa
Ho una serie di object, a forma rettangolare chiamati Quadrati. Ogni quadrato è caratterizzato da una variabile numerica che ne caratterizza il tipo e un contatore, chiamato cont per ora

Codice: Seleziona tutto

[1_0][2_0][1_0][1_0][1_0]
[2_0][1_0][1_0][2_0][2_0]
[2_0][1_0][1_0][2_0][2_0]

Ogni quadrato deve avere l'informazione del numero di adiacenze dello stesso tipo che ha con i suoi 4 lati.

Codice: Seleziona tutto

[1_0][2_0][1_2][1_2][1_1]
[2_1][1_2][1_3][2_2][2_2]
[2_1][1_2][1_2][2_2][2_2]

IL punto è che a me servirebbe inserire in ogni quadrato non l'informazione delle adiacenze personali ma quelle massime raggiunte dal gruppo. E per gruppo intendo dire l'insieme di quadrati dello stesso tipo che condividono almeno un adiacenza.

Spero di essermi spiegato, a volte non mi capisco nemmeno da solo

[Homunculus]

Non é molto chiaro in effetti, per gruppo intendi che se ci sono 5 quadrati di tipo 1, tutti e cinque dovrebbero contenere il numero di adiacenze del quadrato che ha più adiacenze?

es (tipo - adiacenze personali):

1 - 2
1 - 3
1 - 0
1 - 2
1 - 1

Tutti dovrebbero avere come numero 3, visto che é il massimo di adiacenze personali tra i quadrati di tipo 1? Oppure 8, che é il totale di adiacenze di tipo 1?

[nightwish88]

ci riprovo

ho due tipologie di quadrati: la tipologia 1 e la tipologia 2. La tipologia 1 è segnata dalla X mentre la tipologia 2 non ha la X ma numeri.

Codice: Seleziona tutto

[X][1][X][X][X]
[1][3][2][2][1]

I numeri della tipologia 2 hanno un significato: sono il numero di adiacenze che il quadrato possiede con lo stesso tipo

ho necessità di trovare un algoritmo in cui partendo da questa informazione ottengo qualcosa del genere

Codice: Seleziona tutto

[X][3][X][X][X]
[3][3][3][3][3]

in quanto 3 è il valore massimo costituito da questo gruppo di quadrati. Per ora non lavoro con matrici, non saprei nemmeno come utilizzarle. Anzi non mi interessa. Vorrei trovare un algoritmo di partenza su cui lavorare visto che per ora l'informazione delle adiacenze e tipo ce l'ho in ogni i-esimo object, le adiacenze sono fisiche ( i quadrati sono disposti nella room come appunto tanti quadrati affiancati) e le calcolo con un instance_position(x,y,obj)

[Nix]

with (quadrato) if (tipologia == 2 && cont > max) max = cont;
with (quadrato) if (tipologia == 2) cont = max;

[nightwish88]

with (quadrato) if (tipologia == 2 && cont > max) max = cont;
with (quadrato) if (tipologia == 2) cont = max;

non mi sembra un algoritmo... e sinceramente poco capisco questo tuo frammento se non solo per mero confronto di numeri

[Nix]

Allora spiegati meglio. Fin'ora ho capito che vuoi prendere il valore massimo di una variabile su tutti gli oggetti di un certo tipo e impostarla su questi.

[ZerA78]

mi viene in mente una ds_grid in cui memorizzare i quadrati e una ds_list in cui inserire i valori delle loro adiacenze e poi ordinarli per valore massimo. Infine prendi come riferimento il primo valore(massimo) della lista. Oppure mi sembra che c'e' anche una funzione che su tot valori ti restituisce il valore max.. Ma non mi ricordo come si chiama di preciso

[nightwish88]

Allora spiegati meglio. Fin'ora ho capito che vuoi prendere il valore massimo di una variabile su tutti gli oggetti di un certo tipo e impostarla su questi.

beh si è esatto... ma il mio problema non è assegnare una variabile a secondo di un controllo di massimi e minimi ma tirar fuori un algoritmo che effettua automaticamente tutto ciò senza rallentare troppo. Mi vengono solo in mente doppie visite con funzioni annidate, speravo in una soluzione meno complessa.

[Nix]

Allora spiegati meglio. Fin'ora ho capito che vuoi prendere il valore massimo di una variabile su tutti gli oggetti di un certo tipo e impostarla su questi.

beh si è esatto... ma il mio problema non è assegnare una variabile a secondo di un controllo di massimi e minimi ma tirar fuori un algoritmo che effettua automaticamente tutto ciò senza rallentare troppo.

L'instance_position per rilevare le adiacenze è già molto lento, non credo cambi molto aggiungendo quel controllo su cont.

mi viene in mente una ds_grid in cui memorizzare i quadrati e una ds_list in cui inserire i valori delle loro adiacenze e poi ordinarli per valore massimo. Infine prendi come riferimento il primo valore(massimo) della lista.

Ordinando è ancora più lento.

[nightwish88]

...

mmm forse ho capito cosa intendevi dire. Mi ero troppo concentrato su un metodo ricorsivo o visita globale dall'esterno che mi è sfuggita la soluzione (forse) banale

posto qui il codice, funziona, spero solo che non mi rallenti tutto in futuro

Codice: Seleziona tutto

//calcolo punteggio
        if mov=0 and vspeed<0.6{
            cont_col=0
            //calcolo delle adiacenze
            for(i=0;i<4;i+=1)
            {  
                var xx;xx=lengthdir_x(30,90*i);
                var yy;yy=lengthdir_y(30,90*i);
                var idd;idd=instance_position(x+xx,y+yy,Cassa)
                if (instance_exists(idd)) {
                    if idd.mov=0 and idd.vspeed<0.6 {if idd.tip=tip {cont_col+=1;}}
                }
            }
            //confronto con vicini
            for(i=0;i<4;i+=1)
            {  
                var xx;xx=lengthdir_x(30,90*i);
                var yy;yy=lengthdir_y(30,90*i);
                var idd;idd=instance_position(x+xx,y+yy,Cassa)
                if (instance_exists(idd)) {
                    if idd.mov=0 and idd.vspeed<0.6 {if idd.tip=tip {if idd.cont_col>cont_col {cont_col=idd.cont_col;}}}
                }
            }
        }