C++/C Aufgabe "Katze vs Hund"



  • Hallo Leute,
    ich will eine "Simulation" machen, in der Hunde gegen Katzen kämpfen. Dazu hat jeder Hund und jede Katze eine zufällige Anzahl von Schadenspunkten und Lebenspunkten.
    Mein Problem ist jetzt: Ich möchte das Programm so lange laufen lassen, solange eine der beiden Seiten Tod ist, also wenn alle Hunde/Katzen 0 Lebenspunkte mehr haben.

    do {
    	for (int i = 0; i < HUNDE_ANZAHL; i++)
    			{
    				for (int j = 0; j < KATZEN_ANZAHL; j++)
    				{
    					if (Hundehorde[i] != NULL || Katzenhorde[j] != NULL)
    					{
    						//if !tod weiter machen
    						printf("Der %i. Hund greift die %i. Katze an!\nEr hat %i Schaden gemacht!\n", i + 1, j + 1, Hundehorde[i]->getKraftHunde());
    						Katzenhorde[j]->setLebenKatze(Katzenhorde[j]->getLebenKatze() - Hundehorde[i]->getKraftHunde());
    						printf("Die %i. Katze hat noch %i Leben!\n\n\n", j + 1, Katzenhorde[j]->getLebenKatze());
    
    						//Sleep(500);
    						printf("Die %i. Katze greift den %i. Hund an!\nSie hat %i Schaden gemacht!\n", j + 1, i + 1, Katzenhorde[i]->getKraftKatze());
    						Hundehorde[i]->setLebenHunde(Hundehorde[i]->getLebenHunde() - Katzenhorde[j]->getKraftKatze());
    						printf("Der %i. Hund hat noch %i Leben!\n\n\n", i + 1, Hundehorde[j]->getLebenHunde());
    	
    						if (Hundehorde[i]->getLebenHunde() < 0) {
    							printf("Der %ite Hund ist gestorben!\n", i + 1);
    							Hundehorde[i] = NULL;
    						}
    						if (Katzenhorde[j]->getLebenKatze() < 0) {
    							printf("Die %ite Katze ist gestorben!\n", j + 1);
    							Katzenhorde[j] = NULL;
    						}
    					}
    					
    					
    				}
    				//Sleep(1000);
    			}
    	} while (for (int i = 0; i < KATZEN_ANZAHL; i++)
    	{
    		Katzenhorde[i] > 0;
    	} || for (int j = 0; i < HUNDE_ANZAHL; i++) {
    		Hundehorde[j] > 0;
    	});
    

    Das ist bisher mein Stand. Am while bei der do{}while() Schleife bekomme ich einen Fehler wenn ich das so wie in Zeilen 32 bis 37 machen will.
    Auch will ich dass die Hunde bzw. Katzen die weniger als 0 Lebenspunkte haben "Sterben" und nicht mehr angegriffen werden können.

    Mein ganzer Code:

    //Hunde vs Katzen von Razavanni
    #include <stdlib.h>
    #include <stdio.h>
    #include <time.h>
    #include <windows.h>
    #include <iostream>
    using namespace std;
    
    #define KATZEN_ANZAHL 5
    #define HUNDE_ANZAHL 5
    #define LEBEN_KATZEN 100
    #define LEBEN_HUNDE 150
    #define KRAFT_KATZEN 25
    #define KRAFT_HUNDE 15
    
    
    
    class Hund {
    private:
    	int kraft_von_hunde;
    	int leben_von_hunde;
    
    public:
    	void setKraftHunde(int kraftHund){
    		kraft_von_hunde = kraftHund;
    	}
    	int getKraftHunde() {
    		return kraft_von_hunde;
    	}
    	void setLebenHunde(int lebenHund) {
    		leben_von_hunde = lebenHund;
    	}
    	int getLebenHunde() {
    		return leben_von_hunde;
    	}
    };
    
    class Katze {
    private:
    	int kraft_von_katze;
    	int leben_von_katze;
    
    public:
    	void setKraftKatze(int kraftKatze) {
    		kraft_von_katze = kraftKatze;
    	}
    	int getKraftKatze() {
    		return kraft_von_katze;
    	}
    	void setLebenKatze(int lebenKatze) {
    		leben_von_katze = lebenKatze;
    	}
    	int getLebenKatze() {
    		return leben_von_katze;
    	}
    
    };
    
    int main() {
    	srand(time(NULL));
    
    	Hund* Hundehorde[HUNDE_ANZAHL];
    	Katze* Katzenhorde[KATZEN_ANZAHL];
    
    
    
    
    	for (int i = 0; i < HUNDE_ANZAHL; i++)			
    	{
    		Hundehorde[i] = new Hund();
    		Hundehorde[i]->setKraftHunde(rand() % KRAFT_HUNDE + 1);		//max. 30
    		Hundehorde[i]->setLebenHunde(rand() % LEBEN_HUNDE + 1);	        //max. 300
    	}	   
    	//Hunde erzeugen
    
    	for (int i = 0; i < KATZEN_ANZAHL; i++)
    	{
    		Katzenhorde[i] = new Katze();
    		Katzenhorde[i]->setKraftKatze(rand() % KRAFT_KATZEN + 1);	//max. 40
    		Katzenhorde[i]->setLebenKatze(rand() % LEBEN_KATZEN + 1);	//max. 250
    	}		
    	//Katzen erzeugen
    
    
    	
    	for (int i = 0; i < HUNDE_ANZAHL; i++)		//Hunde HP ausgeben
    	{
    		printf("vorher Leben Hund %i: %i\n ", i+1, Hundehorde[i]->getLebenHunde());
    	}
    	
    	printf("\n\n");
    
    	for (int i = 0; i < KATZEN_ANZAHL; i++)		//Katzen HP ausgeben
    	{
    		printf("vorher Leben Katze %i : %i\n ", i+1, Katzenhorde[i]->getLebenKatze());
    	}
    
    	printf("\n\n");
    
    	for (int i = 0; i < HUNDE_ANZAHL; i++)		//Hunde DMG ausgeben
    	{
    		printf("Damage Hund %i: %i\n ", i+1, Hundehorde[i]->getKraftHunde());
    	}
    
    	printf("\n\n");
    
    	for (int i = 0; i < KATZEN_ANZAHL; i++)		//Katzen DMG ausgeben
    	{
    		printf("Damage Katze %i : %i\n ", i+1, Katzenhorde[i]->getKraftKatze());
    	}
    
    	printf("\n\n");
    	
    	
    	
    	do {
    			for (int i = 0; i < HUNDE_ANZAHL; i++)
    			{
    				for (int j = 0; j < KATZEN_ANZAHL; j++)
    				{
    					if (Hundehorde[i] != NULL || Katzenhorde[j] != NULL)
    					{
    						//if !tod weiter machen
    						printf("Der %i. Hund greift die %i. Katze an!\nEr hat %i Schaden gemacht!\n", i + 1, j + 1, Hundehorde[i]->getKraftHunde());
    						Katzenhorde[j]->setLebenKatze(Katzenhorde[j]->getLebenKatze() - Hundehorde[i]->getKraftHunde());
    						printf("Die %i. Katze hat noch %i Leben!\n\n\n", j + 1, Katzenhorde[j]->getLebenKatze());
    
    						//Sleep(500);
    						printf("Die %i. Katze greift den %i. Hund an!\nSie hat %i Schaden gemacht!\n", j + 1, i + 1, Katzenhorde[i]->getKraftKatze());
    						Hundehorde[i]->setLebenHunde(Hundehorde[i]->getLebenHunde() - Katzenhorde[j]->getKraftKatze());
    						printf("Der %i. Hund hat noch %i Leben!\n\n\n", i + 1, Hundehorde[j]->getLebenHunde());
    	
    						if (Hundehorde[i]->getLebenHunde() < 0) {
    							printf("Der %ite Hund ist gestorben!\n", i + 1);
    							Hundehorde[i] = NULL;
    						}
    						if (Katzenhorde[j]->getLebenKatze() < 0) {
    							printf("Die %ite Katze ist gestorben!\n", j + 1);
    							Katzenhorde[j] = NULL;
    						}
    					}
    					
    					
    				}
    				//Sleep(1000);
    			}
    	} while (for (int i = 0; i < KATZEN_ANZAHL; i++)
    	{
    		Katzenhorde[i] > 0;
    	} || for (int j = 0; i < HUNDE_ANZAHL; i++) {
    		Hundehorde[j] > 0;
    	});
    	
    	
    	
    	
    	
    	printf("\n\n\n\n");
    
    
    	for (int i = 0; i < KATZEN_ANZAHL; i++)
    	{
    		printf("nachher Leben Katze %i; %i\n ", i+1, Katzenhorde[i]->getLebenKatze());
    	}
    	
    	printf("\n\n\n");
    
    	for (int i = 0; i < HUNDE_ANZAHL; i++)
    	{
    		printf("nachher Leben Hunde %i; %i\n ", i+1, Hundehorde[i]->getLebenHunde());
    	}
    
    
    	
    	
    
    
    
    
    	
    	
    
    
    	return 0;
    }
    
    
    


  • Kommentar 0. Ordnung: Du sagst, das sei eine C-Aufgabe, aber du verwendest "class" und den <iostream>-Header. Das ist also C++. Der restliche Code (manuelle Arrays statt std::vector) sieht aber nicht nach C++ aus. Welche Sprache soll es sein?

    Kommentar zum Code: Deine Hunde- und Katzenklasse unterscheiden sich im Wesentlichen gar nicht. Du könntest also eine Klasse "Creature" oder "Animal" machen, die sowohl Hunde als auch Katzen abbilden kann. Dann einen std::vector<Creature> dogs; und einen für Katzen erzeugen.

    PS: der Tod, aber der tote Hund/die tote Katze (t vs d)



  • @wob Ja gut mit der Rechtschreibung lassen wir mal bei Seite 😅
    Zur Aufgabe: Es funktioniert alles mit 2 Klassen und so, Ich habe das so in der Schule gelernt, dass man C und C++ zusammenschreiben kann. Und Ich brauche nur Hilfe zu 2 Teilen des Programmes:

    1. Wenn ein Hund oder eine Katze stirbt, soll dieser/diese aus dem Array gelöscht werden. Auch kann man diese Katze oder den Hund nicht mehr angreifen.
    2. Das Programm soll halt so lange laufen bis alle Hunde ODER alle Katzen gestorben sind. das bekomme ich so mit einer for schleife in dem while() teil der do{} while() Schleife nicht hin.

    Mit freundlichen Grüßen



  • Also C++...

    • rohe Arrays, insbesondere mit dynamischer Speicherverwaltung, benutzt man seit Jahren nicht mehr, std::vector ist die Alternative.
    • deine Klassen Hund und Katze unterscheiden sich nicht, das kann man zu Animal zusammenfassen. Bei solch trivialen Objekten würde ich das als Struktur implementieren, da lohnt sich der Overhead der Datenkapselung nicht.
    #include <string>
    
    struct Animal
    {
       std::string Name; // Hund oder Katze. Oder von mir aus auch Eigenamen wie Waldi oder Mauzi, dann sehen die Kämpfe auch lustiger aus.
       unsigned int Life = 0;
       unsigned int Strength = 0;
    
       Animal() = default;
    };
    

    Ob ein Tier dann ein Hund oder eine Katze ist hängt dann nur davon ab, in welchem Vektor es sich befindet:

    #include <vector>
    
    int main()
    {
       std::vector<Animal> dogs = create_dogs(); // Vektor mit Hunden erzeugen
       std::vector<Animal> cats = create_cats(); // Vektor mit Katzen erzeugen
    
       // so lange Hunde gegen Katzen und umgekehrt kämpfen lassen, bis einer der beiden Vektoren leer ist
       while( !dogs.empty() && !cats.empty() )
       {
          fight( dogs, cats );
       }
    }
    

    Damit könntest du anfangen und hast schon mal zwei kleinere Aufgaben

    1. Vektor mit Hunden und Katzen erzeugen, die jeweils zufällige Eigenschaften haben
    2. die fight()Funktion zumindest rudimentär implementieren, in denen die Kämpfe abgewickelt werden

    Edit:
    while(...) erwartet einen Ausdruck, der sich zu einem bool konvertieren lässt. Eine for-Schleife tut das nicht, und das wird auch so nicht übersetzt.
    Und beim nächsten Mal bitte die Fehlermeldung des Compilers mitposten, die Information "bekomme ich einen Fehler" hilft nicht, den Fehler zu finden und zu beheben.


Anmelden zum Antworten