[OPENGL] Gestire semplici collisioni

[pcg4m3s]

Salve a tutti,
sto creando un piccolo programmino in cui mi dovrei muovere all'interno di una stanza in cui ci sono muri e colonne.
per esempio per alzare i muri viene utilizzata una matrice nxn fatta di tutti 0, e poi ci sono gli 1 dove voglio alzare i muri o le colonne.
ho provato a gestire il tutto seguendo questa logica:
io giocatore prima di andare avanti (o indietro) verifico che la cella della matrice corrispondente alla nuova posizione che andrei a occupare è diversa da 1, altrimenti impedisco di andare in quella posizione perchè se no entrerei nel muro.
il problema è che così facendo, mi si ferma dopo essere già un po entrato nel muro.

[linoma]

A mio modo di vedere le cs se il tuo codice fosse corretto al max si dovrebbe fermare prima, notando dello spazio tra la colonna ed il player. Mi spiego se io sn nel punto A aggiungo 1, collido nn faccio muovere il player. Giusto?
C'e una giusta proporzione tra il valore che aggiungi alla posizione del player e la cella della matrice? A mio avviso il tuo valore dovrebbe essere piu piccolo della dimensione della cella dell matrice, in modo che al max ti muverai di una cella alla volta.

[pcg4m3s]

Originariamente inviato da linoma
A mio modo di vedere le cs se il tuo codice fosse corretto al max si dovrebbe fermare prima, notando dello spazio tra la colonna ed il player. Mi spiego se io sn nel punto A aggiungo 1, collido nn faccio muovere il player. Giusto?
C'e una giusta proporzione tra il valore che aggiungi alla posizione del player e la cella della matrice? A mio avviso il tuo valore dovrebbe essere piu piccolo della dimensione della cella dell matrice, in modo che al max ti muverai di una cella alla volta.

ti posto un po di codice di esempio, così mi spiego meglio.

struct Player{
	GLfloat position[3];
	GLfloat forward[3];
	GLfloat up[3];
} player;

int matrix[20][20];

void initMatrix()
{
	int i,j=0;
	for(i=0;i<20;i++)
		for(j=0;j<20;j++)
			matriceLabirinto[i][j]=0;
	matriceLabirinto[10][10]=1; 


}

[linoma]

Bhe avevo capito che era una sorta di scacchiera. E' una tecnica usata nello sviluppo di videogiochi. Se vai su gamedev di sicuro trovi anchi tutorials.

[pcg4m3s]

Originariamente inviato da linoma
A mio modo di vedere le cs se il tuo codice fosse corretto al max si dovrebbe fermare prima, notando dello spazio tra la colonna ed il player. Mi spiego se io sn nel punto A aggiungo 1, collido nn faccio muovere il player. Giusto?
C'e una giusta proporzione tra il valore che aggiungi alla posizione del player e la cella della matrice? A mio avviso il tuo valore dovrebbe essere piu piccolo della dimensione della cella dell matrice, in modo che al max ti muverai di una cella alla volta.

ti posto un po di codice di esempio, così mi spiego meglio.

#define X 0
#define Y 1
#define Z 2

struct Player{
	GLfloat position[3];
	GLfloat forward[3];
	GLfloat up[3];
} player;

int matrix[20][20];

void initMatrix()
{
	int i,j=0;
	for(i=0;i<20;i++)
		for(j=0;j<20;j++)
			matrix[i][j]=0;
	matrix[10][10]=1; //a titolo di esempio alzo una colonna solo nella posizione 10,10
}

void disegnaStanza()
{
	int x,y,z=0;
	for(x=0;x<20 x++)
		for(y=0;y<20; y++)
			if(matrix[x][y]==1)
				alzaMuro(x,y,5); //muro di altezza 5 nella posizione x,y
			else
				disegnaMattonella(x,y,z); //mattonella nella posizione x,y,z;
}

void posizioneInizialePlayer(){
	
	player.position[X] = 1.0;
	player.position[Y] = 1.0;
	player.position[Z] = 1.0;
	player.forward[X] = player.position[X] + 1.0;
	player.forward[Y] = 1.0;
	player.forward[Z] = 1.0;
	player.up[X] = 0.0;
	player.up[Y] = 0.0;
	player.up[Z] = 1.0;
}

void RenderScene(void)
{
	// Clear the window and the depth buffer
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	
	glPushMatrix();

	//guardo dal punto di vista del giocatore
	gluLookAt (player.position[X], player.position[Y], player.position[Z], 
			   player.forward[X],  player.forward[Y],  player.forward[Z],
			   player.up[X],       player.up[Y],       player.up[Z]        );
	
	disegnaStanza();

	glPopMatrix();
	
	// Buffer swap
	glutSwapBuffers();
}

void SpecialKeys(int key, int x, int y)
{
        GLfloat shift = 0.20;
	GLfloat tempX, tempY;

        //mi muovo verso avanti nella stanza      
        if(key == GLUT_KEY_UP)
	{
		tempX = player.position[X] + shift * cos(2.0 * GL_PI * alpha / 360.0);
		tempY = player.position[Y] + shift * sin(2.0 * GL_PI * alpha / 360.0);
		

		//per evitare che si entra nei muri
		if(matrix[(int)tempX][(int)tempY]!=1)
		{
			player.position[X] = tempX;
			player.position[Y] = tempY;
			player.forward[X]  = player.position[X] + shift * cos(2.0 * GL_PI * alpha / 360.0);
			player.forward[Y]  = player.position[Y]  + shift * sin(2.0 * GL_PI * alpha / 360.0);
		}
	}

        ...
   
}

int main(int argc, char *argv[])
{
     ...
}

[linoma]

Ti ho inviato un MP cn il link della tecnica che stai usando. Nn lo posto xche nn so se va contro il regolamento. Se hai problemi facilita la cosa muovendoti ad angoli di 90 gradi.
Di sicuro la matrice ti crea problmi muovendoti in diagonale, bhe basta che vedi l'indice delal casella rispetto a dove sei.
Immagina di aver davanti una scacchiera e di avere solo una torre, il tuo player, la torre si muove solo in verticale ed orrizontale. Limita il suo movimento ad una cella. Subito capisci come funziona il tutto ed i problemi che vi possono essere incrontando un'altra torre.

[pcg4m3s]

Originariamente inviato da linoma
Ti ho inviato un MP cn il link della tecnica che stai usando. Nn lo posto xche nn so se va contro il regolamento. Se hai problemi facilita la cosa muovendoti ad angoli di 90 gradi.
Di sicuro la matrice ti crea problmi muovendoti in diagonale, bhe basta che vedi l'indice delal casella rispetto a dove sei.
Immagina di aver davanti una scacchiera e di avere solo una torre, il tuo player, la torre si muove solo in verticale ed orrizontale. Limita il suo movimento ad una cella. Subito capisci come funziona il tutto ed i problemi che vi possono essere incrontando un'altra torre.

muovermi di 90 gradi non credo sia bello a livello di risultato.
comunque non mi è arrivato nessun messaggio privato

[linoma]

Ma non è neanche reale. Cmq togliendo gli angoli ti muovi a passi di 0.20 per 5 passi sarai nella stessa cella quindi dopo 100 passi se fuori la matrice.
Dove è posizionato il punto posizione nel player? Quanto è grosso il player? Hai considerato queste cose?

[pcg4m3s]

Originariamente inviato da linoma
Ma non è neanche reale. Cmq togliendo gli angoli ti muovi a passi di 0.20 per 5 passi sarai nella stessa cella quindi dopo 100 passi se fuori la matrice.
Dove è posizionato il punto posizione nel player? Quanto è grosso il player? Hai considerato queste cose?

no, nel mio caso il giocatore non si vede. in pratica il giocatore è la telecamera.

[linoma]

Ti scrivo la stessa cosa dei MPs non usare misure angolari ed usa step di una cella alla volta. xche non dovrebbero esserci problemi. Non ho letto tutto il codice, ma solo concettualmente