Vielen Dank für euere Hilfe im Vorraus. ich hoff dass der Code, vllt. doch ein wenig überischtlich ist.

#include <cmath>
#include <iostream>
#include <stdlib.h>
#include <GL/glut.h>

#include "Zielscheibe.h"
#include "Scheibe.h"
#include "Pfeil.h"
#include "Bogen.h"
//#include "ZylinderBogen.h"
#include "Kegel.h"
#include "Rechteck.h"
#include "Textausgabe.h"
#include "BodenUndHimmel.h"

//GLfloat winkel =3;

GLfloat drehwinkel = 0.0f; // fürs Umfallen

// Zielscheibe 1 mit Stock
GLfloat abstandZ1 =-1; // wichtig immer negativ!!!! // Dicke der Zielscheibe
GLfloat radiusZ1 = 3; // Radius der Zielscheibe
Zielscheibe z1(abstandZ1, radiusZ1);

// Zielscheibe 2 mit Stock
GLfloat abstandZ2 =-1; // wichtig immer negativ!!!!
GLfloat radiusZ2 = 3;
Zielscheibe z2(abstandZ2, radiusZ2);

// Zielscheibe 3 mit Stock
GLfloat abstandZ3 =-1; // wichtig immer negativ!!!!
GLfloat radiusZ3 = 3;
Zielscheibe z3(abstandZ3, radiusZ3);

Pfeil pfeilAktuell;
const int anzahlPfeile = 6;
Pfeil pfeile[anzahlPfeile];

GLfloat anlegenX = 0;
GLfloat anlegenY = 5;
GLfloat anlegenZ= -10;

GLboolean showPfeil = GL_FALSE;

//Bogendrehung
GLfloat hoch = 0;
GLfloat links = 0;
GLfloat delta = 5;
//Krafteinstellung
GLfloat strecke;
GLfloat delta_Anzeige = 0.075;
GLboolean istOben = GL_TRUE;
GLboolean weiter = GL_TRUE;

GLboolean imSpiel = GL_FALSE;
GLboolean istAngelegt = GL_FALSE;
GLboolean zumZielen = GL_FALSE;
GLboolean zumSchiessen = GL_FALSE;
GLboolean istUnterbrochen = GL_TRUE; // eigelt. auf true

//Bogen
Bogen b1;

//Prototypen
void bodenZeichnen (void);
void himmelZeichnen (void);
GLfloat abstandsBerechnung (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
GLint koordinatenAbfrageMitZielscheibeStock(Pfeil, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat , GLfloat, GLfloat);
void koordinatenAbfrage (Pfeil&);
void pfeilFliegt(Pfeil);
void zielscheibeUndPfeilZeichnen(Pfeil, Zielscheibe, GLfloat, GLfloat, GLfloat);
void umfallen(Pfeil, Zielscheibe, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
void drawScene(void);
void pfeilWaehlen(unsigned char, int, int);
void initLightning(void);
void keyboard(unsigned char, int, int);
//void drawBitmapString(void, char);
//void drawStrokeString(void, char);
void printHilfsanweisung();
void printSpielanleitung();

void drawAnzeigeBalken(void)
{
Rechteck r1,r2, r3, r4, r5, r6;

glDisable(GL_LIGHTING);

glPushMatrix();

r1.zeichneAnzeigeBalken(1.0f, 3.0f, 0.0f, 0.0f);
r2.zeichneRechteck(2.0, 0.5, 0.0, -1.75);
r3.zeichneRechteck(2.0, 0.5, 0.0, 1.75);
r4.zeichneRechteck(0.5, 3.0, 0.75, 0.0);
r5.zeichneRechteck(0.5, 3.0, -0.75, 0.0);

if(istOben){
if(strecke<=1.5)
strecke = strecke + delta_Anzeige;
else
istOben = false;
}
else{
if(strecke >= -1.5)
strecke = strecke - delta_Anzeige;
else
istOben = true;
}

glTranslatef(0.0, strecke, 0.0);
r6.zeichneDreieck();

glPopMatrix();

glEnable(GL_LIGHTING);

}

float getKraft() // wird bei der Schussstärke benötigt
{
GLfloat kraft = strecke + 2.5f;
return kraft *200;
}

Pfeil pfeilWaehlen(void){

for (int i = 0; i< anzahlPfeile; i++){
if(pfeile[i].isPfeilAktiv() == GL_FALSE){
// pfeile[i].setPfeilAktiv(GL_TRUE);
return pfeile[i];
}

// // es gibt keine Pfeile mehr ->Game over
}

}

void pfeilAnlegen(Pfeil& p)
{

glPushMatrix();
glTranslatef(0,anlegenY,anlegenZ);

glRotatef(links, 0, 1, 0);
glRotatef(hoch, 1, 0, 0);
b1.bogenMitSehne();
if(showPfeil){// !!!!!!!!!!!?????????????
glRotatef(90, 1, 0, 0);
glTranslatef(0.0f, p.getRadiusPfeil(), -b1.getRadiusAussenBogen()); //letzter Parameter bezieht sich auf Bogenbreite
p.zeichnePfeil();
}

glPopMatrix();

p.setStartYPos(anlegenY);
p.setStartZPos(anlegenZ -b1.getRadiusAussenBogen());
}

void zielen ()
{
glPushMatrix();
glTranslatef(anlegenX+8,anlegenY-4,anlegenZ);
drawAnzeigeBalken();
glPopMatrix();
}

// beim Abschießen : istAngelegt = false

void schiessen (Pfeil& p){

koordinatenAbfrage(p);

std::cout << "Pfeil im Flug?? " << (p.isPfeilImFlug() == GL_TRUE)<< "\n";

// p.fliegt(links, hoch, getKraft()); // 3.Variable ist Anfangsgeschwinidigkeit
p.fliegt(links, hoch, 50);

}

void keyboard ( unsigned char key, int x, int y)
{
if (istUnterbrochen == GL_TRUE){
if(key == 'w' || key == 'W') // Spielstart oder nach Hilfeanzeige Spielfortsetzung
istUnterbrochen = GL_FALSE;
}

else {

if(imSpiel == GL_FALSE){
if((key == 'p' || key == 'P') && zumZielen == GL_FALSE){ // Anlegen nur mgl, wenn zuvor Schiessen
istAngelegt = GL_TRUE;
imSpiel = GL_TRUE;
showPfeil = GL_TRUE;
pfeilAktuell = pfeilWaehlen();
// pfeilAktuell.setPfeilAktiv(GL_TRUE);
}
}
else{
if((key == 'z' || key == 'Z') && zumSchiessen == GL_FALSE){// Zielen nur mgl, wenn zuvor Anlegen
istAngelegt == GL_FALSE;
showPfeil = GL_FALSE;
zumZielen = GL_TRUE;
}
if((key == 's' || key =='S') ){// Schiessen nur mgl, wenn zuvor Zielen
zumZielen == GL_FALSE;
zumSchiessen = GL_TRUE;
}

// if((key == 's' || key =='S') && pfeilAnlegen == GL_FALSE){// Schiessen nur mgl, wenn zuvor Zielen
// zumZielen == GL_FALSE;
// zumSchiessen = GL_TRUE;
}
}

if(key == 'h' || key == 'H') // Hilfeanzeige
istUnterbrochen = GL_TRUE;

if(showPfeil == GL_FALSE)
zumZielen = GL_FALSE;

}

void special ( int key, int x, int y)
{
if (istAngelegt == GL_TRUE){

if(key == GLUT_KEY_LEFT && links <90 )
links = links + delta;
if(key == GLUT_KEY_RIGHT && links >-90)
links = links - delta;
if(key == GLUT_KEY_UP && hoch <90)
hoch = hoch + delta;
if(key == GLUT_KEY_DOWN && hoch >-90)
hoch = hoch - delta;
}

}

GLfloat abstandsBerechnung (GLfloat xZ, GLfloat yZ, GLfloat zZ, GLfloat xP, GLfloat yP, GLfloat zP)
{ //{x,y,z}Z = Koordinaten der Zielscheibe, {x,y,z}P = Koordinaten des Pfeiles
return sqrt( pow(xZ - xP, 2) + pow(yZ - yP, 2) + pow(zZ - zP, 2));
}

GLint koordinatenAbfrageMitZielscheibeStock( Pfeil& p){

GLfloat dS1 = abstandsBerechnung(z1.getXposStock(), 0.0f ,z1.getZposStock(), p.getXPos(), 0.0f, p.getZPos()); // Stock
GLfloat dZ1 = abstandsBerechnung(z1.getXposZielscheibe(), z1.getYposZielscheibe(), 0.0, p.getXPos(), p.getYPos(), 0.0); // Zielscheibe

GLfloat dS2 = abstandsBerechnung(z2.getXposStock(), 0.0f , z2.getZposStock(), p.getXPos(), 0.0f, p.getZPos()); // Stock
GLfloat dZ2 = abstandsBerechnung(z2.getXposZielscheibe(), z2.getYposZielscheibe(), 0.0, p.getXPos(), p.getYPos(), 0.0); // Zielscheibe

GLfloat dS3 = abstandsBerechnung(z3.getXposStock(), 0.0f , z3.getZposStock(), p.getXPos(), 0.0f, p.getZPos()); // Stock
GLfloat dZ3 = abstandsBerechnung(z3.getXposZielscheibe(), z3.getYposZielscheibe(), 0.0, p.getXPos(), p.getYPos(), 0.0); // Zielscheibe

// std::cout << z1.getXposStock()<< " " << z1.getZposStock()<<"\n";

// std::cout << dS1<< "\n";

if((dS1 <= z1.getRadiusStock()) && ((p.getYPos() <= z1.getYposZielscheibe()) && (p.getYPos() > 0))) // Pfeil hat Stock 1 getroffen
return -1;
else if (dZ1<= radiusZ1 && (p.getZPos() >= (z1.getZposZielscheibe() -1.0) && p.getZPos() <= z1.getZposZielscheibe() )) // Pfeil hat Zielscheibe 1 getroffen
return 1;
else if((dS2 <= z2.getRadiusStock()) && ((p.getYPos() <= z2.getYposZielscheibe()) && (p.getYPos() > 0))) // Pfeil hat Stock 2 getroffen
return -2;
else if (dZ2<= radiusZ2 && (p.getZPos() >= (z2.getZposZielscheibe() -1) && p.getZPos() <= z2.getZposZielscheibe())) // Pfeil hat Zielscheibe 2 getroffen
return 2;
else if((dS3 <= z3.getRadiusStock()) && ((p.getYPos() <= z3.getYposZielscheibe()) && (p.getYPos() > 0))) // Pfeil hat Stock 3 getroffen
return -3;
else if (dZ3<= radiusZ3 && (p.getZPos() >= (z3.getZposZielscheibe() -1) && p.getZPos() <= z3.getZposZielscheibe())) // Pfeil hat Zielscheibe 3 getroffen
return 3;
else
return 0;

}
void koordinatenAbfrage (Pfeil& p){

GLfloat ergebnisAbfrage = koordinatenAbfrageMitZielscheibeStock(p); // Abstandsvergleich zur Zielscheibe und Stock von Zielscheibe 1;

// std::cout << "Ergebnisabfrage " <<ergebnisAbfrage << "\n";

if(p.getYPos() < 0 || ergebnisAbfrage != 0){

// std:: cout << "Hallöle"<< "\n";

imSpiel = GL_FALSE;
zumSchiessen = GL_FALSE;

p.setPfeilImFlug(GL_FALSE); // Pfeil hat etwas getroffen

// // Nur für Methode Umfallen von Bedeutung!!!!!
// if(ergebnisAbfrage == 1) // dh. hat Zielscheibe und nicht Stock getroffen
// z1.setGetroffen(GL_TRUE);
// if(ergebnisAbfrage == 2) // dh. hat Zielscheibe und nicht Stock getroffen
// z2.setGetroffen(GL_TRUE);
// if(ergebnisAbfrage == 3) // dh. hat Zielscheibe und nicht Stock getroffen
// z3.setGetroffen(GL_TRUE);

}
}
//

void pfeilFliegt(Pfeil& p){
koordinatenAbfrage(p);

p.fliegt(links, hoch, getKraft()); // 3.Variable ist Anfangsgeschwinidigkeit

}

void zielscheibeUndPfeilZeichnen(Pfeil& p , Zielscheibe z, GLfloat xZ, GLfloat yZ, GLfloat zZ){

glPushMatrix(); // z1 Zielscheibe mit Stock zeichnen
glTranslatef(xZ,yZ, zZ);
z.stockZielscheibeZeichnen();
glPopMatrix();

glPushMatrix(); // Pfeil wird gezeichnet
glTranslatef(p.getXPos(), p.getYPos(),p.getZPos()); // damit sichtbar wird
p.zeichnePfeil();
glPopMatrix();

}

//void umfallen(Pfeil p, Zielscheibe z, GLfloat xZ, GLfloat yZ, GLfloat zZ, GLfloat abstand, GLfloat rS){
//
// glPushMatrix();
// glTranslatef(0.0f, 0.0f, (zZ + abstand -2rS));
// glRotatef(drehwinkel, 1.0f, 0.0f, 0.0f);
// glTranslatef(0.0f, z.getRadiusStock(), -zZ - abstand +2.0frS);
//
// zielscheibeUndPfeilZeichnen(p, z, xZ, yZ, zZ);
// glPopMatrix();
//
//
// if (drehwinkel>-90) {
// drehwinkel = drehwinkel - 3.0f;
// }
//
//
//}

void aktionMitAktuellemPfeil (void){

if(istAngelegt == GL_TRUE)
pfeilAnlegen(pfeilAktuell);

if(zumZielen == GL_TRUE){
istAngelegt = GL_FALSE;
zielen();
}

if (zumSchiessen == GL_TRUE)
schiessen(pfeilAktuell);

}

void zielscheibenZeichnen (void){

z1.setXposZielscheibe(0);
z1.setZposZielscheibe(-20);
glPushMatrix(); // z1 Zielscheibe mit Stock zeichnen
glTranslatef(z1.getXposZielscheibe(), z1.getYposZielscheibe(), z1.getZposZielscheibe());
z1.stockZielscheibeZeichnen();
glPopMatrix();

z2.setXposZielscheibe(8);
z2.setZposZielscheibe(-30);
glPushMatrix(); // z2 Zielscheibe mit Stock zeichnen
glTranslatef(z2.getXposZielscheibe(), z2.getYposZielscheibe(), z2.getZposZielscheibe());
z2.stockZielscheibeZeichnen();
glPopMatrix();

z3.setXposZielscheibe(-10);
z3.setZposZielscheibe(-20);
glPushMatrix(); // z2 Zielscheibe mit Stock zeichnen
glTranslatef(z3.getXposZielscheibe(), z3.getYposZielscheibe(), z3.getZposZielscheibe());
z3.stockZielscheibeZeichnen();
glPopMatrix();

}

void pfeileZeichnen(void){

// std::cout << "Hallo" << "\n";

//pfeile[0] = pfeilAktuell;

for(int i = 0; i < anzahlPfeile; i++){

std::cout << "Pfeil " << i <<" : " << "Aktiv?? "<< (pfeile[i].isPfeilAktiv() == GL_TRUE) << " Flug?? " << (pfeile[i].isPfeilImFlug() == GL_FALSE) <<"\n";

if(pfeile[i].isPfeilAktiv() == GL_TRUE && pfeile[i].isPfeilImFlug() == GL_FALSE){

std::cout << "Pfeil" << i <<": wird gezeichnet" << "\n";
pfeile[i].zeichnePfeilNachHatGetroffen();
}
}

}

void drawScene(void){

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

if (istUnterbrochen)
Textausgabe::printSpielanleitung();

else{

glLoadIdentity();
// gluLookAt(15, 5,zZ1, 0,5,zZ1, 0,1,0); // Kamerapositon verändern
// gluLookAt(0, 6,zZ1+6, 0,6,zZ1, 0,1,0); // Kamerapositon verändern
// gluLookAt(0, 10,0, 0,8, 0, 0,1,0); // Kamerapositon verändern
gluLookAt(10,5,0, 0,5, -20, 0,1,0); // Kamerapositon verändern

BodenUndHimmel::bodenUndHimmelZeichnen();
zielscheibenZeichnen();
pfeileZeichnen();

aktionMitAktuellemPfeil();

glutSwapBuffers();
glutPostRedisplay();

}

}

void initLightning(void)
{
GLfloat lmodel_ambient [] = {0.5f, 0.5f, 0.5f, 1.0f}; // Hintergrundlicht

GLfloat light0_positon [] = {5.0f, 2.0f, -3, 1.0f};
GLfloat light0_diffuse [] = {0.4f, 0.4f, 0.4f, 1.0f};
GLfloat light0_specular [] = {0.8f, 0.8f, 0.8f, 1.0f};
GLfloat light0_direction [] = {-1.0f, 0.0f, -0.75f};

GLfloat light1_positon [] = {0.0f, 3.0f, 0.0, 1.0f};
GLfloat light1_diffuse [] = {0.8f, 0.8f, 0.8f, 1.0f};
GLfloat light1_specular [] = {0.9f, 0.9f, 0.9f, 1.0f};
GLfloat light1_direction [] = {0.0f, 0.0f, -1.0f};

// Strahler:: definiert GL_Light0 (von der Seite)
glLightfv(GL_LIGHT0, GL_POSITION, light0_positon);
glLightfv(GL_LIGHT0, GL_DIFFUSE, light0_diffuse);
glLightfv(GL_LIGHT0, GL_SPECULAR, light0_specular);
glLightfv(GL_LIGHT0, GL_SPOT_DIRECTION, light0_direction);
glLightf(GL_LIGHT0, GL_SPOT_CUTOFF, 100.0f); // Öffnungswinkel des Strahlers
glLightf(GL_LIGHT0, GL_SPOT_EXPONENT, 30.0f);

// Strahler:: definiert GL_Light1
glLightfv(GL_LIGHT1, GL_POSITION, light1_positon);
glLightfv(GL_LIGHT1, GL_DIFFUSE, light1_diffuse);
glLightfv(GL_LIGHT1, GL_SPECULAR, light1_specular);
glLightfv(GL_LIGHT1, GL_SPOT_DIRECTION, light1_direction);
glLightf(GL_LIGHT1, GL_SPOT_CUTOFF, 5.0f); // Öffnungswinkel des Strahlers
glLightf(GL_LIGHT1, GL_SPOT_EXPONENT, 100.0f);

glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient); // Hintergrundlicht

glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glEnable(GL_LIGHT1);
}

void init(void)
{
glClearColor(0.0, 0.0, 0.0, 0.0);

glEnable(GL_DEPTH_TEST);

z1 = Zielscheibe(abstandZ1, radiusZ1);
z2 = Zielscheibe(abstandZ2, radiusZ2);
z3 = Zielscheibe(abstandZ3, radiusZ3);

pfeile[0]= Pfeil();
pfeile[1]= Pfeil();
pfeile[2]= Pfeil();
pfeile[3]= Pfeil();
pfeile[4]= Pfeil();
pfeile[5]= Pfeil();
b1 = Bogen();

glutKeyboardFunc(keyboard);
glutSpecialFunc(special);

initLightning();

}

void reshape(int w, int h)
{
glViewport( 0, 0, w, h );
glMatrixMode(GL_PROJECTION);
glLoadIdentity();

if(istUnterbrochen)
glOrtho(-10, 10, -10, 10, -10, 10);
else
gluPerspective(90, 1, 1, 500);

glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}

int main(int argc, char **argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE| GLUT_RGB | GLUT_DEPTH);
glutInitWindowSize(750, 750);
glutInitWindowPosition(100, 100);
glutCreateWindow("Bogenschießen");
init();
glutReshapeFunc(reshape);
glutDisplayFunc(drawScene);
glutMainLoop();
return(0);
}

2 wichtige sachen:

0.- code tags für quellcode !
1.- beschreib genauer was dein problem ist.
2.- poste nur den relevanten auf ein kompilierbares minimal beispiel reduzierten code !!!

das liest sich keiner durch

Pfeil pfeilAktuell;
const int anzahlPfeile = 6;
Pfeil pfeile[anzahlPfeile];

Pfeil pfeilWaehlen(void){
    for (int i = 0; i< anzahlPfeile; i++){
        if(pfeile[i].isPfeilAktiv() == GL_FALSE){
            // pfeile[i].setPfeilAktiv(GL_TRUE);
            return pfeile[i];
        }
        // // es gibt keine Pfeile mehr ->Game over
    }
}

void keyboard ( unsigned char key, int  x, int y)
{
  /* codecodecode */
  pfeilAktuell = pfeilWaehlen();
  /* codecodecode */
}

Und die Frage ist, warum pfeilAktuell und pfeile[i] nicht dasselbe Objekt sind. Und was man daran ändern kann.

Der Code ist leider komplett fubar...
Trotzdem:
Wie wäre es, wenn Du statt Pfeil pfeilAktuell einfach ein int pfeil_aktuell_index nimmst, der in Dein Array zeigt?
Das wäre eine pragmatische Lösung...