Minigolf - approcio pallina nella buca

[funkygallo]

Hola boys,
sto cercando di fare un gioco sul minigolf in 2D vista dall'alto.

Sto affrontando il problema dell'approccio/caduta della pallina nel buco usando la fisica integrata in GMS.
Ora come ora, molto brutalmente "shifto" la pallina verso la buca, se dista meno di 4 pixel, la butto dentro!

L'ideale sarebbe un codice che faccia cadere la pallina oppure un movimento a spirale.

Avete idee su come si possa realizzare? (presumo usando seno e coseno...)

[steep event]

Codice: Seleziona tutto

if (phy_speed >= 0.01 && phy_speed <= 6.02)
{
    if (distance_to_point(obj_hole.x,obj_hole.y) < 4)
    {
          if phy_position_x != obj_hole.x
           {
            phy_position_x = obj_hole.x;
            phy_position_y = obj_hole.y;           

            with obj_ball // ball resize
             {
              image_xscale = 0.20;
              image_yscale = 0.20;             
             }
           }
          alarm[2] = 2;   // next hole
    }
}

[Breston]

Quando la pallina (il suo punto centrale) si trova entro una certa corona circolare centrata nella buca potresti applicare una forza praticamente costante in modulo ma direzionata sempre verso il centro della buca. Quando la pallina (il suo punto centrale) si trova dentro l'anello più piccolo della corona allora è buca. In questo modo, quando la pallina viene tirata verso il bordo della buca subisce l'influenza di una forza perpendicolare al suo moto che devia la sua direzione. Se la velocità è abbastanza bassa, la pallina rimarrà intrappolata dalla forza entrando in buca vorticosamente, altrimenti subirà una deviazione e procederà dritta..
non saprei con la fisica di GM, ma se vuoi fare i conti a mano puoi discretizzare la forza considerandola costante tra uno step e l'altro (approssimazione valida fintantoché la durata dello step è sufficientemente breve da produrre variazioni trascurabili).
Inizializzi il vettore di forza una sola volta all'inizio:

Codice: Seleziona tutto

f_x = 0;
f_y = 0;

e nello step calcoli il risultato:

Codice: Seleziona tutto

speed_x += f_x / m;
speed_y += f_y / m;
x += speed_x;
y += speed_y;

Nota la potenza della discretizzazione: qui stiamo facendo una doppia integrazione nel tempo, però vedi solo un +.
dopo di che aggiorni il vettore di forza:

Codice: Seleziona tutto

d = sqrt((x-hole_x)^2+(y-hole_y)^2); // distanza dalla buca
a = atan2(y-hole_y,x-hole_x); // direzione verso la buca
if(  r < d && d < R ) { f_x = c*cos(a); f_y = c*sin(a); } // c costante arbitraria per modulare la forza - trova quella che ti soddisfa. r ed R sono ovviamente i due raggi della corona
if(  d > r ) //buca

Per ottenere un effetto migliore potresti anche aggiungere una dipendenza del modulo della forza (c nel codice) da 1/d, simulando una pendenza sempre maggiore man mano che ci si avvicina alla buca.

[funkygallo]

grazie per il codice!

Al momento ho un problema "leggero" quando la pallina raggiunge la buca viene spazzata via in una direzione a caso.

Ho fatto queste modifiche (step event)

dove:
var dir = point_direction(x, y, mouse_x, mouse_y);

Codice: Seleziona tutto

//vettore forza risultato
phy_speed_x += f_x / 0.05;
phy_speed_y += f_y / 0.05;
x += phy_speed_x;
y += phy_speed_y;
r = 4;
R = 25;
c = 0.5;


d = distance_to_point(obj_hole.x,obj_hole.y);// sqrt(x*x-obj_hole.x*obj_hole.x+y*y-obj_hole.y*obj_hole.y); // distanza dalla buca
a = dir; //arctan2(y-obj_hole.y,x-obj_hole.x); // direzione verso la buca
if(  r < d && d < R ) 
 { 
  f_x = c*cos(a); 
  f_y = c*sin(a); 
 } // c costante arbitraria per modulare la forza - trova quella che ti soddisfa. r ed R sono ovviamente i due raggi della corona
 
if ( d < r ) //buca
 {show_debug_message("buca");}

show_debug_message("distanza" + string(d));

[Breston]

var dir = point_direction(x, y, mouse_x, mouse_y);
perché verso il cursore e non obj_hole?

[funkygallo]

Ops, hai ragione anche tu, ma ahimè non cambia molto. La pallina viene "sparata" lontano come prima

[Breston]

Se setti f_x e y solo quando ti trovi dentro la corona circolare e poi disgraziatamente ne esci, nulla le resetterà e la pallina verrà accelerata da una forza costante, ergo non c'è limite alla velocità che può raggiungere.
edit: sì, è un bug mio e ti sto dando la colpa
in verità il codice che ti ho proposto l'ho scritto di getto solo per darti uno spunto, confidando che avresti risolto eventuali problemi, ma a questo punto ho paura che i miei post siano presi troppo sul serio

[funkygallo]

Ok, a scanso di errori ho effettuato 2 prove.. ma se nella prima non vi è nessuna rotazione a spirale,
nella seconda la pallina viene lanciata come suddetto.




1) prima dichiarando quelsto sotto nell'evento CREATE della pallina (obj_ball)

Codice: Seleziona tutto

f_x = 0;
f_y = 0;
r = 4;
R = 25;
c = 0.005;

2) Nel secondo tentativo ho dichiarato i valori all'interno dello step sempre della pallina (obj_ball)

Codice: Seleziona tutto

var dir2 = point_direction(phy_position_x, phy_position_y, obj_hole.x, obj_hole.y);
 d = distance_to_point(obj_hole.x,obj_hole.y)
//if dir 2 < 25

if d <= 25
 {
//vettore forza pallina
f_x = 0;
f_y = 0;


r = 4;
R = 25;
c = 0.005;
 
    phy_speed_x += f_x / 0.05;
    phy_speed_y += f_y / 0.05;
    x += phy_speed_x;
    y += phy_speed_y; 
    
    
    d = distance_to_point(obj_hole.x,obj_hole.y);// sqrt(x*x-obj_hole.x*obj_hole.x+y*y-obj_hole.y*obj_hole.y); // distanza dalla buca
    a = dir2; //arctan2(y-obj_hole.y,x-obj_hole.x); // direzione verso la buca
    if(  r < d && d < R ) 
     { 
      f_x = c*cos(a); 
      f_y = c*sin(a); 
     } // c costante arbitraria per modulare la forza - trova quella che ti soddisfa. r ed R sono ovviamente i due raggi della corona
     
    if ( d < r ) //buca
     {show_debug_message("buca");}
    
    show_debug_message("distanza" + string(d));
 }   
 
show_debug_message(dir2); 

[civic71]

A parte il bel codice di Breston , mi è venuto in mente adesso che si potrebbe ovviare a ciò, utilizzando un semplice sprite animato che rappresenti appunto la pallina che cade al centro con moto spiraliforme e rimpicciolendosi , al quale modificheresti solo la sua rotazione ( con image_angle ) per farla combaciare il punto esatto di collisione.

[Breston]

aggiungere quell'if non risolve il problema in questione e anzi, dato che con quel codice resetti sempre e comunque la forza subito prima di applicarla alla posizione della pallina stai bypassando tutto e la presenza della buca diventa ininfluente.. cioè tu la calcoli ma poi comuqnue la forza effettiva è sempre nulla..
Tornando sul mio primo post:

Codice: Seleziona tutto

// Aggiorna velocità e posizione
vel_x += f_x/m;
vel_y += f_y/m;
x += vel_x;
y += vel_y;

// Aggiorna la forza
d = point_distance(x,y,hole_x,hole_y);
a = point_direction(x,y,hole_x,hole_y);
// Niente forza risultante
f_x = 0; f_y = 0;
// A meno che non mi trovi dentro la corona
if(  r < d && d < R )
{
   f_x = c*cos(a);
   f_y = c*sin(a);
} 
if(  d < r ) //buca

@civic si può (e anzi sarebbe doveroso) aggiungere la tua soluzione alla mia per abbellire la caduta della pallina nella buca una volta che questo evento sia accertato, ma parliamo di una rifiniutura estetica. La soluzione che ho proposto è una simulazione fisica molto semplificata e permette di tenere in conto anche il caso in cui un colpo leggermente storto subisca una deviazione anche importante a causa della buca, un fenomeno caratteristico e decisamente frustrante che tutti i minigolfisti conoscono.

[funkygallo]

Vedo che un buco appassiona sempre
Scherzi a parte, buona l'idea di civic71, e la tengo sicuramente buona se non ne vengo a capo.

Invece Breston, con il tuo codice che mi hai ripostato succede quello nel video (dura 20 secondi)
Come potrai vedere ha un comportamento anomalo nel caso il tiro sia troppo veloce, ma anche se è lento

https://www.youtube.com/watch?v=fqnQRGA49yk

[Breston]

Pare che la tua forza abbia verso opposto, il che spiegherebbe il comportamento repulsivo invece di attrattivo del buco
Prova a invertire l'angolo, per esempio così:
f_x = c*cos(a+pi);
f_y = c*sin(a+pi);

[Breston]

Dato che ero curioso di vedere se è veramente difficile ho provato a scaricare lateralgm e a farlo.. mi funziona abbastanza bene..
Due oggetti.
obj_ball create:

Codice: Seleziona tutto

v_x = 7.45; // con 7.45 vedi un bel mulinello, prova 8 per vederla deviare parecchio, 9 per una deviazione più leggera
v_y = 0;
f_x = 0;
f_y = 0;

mass = 1;
friction_coeff = 0.025;

shooting = false;
shooting_force = 0;
shooting_t = 0;

obj_ball step:

Codice: Seleziona tutto

// Applica la forza alla pallina
v_x += f_x / mass;
v_y += f_y / mass;
x += v_x;
y += v_y;

// Calcola attrito
fa_x = -v_x * friction_coeff;
fa_y = -v_y * friction_coeff;

// Calcola la forza della buca
dist = point_distance(x,y,obj_hole.x,obj_hole.y);
angle = arctan2(obj_hole.y-y,obj_hole.x-x);
fh_x = 0; fh_y = 0;
if( obj_hole.r < dist && dist < obj_hole.R )
{
	fh_x = 5/dist*cos(angle);
	fh_y = 5/dist*sin(angle);
}
if( obj_hole.r > dist )
{
	// Buca: metto la pallina in buca e la arresto
	x = obj_hole.x;
	y = obj_hole.y;
	v_x = 0; v_y = 0;
}

// Forza complessiva
f_x = fa_x + fh_x;
f_y = fa_y + fh_y;

// Controlli
if( mouse_check_button_pressed(mb_left) )
{
	shooting = true;
	shooting_t = 0;
}
if( mouse_check_button_released(mb_left) )
{
	shooting = false;
	angle = arctan2(mouse_y-y,mouse_x-x);
	v_x = shooting_force*cos(angle);
	v_y = shooting_force*sin(angle);	
}
if( shooting )
{
	shooting_t += 0.02;
	shooting_force_max = 30;
	shooting_force = shooting_force_max*(1+sin(shooting_t))/2;
}

obj_ball draw:

Codice: Seleziona tutto

draw_set_color(c_ltgray);
draw_circle(x,y,13,false);

// Gestione del colpo
if( shooting )
{
	draw_set_color(c_white);
	draw_rectangle(x,y+20,x+100,y+30,false);
	draw_set_color(c_green);
	draw_rectangle(x,y+20,x+100/shooting_force_max*shooting_force,y+30,false);
}

obj_hole create:

Codice: Seleziona tutto

r = 2;
R = 25;

x = obj_ball.x+200;
y = obj_ball.y-22;

obj_hole draw:

Codice: Seleziona tutto

draw_set_color(c_dkgray);
draw_circle(x,y,R,false);
draw_set_color(c_black);
draw_circle(x,y,r,false);

obj_ball deve avere depth inferiore a obj_hole, la room con sfondo verde scuro e velocità 60...
ci ho messo poco, ti perdi un po' in un bicchier d'acqua

[funkygallo]

Eccomi.

Allora ho provato aggiungendo come suggerito la costante pi, ma il risultato non cambia.

Ci sono 2 problemi.
1) se il tiro è veloce la buca viene saltata. Intendo non a velocità massima ma umana, ovvero sotto il 7 di potenza.
2) come puoi vedere dal video, la pallina "gira" solo a velocità bassissima e dopo un po' viene buttata fuori.
Ho provato ad aumentare il raggio di azione delal spirale, ma senza risultato


Ora non vorrei farti perdere troppo tempo...

https://www.youtube.com/watch?v=sQ5ZIU5NgCM

[Breston]

Ora non vorrei farti perdere troppo tempo...

Dato che ho provato il codice proposto e non ci sono stati grossi problemi eccetto aggiustamenti minimi, la questione sarebbe fare debug, che è un tuo sacrosanto e costruttivo dovere in qualità di programmatore dal quale non posso permettermi di esimerti. Posso solo consigliarti di provare in un nuovo progetto il codice (completo) che ho messo nel post precedente, che mostra esattamente come avevo in mente dovessero funzionare le cose.
Oltretutto penso impiegherei più tempo a debuggare il tuo gioco stiamo parlando di una decina di righe suvvia, olio di gomito.

[funkygallo]

Si si ho debuggato. A sto punto dipende da altri fattori.
Olio di gomito si.. di palma no

[civic71]

Ho provato il codice e mi funziona bene , seppur senza aver attivato la fisica.
Me lo salvo visto che in futuro potrebbe ritornarmi utile .
Bravo Breston

[Breston]

Non uso GM da molto tempo, non so esattamente cosa sia la fisica integrata, ma se è un engine completo allora usarla è bruteforce inutile, come adoperare un bazooka per uccidere un ragno, questo ne è un esempio lampante.
Grazie comunque

[funkygallo]

A dir la verità la prima versione non godeva della fisica, ma poi ho modificato il tutto per gestire i sali e scendi, o dossi in modo da rallentare o velocizzare il moto della pallina in base all'altezza.

A sto punto devo trovare una via di mezzo

[Breston]

In realtà la mia soluzione può essere estesa facilmente per comprendere qualunque tipo di deformazione geometrica.. la buca è modellata appunto come una "discesa" radiale verso il centro. Come vedi nel codice ho calcolato la forza netta finale come somma della forza di attrito con la forza esercitata dalla buca, ma puoi aggiungere altre componenti dovute a salite e discese altrettanto facilmente. Rendendo l'intensità della forza proporzionale alla derivata spaziale del profilo del terreno (anche detta "pendenza" ) puoi simulare qualunque forma. Una rampa (salita o discesa in linea retta) ha pendenza costante e sarebbe modellata con una forza costante, per esempio. Non solo: aggiungendo una variabile (z) puoi trattare anche i salti della pallina duvuti a terreni discontinui, aggiungendo una forza costante lungo l'asse z (gravità).

[funkygallo]

Ho provato il codice eliminado tutta la fisica e dire che non fa una piega, anzi gira a spirale
Vedrò di seguire i suggerimenti anche per le salite e discese.

Ora bello che ora i "muri" non fanno rimbalzare la pallina ne settati come solide ne no. Mi sa che oggi non è serata.
Chiudo tutto e mi guardo Star Trek

Grazie per l'aiuto!