So jetzt zur Problembeschreibung. Wenn ihr die Datei heruntergeladen habt öffnet bitte die datei Mein Game.exe (wenn ihr denkt das es eine gefährliche datei ist dann könnt ihr ja auch die .dev Datei öffnen dies dann kompilieren dann könnt ihr euch sicher sein das es nur das Rundenkampf Game ist) und gebt zuerst einen Namen ein dann wählt eine Rasse und dann müsst ihr [2] 2 Waffen und 0 Schilde wählen und dann 2 mal die 16 (also den Stock). Jetzt müsst ihr entweder die 1(Drachenkrieger) oder die 3(Troll) wählen.
Dann geht der Kampf los. Nun müsst ihr eure Ap durch Angriffe (welche sind egal) auf 0 reduzieren.

Bis hierhin sollte eigentlich alles glatt laufen. Doch jetzt kommt der Fehler. Eigentlich müsste der Gegner jetzt mit beiden Waffen angreifen bis die Ap=0 sind. Doch genau dies tut er nicht. Er greift Lediglich 1 mal an und dann bleibt das Programm hängen doch ich weis nicht warum.
Wisst ihr vielleicht warum?

Ach ja falls der Code noch nicht so professionel bzw nicht ganz sauber geschrieben oder nicht so gut formatiert ist. Nicht wundern. Ich lerne seit gerade einmal 3 Tagen C++.

Verbesserungsvorschläge jeglicher Art egal wozu nehme ich natürlich gerne dankend an.

Ich hoffe ich konnte das Problem klar darstellen und jetzt hoffe ich auf ein wenig Hilfe von euch .

void Kampf(void)
{
     int BGSchadenWaffe1=GSchadenWaffe1-Verteidigung;
     int BGSchadenWaffe2=GSchadenWaffe2-Verteidigung;
     int BGSchadenGesamt=GSchadenGesamt-Verteidigung;
     int BSchadenWaffe1=SchadenWaffe1-GVerteidigung;
     int BSchadenWaffe2=SchadenWaffe2-GVerteidigung;
     int BSchadenGesamt=SchadenGesamt-GVerteidigung;
     for(;Lebt == 1 || GLeben == 1;)
     {
               Runde++;
               Runde2++;
               Verteidigung=VertGesamt;
               GVerteidigung=GVertGesamt;
               while(Ap != 0)
               {
                        cout << "\nWas moechten sie tun?\n";
                        if(Ap>=6)
                        {
                                 cout << "[1] Dem naechsten Angriff des Gegners ausweichen (6Ap)\n";
                                 Moeglichkeiten++;
                        }
                        cout << "[2] Mit Waffe 1 angreifen (1Ap)\n";
                        Moeglichkeiten++;
                        if(BWaffe2==1)
                        {
                                    cout << "[3] Mit Waffe 2 angreifen (1Ap)\n";
                                    Moeglichkeiten++;
                                    cout << "[4] Mit beiden Waffen angreifen (2Ap)\n";
                                    Moeglichkeiten++;
                        }
                        if(Runde >=3)
                        {
                                 cout << "[5] Heilen (6AP)\n";
                                 Moeglichkeiten++;
                        }
                        cin >> Auswahl;
                        switch(Auswahl)
                        {
                                       case 1 : if(Ap>=6)
                                                {
                                                    Ausweichen=1;
                                                    Ap=0;
                                                    cout << "Du wirst dem naechsten Angriff des Gegners ausweichen.\n";
                                                    Moeglichkeiten=0;
                                                }
                                                else
                                                {
                                                    cout << "Du hast zu wenig Ap um Auszuweichen. Deshalb wirst du mit Waffe 1 angreifen.\n";
                                                    GLeben=GLeben-BSchadenWaffe1;
                                                    Ap--;
                                                    cout << "Du hast dem Gegner " << BSchadenWaffe1 << " abgezogen.\n";
                                                    Moeglichkeiten=0;
                                                }
                                       break;
                                       case 2 : if(GAusweichen==0)
                                                {
                                                      GLeben=GLeben-BSchadenWaffe1;
                                                      Ap--;
                                                      cout << "Du hast dem Gegner " << BSchadenWaffe1 << " abgezogen.\n";
                                                      Moeglichkeiten=0;
                                                }
                                                else
                                                {
                                                    Ap--;
                                                    cout << "Der Gegner ist deinem Angriff ausgewichen.";
                                                    Moeglichkeiten=0;
                                                }
                                       break;
                                       case 3 : if(GAusweichen==0)
                                                {
                                                      GLeben=GLeben-BSchadenWaffe2;
                                                      Ap--;
                                                      cout << "Du hast dem Gegner " << SchadenWaffe2 << " abgezogen.\n";
                                                      Moeglichkeiten=0;
                                                }
                                                else 
                                                {
                                                     Ap--;
                                                     cout << "Der Gegner ist deinem Angriff ausgewichen.";
                                                     Moeglichkeiten=0;
                                                }
                                       break;
                                       case 4 : if(GAusweichen==0)
                                                {
                                                      GLeben=GLeben-BSchadenGesamt;
                                                      Ap=Ap-2;
                                                      cout << "Du hast dem Gegner " << BSchadenGesamt << " abgezogen.\n";
                                                      Moeglichkeiten=0;
                                                }
                                                else
                                                {
                                                    Ap=Ap-2;
                                                    cout << "Der Gegner ist deinem Angriff ausgewichen.";
                                                    Moeglichkeiten=0;
                                                }
                                       break;
                                       case 5 : if(Runde >=3)
                                                {
                                                      Leben=Leben+Heilen;
                                                      Ap=0;
                                                      cout << "Du haste " << Heilen << " deiner Lebenspunkte geheilt.\n";
                                                      Runde=0;
                                                      Moeglichkeiten=0;
                                                }
                                                else
                                                {
                                                      cout << "Du kannst dich momentan noch nicht (wieder) heilen.\n"
                                                           << "Weil du die falsche Zahl eingegeben hast wirst du jetzt\n"
                                                           << "mit Waffe 1 angreifen\n";
                                                      if(GAusweichen==0)
                                                      {
                                                               GLeben=GLeben-BSchadenWaffe1;
                                                               Ap--;
                                                               cout << "Du hast dem Gegner " << BSchadenWaffe1 << " abgezogen.\n";
                                                               Moeglichkeiten=0;
                                                      }
                                                      else
                                                      {
                                                               Ap--;
                                                               cout << "Der Gegner ist deinem Angriff ausgewichen.";
                                                               Moeglichkeiten=0;
                                                      }
                                                }
                                       break;
                                       default : cout << "Du hast eine falsche Zahl eingegeben. Es gibt nur " << Moeglichkeiten << '\n'  
                                                      << "Deshalb wirst du mit Waffe 1 angreifen.\n";
                                                 if(GAusweichen==0)
                                                 {
                                                 GLeben=GLeben-BSchadenWaffe1;
                                                 Ap--;
                                                 cout << "Du hast dem Gegner " << BSchadenWaffe1 << " abgezogen.\n";
                                                 Moeglichkeiten=0;
                                                 }
                                                 else
                                                 {
                                                     Ap--;
                                                     cout << "Der Gegner ist deinem Angriff ausgewichen.\n";
                                                     Moeglichkeiten=0;
                                                 }
                                       break;
                        }
               }
     GAusweichen=0;
     Ap=Apvoll;
     if(GLeben <=0)
     {
                cout << "___________________________________________________\n"
                     << "Der Sieg ist dein!!\n"
                     << "___________________________________________________\n";
                GLebt=0;
                break;
     }
     cout << "\nDer Gegner:\n";
     [b]while(GAp!=0)
     {
                 if(Runde2 >=3 && GLeben<=100)
                 {
                           GLeben=GLeben+GHeilen;
                           GAp=0;
                           cout << "Der Gegner hat " << GHeilen << " seiner Lebenspunkte geheilt.\n";
                 }
                 if(GWaffe2==1 && Ausweichen==0)
                 {
                               Leben=Leben-BGSchadenGesamt;
                               GAp=GAp-2;
                               cout << "Der Gegner greift mit beiden Waffen an und zieht dir " << BGSchadenGesamt << " ab.\n";
                 }
                 if(GWaffe2==1 && Ausweichen==1)
                 {
                     GAp=GAp-2;
                     cout << "Du bist dem Angriff des Gegners ausgewichen.\n";
                 }
                 if(GSchild==1 && Ausweichen==0)
                 {
                               Leben=Leben-BGSchadenWaffe1;
                               GAp--;
                               cout << "Der Gegner greift mit Waffe 1 an und zieht dir " << BGSchadenWaffe1 << " ab.\n";
                 }
                 if(GWaffe2=0 && Ausweichen==1)
                 {
                     GAp--;
                     cout << "Du bist dem Angriff des Gegners ausgewichen.\n";
                 }
     }[/b]
     cout << "\nSie haben noch " << Leben << " Lebenspunkte.\n"
          << "Ihr Gegner hat noch " << GLeben << " Lebenspunkte.\n";
     GAp=Apvoll;
     Ausweichen=0;
     if(Leben <=0)
     {
                cout << "___________________________________________________\n"
                     << "Der Gegner hat dich bezwungen. Schande ueber dich!!\n"
                     << "___________________________________________________\n";
                Lebt=0;
                break;
     }                           
     }                                            
}

Danke schon mal im vorraus für eure Hilfe.

for(;Lebt == 1 || GLeben == 1

das kann nicht gehen...

Das das geht wusste ich nicht wie gesagt hat er beim kopieren irgendwie nicht übernommen ^^ warum auch immer.

a) Das void in den Klammern ist unter C++ unnötig ("void Kampf(void)" => "void Kampf()")
b) Die Variablen sind teilweise [ironie]gut verständlich[/ironie] gewählt.
c) Schleifeneinrückungen sollten sinnvoll gewählt sein, teilweise fehlt bei dir die Einrückung.
d) Lieber einzelne Bereiche als eigene Funktion auslagern, anstatt Funktionen zu riesig werden zu lassen.
e) Ich hoffe du hast deinen Code nicht innerhalb des Kopfes einer for-Schleife geschrieben? "for(;Lebt == 1 || GLeben == 1" ist unvollständig...

Um es kurz zu machen: Dein Programm ist nicht sinnvoll zu lesen. Daher werde ich auch garnicht erst versuchen den Fehler zu suchen (Der Aufwand wäre zu groß).

cu André

Ich denke mal, der Fehler liegt hier:

while(GAp!=0)
{
//bla...
}

GAp wurde nirgends initialisiert, soweit ich das überblicke.
Und wenn, dann bleibt er spätestens hängen, sobald er in die Schleife geht und eine Deiner if-Bedingungen erfüllt wird. Dann ist GAp immer 0-Wert und somit immer != 0.

@Tachyon GAp hab ich als Globale Variable schon vor der Main funktion deklariert. Und in der 2 Funktion wird GAp=6

Und in der 2 Funktion wird GAp=6

Jo, dann ist GAp != 0. Dann gehts in die while-Schleife rein. Jetzt kann es sein, dass keine Deiner if-Bedingungen true wird. Dann wird GAp immer 6 bleiben, Du siehst keine Ausgaben, und die Schleife rennt -> Das Programm hängt.

while(GAp != 0)
{
    cout << "Die Schleife brummt...\n";
    if(...
}

Wenn der Text dann ständig ausgegeben wird, solltest Du mal über die Erzeugung Deiner Abbruchbedingung nachdenken.

Danke Tachyon und natürlich auch den anderen.

1. Globale Variablen solltest du immer vermeiden wenn es möglich ist. Funktionen besitzen nicht ohne Grund eine Parameterliste, über die man die "Eingangsgrößen" übergeben kann.

2. Beim zweiten kurzen drüberschauen: ich nehme mal an das der Realschaden mindestens 0 sein sollte, oder?

int BGSchadenWaffe1=GSchadenWaffe1-Verteidigung;

// Ich schätze mal das folgendes besser ist (auch andere Benennung gewählt):
int realSchadenWaffe1 = gesamtschadenWaffe1 - verteidigung;
if(realSchadenWaffe1<0)
  realSchadenWaffe1 = 0;
// oder:
int realSchadenWaffe1 = (gesamtschadenWaffe1 < verteidigung) ?
  0 : (gesamtschadenWaffe1 - verteidigung);

Wenn ich mit meinen Superduper-Zweihändigen-Zahnstocher-Mit-Parierstange einen Panzer angreife, werde ich ihn wohl dennoch nicht heilen

3. Ich würde dir raten, das du dir gleich einen einheitlichen Schreibstil zum Unterscheiden von Variablen oder Funktionen/Methoden angewöhnst. Benennungen sollten zumindest so ausführlich sein, das sie bereits etwas über die Verwendung aussagen ("GAp" sagt nichts aus).

Eine mögliche Variante (es gibt viele, finde deinen Stil):
a) Variablennamen klein beginnen (isNew, roundNumber, count...)
b) Methoden/Klassen/Stukturen groß beginnen (DeleteAddress, Address, Appointment...)
c) Makros komplett groß (ONE_INCLUDEGUARD...)

Eine Möglichkeit Funktionen/Methoden in dieser Variante von Klassen/Strukturen zu unterscheiden ist es, Klassen/Strukturen mit Nomen zu benennen ("Address"), Funktionen/Methoden aber zusätzlich immer um Verben zu ergänzen (bzw. wenn es reicht nur das Verb zu benutzen; Beispiel "DeleteAddress" als Funktionsname oder "Address::Delete" als Bennennung einer Methode...).

4. Über die Qualität von Tutorials lasse ich mich hier lieber nicht aus, achte aber dabei das dein Tutorial zumindest etwas aktuell ist (z.B. "#include <iostream>" statt "#include <iostream.h>", Verwendung von std::string statt char[]/char*...).

cu André

Stimmt das soweit?

Dann bedanke ich mich jetzt noch ein mal recht herzlich bei dir André. Ich werde mir diese Dinge zu Herzen nehmen. Und so wie es aussieht werde ich demnächst wohl auch nicht mehr ganz so viel schreiben müssen. Bin nämlich grad bei den Arrays ^^

Ah da fällt mir noch ein. Die Sache mit den Funktionen von einem Zeiger habe ich jetzt zwar verstanden aber ich verstehe nich ganz warum man das mit den Zeigern macht. Wenn mir das noch einer erklären könnte wäre ich sehr froh.

Oh man der Text wird wieder lang ^^ Naja ich wollte auch noch schnell loswerden das ich dieses Forum einfach nur Klasse finde. Mir wurde inerhalb weniger Minuten geholfen was in einem anderem Forum keiner geschafft hat. Dort wurde nur meine schlechte arbeit bemängelt meine eigentliche Frage aber nicht beantwortet. Natürlich nehme ich Kritik dankend an, dann sollte aber auch dabei geschrieben werden was schlecht ist oder was ich besser machen kann und der Ton sollte natürlich auch angemessen sein.

Also für das Forum und alle die hier Neulingen und auch Erfahrenen Programmierern helfen.

Ah da fällt mir noch ein. Die Sache mit den Funktionen von einem Zeiger habe ich jetzt zwar verstanden aber ich verstehe nich ganz warum man das mit den Zeigern macht. Wenn mir das noch einer erklären könnte wäre ich sehr froh.

Ich bin mir zwar nicht ganz sicher, was du meinst, aber ich vermute, die allgemeine Übergabe von Variabeln an Funktionen per Zeiger.

Die Übergabe als Zeiger oder Referenz hat den Vorteil, dass eine Variable von der Funktion verändert werden kann, was mit einer Wertübergabe nicht möglich ist. Das kann oft praktisch sein, wie z.B. in folgendem Beispiel (Zeiger haben jedoch noch einige weitere Anwendungsbereiche):

// Funktion mit Wertübergabe; verändert Parameter nicht, gibt neuen Wert zurück
int NaechsteZahl(int a) 
{
   return a + 1;
}

// Funktion mit Übergabe als Referenz, erhöht a um 1
void ErhoeheZahl(int &a)
{
   a = a + 1;   // oder a++;
}

// Funktion mit Übergabe als Zeiger, erhöht a um 1
void ErhoeheZahl2(int *a)
{
   *a = *a + 1;   // oder (*a)++;
}

// In main() würde es etwa folgendermassen aussehen:
int main()
{
   int x = 4;
   int y = NaechsteZahl(x); // y ist 5, x aber immer noch 4
   ErhoeheZahl(x); // x wird erhöht, ist nun auch 5
   ErhoeheZahl2(&y); // y wird erhöht, ist nun 6
}

Bei Zeigern übergibst du normalerweise die Adresse der Variable an die Funktion (wird durch das & bei ErhoeheZahl2(&y); . Die Funktion selber dereferenziert den Zeiger dann mit * ( *a = *a + 1 ), das heisst, es wird auf den Wert der übergebenen Speicheradresse zugegriffen. Referenzen sind dadurch etwas einfacher, und besonders am Anfang eher zu empfehlen. Du musst lediglich ein & vor den Parameter schreiben, damit er als Referenz übergeben wird - doch Vorsicht: hier bedeutet & nicht Adressübergabe, sondern Übergabe als Referenz.

Bongi schrieb:

-Einheitlichen Schreibstil angewöhnen aus der man sofort Erkennen kann ob es eine Variable usw. ist. Dazu habe ich aber noch eine Frage. Sollte man dann am Anfang des Codes einen Kommentar erstellen damit sofort ersichtlich wird welche Schreibweise für Variablen usw. sind?

Das ist eigentlich dir überlassen. Wenn du immer weisst, was gemeint ist, kannst du es auch lassen, aber eine oder zwei Zeilen Kommentar am Anfang können eigentlich nicht schaden

Bongi schrieb:

-Darauf achten das das Tutorial das benutzt wird nicht zu alt ist. Hierzu habe ich auch noch eine Frage. Wie alt dürfe so ein Tutorial den sein damit es noch aktuell ist? Die Sache mit #include <iostream> ist in meinem Tutorial schon und das mit den String weis ich noch nicht. So weit bin ich noch nicht. Das Tutorial ist von Ende 2003 ist das zu alt oder geht das noch?

Grundsätzlich sollte das Tutorial nicht veraltet sein. Bei Tutorials ist es jedoch oft so, dass C mit C++ vermischt wird und mit unsauberem oder falschem Code (z.B. void main() ) gearbeitet wird. Im Internet findet man sehr viel Schrott, eventuell solltest du dir auch ein Buch überlegen.

Ich hoffe, ich konnte einigermassen helfen, ansonsten fragst du einfach

...Und so wie es aussieht werde ich demnächst wohl auch nicht mehr ganz so viel schreiben müssen. Bin nämlich grad bei den Arrays ^^

Ah da fällt mir noch ein. Die Sache mit den Funktionen von einem Zeiger habe ich jetzt zwar verstanden aber ich verstehe nich ganz warum man das mit den Zeigern macht. Wenn mir das noch einer erklären könnte wäre ich sehr froh.

Das Deutet eher auf ein C den ein C++ Tutorial hin. Arrays kann man zwar durchnehmen, ich würde aber erst std::vector ansprechen - Dies ist aber Geschmackssache. Zeiger wiederum haben meines Erachtens zwar in ein C++ Tutorial zu tun, Bei Funktionsübergaben sollten aber Referenzen zuerst angesprochen werden! Zudem würde ich grundsätzlich versuchen Zeiger nicht zu früh zu erklären...

cu André

...void Kampf...

Hmmmm das kommt mir doch bekannt vor ....
"Die Schildkröte liegt auf dem Rücken, Leon, doch sie helfen nicht ! Warum helfen sie nicht ??"
...
"Meine Mutter ? Ich erzähl Ihnen mal was von meiner Mutter !" *BÄNG*

Gruß,

Simon2.

asc@ausgeloggt schrieb:

...void Kampf...

Hmmmm das kommt mir doch bekannt vor ....
"Die Schildkröte liegt auf dem Rücken, Leon, doch sie helfen nicht ! Warum helfen sie nicht ??"
...
"Meine Mutter ? Ich erzähl Ihnen mal was von meiner Mutter !" *BÄNG*

Gruß,

Simon2.

Pff, Banause. Das heisst Voigt Kampff...

Die Übergabe als Zeiger oder Referenz hat den Vorteil, dass eine Variable von der Funktion verändert werden kann, was mit einer Wertübergabe nicht möglich ist. Das kann oft praktisch sein, wie z.B. in folgendem Beispiel (Zeiger haben jedoch noch einige weitere Anwendungsbereiche):

Genau das wollte ich wissen ^^ Dankeschön

Das mit dem Buch werde ich mir noch mal überlegen aber will erst einmal das Tutorial durcharbeiten.

Aber noch einmal ein kräftiges Dankeschön an alle die mir meine Fragen beantwortet haben und sich ein bisschen um einen Neuling wie mich kümmern