void CComputerBauer::HandleGolfer(const float elapsed)
{
	CChicken* c=(CChicken*)SearchNextChicken();
	if (c==NULL)return;

	// um 0.07 RAD weiter nach links drehen um noch richtig zu zielen
	float w=GetWinkel(ang.y,c->pos)-0.07f;
	float entf=Magnitude(pos-c->pos);

	if (abs(w)>0.025f)w=RotateTo(w,elapsed*((entf<13.0f)?2.25f:1.0f));

	if (entf>1.5f)speed.z=4.4f;
	else speed.z=0.0f;

	if ((w<0.1f)&&(entf<2.0f))
	{	// Zuschlagen
		ang.x=-0.2f;

		CGolfer* g=(CGolfer*)object;
		if (g->Schlag())
		{
			g->SendNotify(3);
		}
	}
}
void CComputerBauer::HandleGartenkralle(const float elapsed)
{
	CChicken* c=(CChicken*)SearchNextChicken();
	if (c==NULL)return;

	// um 0.07 RAD weiter nach links drehen um noch richtig zu zielen
	float w=GetWinkel(ang.y,c->pos)-0.07f;
	float entf=Magnitude(pos-c->pos);

	if (abs(w)>0.02f)w=RotateTo(w,elapsed*((entf<13.0f)?2.25f:1.0f));

	if (entf>1.3f)speed.z=4.0f;
	else speed.z=0.0f;

	if ((w<0.1f)&&(entf<1.8f))
	{	// Zustechen
		ang.x=-0.45f;

		CGartenkralle* g=(CGartenkralle*)object;
		if (g->Stoss())
		{
			g->SendNotify(2);
			g->EndStoss();
		}
	}
}
void CComputerBauer::HandleDrescher(const float elapsed)
{
	CChicken* c=SearchNextChicken();
	CDrescher* d=(CDrescher*)object;

	if (c==NULL)
	{	// Ist kein Huhn in der Nähe, einfach stumpfsinnig in einem kleinen Kreis weiterfahren
		d->rot=0.35f;	
		return;
	}

	d->acc.z=5.5f;

	float w=GetWinkel(d->ang.y,c->pos);
	if (abs(w)<0.1f)
	{	// Wenn Winkeldiffenenz zu klein, Kurs einfach beibehalten ohne zu lenken
		d->rot=0.0f;
		return;
	}
	// Drehen
	if ((abs(w)>g_PI/2.0f)&&(Magnitude(pos-c->pos)<12.0f)&&(world->GetDistanceFromWall(pos)>5.0f))
	{	// Wenn Ziel hinter Mähdrescher ist, weiterfahren bis es mit der Kurve erwischt werden kann
		d->rot=0.0f;
		return;
	}

	// Sonst Mähdrescher in Richtung des Huhns drehen
	if (w<0.0f)d->rot=-1.0f;
	else d->rot=+1.0f;
}
// Beginn IST-Abweichung von idealer Flugbahn berechnen (negative Abweichung ist links von der Geraden/Kurve)--------------
// und Einspeichern des Notfallarrays
int weg::Berechne_Abweichung()
{
    int abweichung;
    double alpha, beta, gamma, distance;

    switch (modus){
    case true:{
        alpha = GetWinkel(EP[0] - AP[0], EP[1] - AP[1]);

        //Notfallmodus optimieren
        //                distance = BetragVektor(AP[0],AP[1],EP[0],EP[1]);
        //                notfallziel[0]=(EP[0] - AP[0])/distance;
        //                notfallziel[1]=(EP[1] - AP[1])/distance;

        distance = BetragVektor(AP[0],AP[1],xList.at(0),yList.at(0));
        if (distance<10)
        {
            beta = alpha;
        }
        else
        {
            beta = GetWinkel(xList.at(0) - AP[0], yList.at(0) - AP[1]);
        }
        gamma = (DifferenzWinkel(alpha,beta)* PI)/180;
        abweichung = sin(gamma)*distance;

        //Notfallmodus
        //                notfallziel[0]=cos(gamma)*notfallziel[0]+AP[0];
        //                notfallziel[1]=cos(gamma)*notfallziel[1]+AP[1];
        //                GetWinkel(xList.at(0)-notfallziel[0],yList.at(0)-notfallziel[1]);
        break;
    }
    case false :
    {
        distance = BetragVektor(hin[hinnummer][0],hin[hinnummer][1],xList.at(0),yList.at(0)) - kreisradius[hinnummer];
        if (hin[hinnummer][2]==0)
        { distance = distance*(-1);}
        abweichung = Runden(distance);
        abweichung = 0; //muss gelöscht werden
        break;
    }
    }
    return abweichung;
}
void CComputerBauer::HandlePlasmaCannon(const float elapsed)
{
	CPlasmaCannon* p=(CPlasmaCannon*)object;
	if (p->munition<1.0f)
	{	// Weglegen, wenn keine Munni mehr
		p->Throw();
		p->SendNotify(2);
		object=NULL;

//		RotateTo(D3DVECTOR(0,0,0),elapsed);
		return;
	}

	CChicken* c=(CChicken*)SearchNextChicken();
	if (c==NULL)return;

	// um 0.07 RAD weiter nach links drehen um noch richtig zu zielen
	float w=GetWinkel(ang.y,c->pos)-0.07f;
	float entf=Magnitude(pos-c->pos);

	if (abs(w)>0.02f)w=RotateTo(w,elapsed*((entf<13.0f)?1.85f:0.9f));

	if (entf<2.5f)speed.z=-2.5f;
		else if (entf>5.0f)speed.z=3.3f;
		else speed.z=0.0f;

	if ((w<0.1f)&&(p->CanShoot())&&(entf<17.0f))
	{	// Schießen
		float sx=sqrtf(sqr(pos.x-c->pos.x)+sqr(pos.z-c->pos.z));
		// 0.65 weiter oben ansetzen, bei Plasmakanone
		float sy=pos.y+0.65f-c->pos.y;
		float alpha=0.0f;
		float bestdistance=4.0f;

		float aktalpha=-0.7f;
		do
		{
			float y=GetSchussY(sx,aktalpha);

			if (abs(y-sy)<bestdistance)
			{
				bestdistance=abs(y-sy);
				alpha=aktalpha;
			}

			aktalpha+=0.05f;
		}while (aktalpha<g_PI*0.5f);

		if (bestdistance<4.0f)
		{
			ang.x=-alpha;

			if (p->Shoot())p->SendNotify(1);
		}else ang.x=0.0f;
	}
}
void weg::notfallplan()
{
    notfallmodus=1;
    //Filtertimer->setInterval(400);   EVENTUELL BENÖTIGT
    if(BetragVektor(xList.at(0),yList.at(0),notfallziel[0],notfallziel[1])<notfalltol)
    {
        notfallplanende();
        //Filtertimer->setInterval(1000);
    }
    else
    {
        int winkelzumziel=0;
        winkelzumziel=GetWinkel(notfallziel[0]-xList.at(0), notfallziel[1]-yList.at(0)); //<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
        if(abs(winkelzumziel-Ausrichtung.at(0))<notfalltolwinkel)
        {
            geradeaus(BetragVektor(xList.at(0),yList.at(0),notfallziel[0],notfallziel[1]));
        }
        else
        {
            notfallplananfang(winkelzumziel-Ausrichtung.at(0));
        }
    }
}
//Beginn Tangentenpunktberechnung..................................................
void weg::Tangentenberechnung(double S_x, double S_y, double P_x, double P_y, double rad)
{
    double x1,y1; /*Schnittpunkt 1**/
    double x2,y2; /*Schnittpunkt 2**/
    double alpha,beta; /*Buffer**/

    /*Schnittpunktbestimmung**/
    BestimmeSchnittpunkte(S_x, S_y, hin[hinnummer][0], hin[hinnummer][1], rad, kreisradius[hinnummer],&x1,&y1,&x2,&y2); //Schnittpunkte der zwei Kreise berechnen

    /*Entscheidung, welcher Schnittpunkt der richtige Tangentenpunkt ist, abhängig davon,
     *ob der zeppelin rechts oder links herum fliegen soll und
     *ob es ein Austrittspunkt bzw ein Eintrittspunkt sein soll**/


    alpha = GetWinkel(hin[hinnummer][0] - P_x,hin[hinnummer][1] - P_y);
    beta = GetWinkel(x1-P_x,y1-P_y);

    qDebug()<<"Alpha"<<alpha;
    qDebug()<<"Beta"<<beta;
    qDebug()<<"Differenz"<<DifferenzWinkel(alpha,beta);
    if (modus == true) //Flug Geradeaus
    {
        if (hin[hinnummer][2]==1) //falls linksrum
        {
            if (DifferenzWinkel(alpha,beta)>0)
            {
                EP[0]=x1;
                EP[1]=y1;
            }
            else
            {
                EP[0]=x2;
                EP[1]=y2;
            }
        }
        else
        {
            if (DifferenzWinkel(alpha,beta)<0)
            {
                EP[0]=x1;
                EP[1]=y1;
            }
            else
            {
                EP[0]=x2;
                EP[1]=y2;
            }
        }
        ziel_x = EP[0]; /*Abspeichern der Zielkoordinaten**/
        ziel_y = EP[1];
    }

    else
    {
        if (hin[hinnummer][2]==1) //falls linksrum
        {
            if (DifferenzWinkel(alpha,beta)<0)
            {
                AP[0]=x1;
                AP[1]=y1;
            }
            else
            {
                AP[0]=x2;
                AP[1]=y2;
            }
        }
        else
        {
            if (DifferenzWinkel(alpha,beta)>=0)
            {
                AP[0]=x1;
                AP[1]=y1;
            }
            else
            {
                AP[0]=x2;
                AP[1]=y2;
            }
        }
        ziel_x = AP[0]; /*Abspeichern des Zwischenziels**/
        ziel_y = AP[1];
     }

    //Entscheidung Ende
    qDebug()<<"Punkt 1:"<<x1<<y1;
    qDebug()<<"Punkt 2:"<<x2<<y2;
    qDebug()<<"Zielpunkte Hindernis"<<ziel_x<<ziel_y;

}
//Start Aufruf und Abfragen--------------------------------------------------------------------------------------------
void weg::start()
{

    int Soll_Ausrichtung,Abweichung_Ausrichtung;
    qDebug()<<"Start und Modus:"<<modus;

    if (BetragVektor(xList.at(0),yList.at(0),abwurfkoordinate[0],abwurfkoordinate[1])<zieltol)
    {
        abwurfmodus = 1;
    }
    else
    {
        abwurfmodus = 0;
    }
    if (BetragVektor(xList.at(0),yList.at(0),zielkoordinaten[0],zielkoordinaten[1])<zieltol)
    {
        stop();
        ziel = true;
    }
    else
    { //Für den Notfallplan brauche ich das notfallziel array ausgefüllt, also die Daten wo das Zeppelin im Notfall hinsteuern soll (x und y) und den Ausrichtungswinkel, zum Schluss
        if(notfallmodus==1)
        {notfallplan();}
        else
        {
            qDebug()<<"Anzahl"<<anz_rueckschub;
            qDebug()<<"Reuckcountdown"<<rueck_countdown;
            if (rueck_countdown>0)
            {

                rueck_countdown-=1;
            }
            else
            {
                if ((modus == false)&&(BetragVektor(xList.at(0),yList.at(0),ziel_x,ziel_y)<zieltol))
                {
                    kurve(hin[hinnummer][2],kreisradius[hinnummer]);
                    modus = true;
                    hinnummer = hinnummer + 1;
                    berechneWeg();
                    schub[0]=-schub[0];
                    schub[1]=-schub[1];
                    rueck_countdown=anz_rueckschub-1;

                }
                else if((modus==true)&&(BetragVektor(xList.at(0),yList.at(0),ziel_x,ziel_y)<zieltol))
                {
                    modus = false;
                    berechneWeg();
                    rueck();
                    rueck_countdown=anz_rueckschub-1;
                }

                else
                {

                    if (modus)
                    {
                        Soll_Ausrichtung = Runden(GetWinkel(ziel_x-AP[0],ziel_y-AP[1]));
                        Abweichung_Ausrichtung=DifferenzWinkel(Soll_Ausrichtung,Ausrichtung.at(0));
                        notfallziel[2]=Soll_Ausrichtung;
                        qDebug()<<"Abweichung"<<Berechne_Abweichung();
                        qDebug()<<"IST_Ausrichtung"<<Ausrichtung.at(0);
                        qDebug()<<"SOll_Ausrichtung"<<Soll_Ausrichtung;
                        qDebug()<<"Abweichung_Ausrichtung"<<Abweichung_Ausrichtung;
                        if(abs(Berechne_Abweichung())<abweichungGUI[1])
                        {
                            qDebug()<<"Regelung Ausrichtung";
                            geradeaus(BetragVektor(xList.at(0),yList.at(0),ziel_x,ziel_y),Abweichung_Ausrichtung);
                        }
                        else
                        {
                            if ((Abweichung_Ausrichtung<20&&Berechne_Abweichung()<=-abweichungGUI[1])||(Abweichung_Ausrichtung>-20&&Berechne_Abweichung()>=abweichungGUI[1]))
                            {
                                qDebug()<<"Regelung Abweichung";
                                geradeaus(BetragVektor(xList.at(0),yList.at(0),ziel_x,ziel_y),Berechne_Abweichung());
                            }
                            else
                            {
                                geradeaus(BetragVektor(xList.at(0),yList.at(0),ziel_x,ziel_y));
                            }

                        }

                        //if(Berechne_Abweichung()>30)
                        //{
                        //    //Notfallmodus
                        // }
                        //else
                        //{

                        //}
                    }
                    else
                    {

                        qDebug()<<"Abweichung"<<Berechne_Abweichung();
                        if (hin[hinnummer][2]==0)
                        {
                            Soll_Ausrichtung = Runden(GetWinkel(xList.at(0)-hin[hinnummer][0],yList.at(0)-hin[hinnummer][1]))+90;
                            if (Soll_Ausrichtung>180){Soll_Ausrichtung = Soll_Ausrichtung-360;}
                        }
                        else
                        {
                            Soll_Ausrichtung = Runden(GetWinkel(xList.at(0)-hin[hinnummer][0],yList.at(0)-hin[hinnummer][1]))-90;
                            if (Soll_Ausrichtung<=-180){Soll_Ausrichtung = Soll_Ausrichtung+360;}
                        }
                        notfallziel[2]=Soll_Ausrichtung;
                        Abweichung_Ausrichtung=DifferenzWinkel(Soll_Ausrichtung,Ausrichtung.at(0));
                        qDebug()<<"IST_Ausrichtung"<<Ausrichtung.at(0);
                        qDebug()<<"SOll_Ausrichtung"<<Soll_Ausrichtung;
                        qDebug()<<"Abweichung_Ausrichtung"<<Abweichung_Ausrichtung;
                        if(abs(Berechne_Abweichung())<10)
                        {
                            kurve(hin[hinnummer][2],kreisradius[hinnummer]);
                        }
                        else
                        {
                            //if(Berechne_Abweichung()>30)
                            //{
                            //    //Notfallmodus
                            // }
                            //else
                            //{
                            //                    if ((Abweichung_Ausrichtung<20&&Berechne_Abweichung()<=-100)||(Abweichung_Ausrichtung>-20&&Berechne_Abweichung()>=100))
                            //                    {
                            //                        kurve(hin[hinnummer][2],kreisradius[hinnummer],Berechne_Abweichung());
                            //                    }
                            //                    else
                            //                    {
                            kurve(hin[hinnummer][2],kreisradius[hinnummer],Berechne_Abweichung());
                            //}
                            //}

                        }
                    }
                }
            }
        }
    }
}