Simulierte Ki



  • Also ich habe folgendes Problem:

    Ich schreibe gerade ein Spiel, das heißt ich setze mich ab und zu mal ran, immoment fehlt mir die Motivation etwas aber das wird wieder.
    Genau deshalb probiere ich mich um folgendes Problem zu kümmern.

    Ich habe ein kleines Konsolenbasiertes Strategiespiel in C++ geschrieben.
    Die ersten Lauffähigen Versionen brachten mich schon zum Staunen.
    Doch mein Code war hoffnungslos durcheinander und ich verwendete 1000 Gotos...
    Auf die soll man ja möglichst verzichten, also habe ich nochmal alles neu Struckturiert und komme auch ganz gut voran.

    Ein kleines Problem habe ich aber immernoch ohne die Gotos...
    Meine Simulierte Ki...hahah wenn die Bezeichnung derer Überhaupt würdig ist handelt nicht wie sie es soll.
    Es sind eigentlich nur zufallsentscheidungen die nur dann funktionieren wenn genügend Rohstoffe vorhanden sind. Halt alles einfach gehalten, aber es funktioniert und reicht für meine Zwecke.

    Also hier mal der Code:

    void Ki()
    {
         do
         {
    
    //****************************************************************************** 
    //****************************************************************************** 
    //Anfang Gegner KI   
    
        bool Ki;
    
        SetConsoleTextAttribute(::GetStdHandle(STD_OUTPUT_HANDLE), ROT);
        cout << "" << endl;
        cout << "" << endl;
        cout << "                           Dein Gegner ist am Zug!" << endl;
        SetConsoleTextAttribute(::GetStdHandle(STD_OUTPUT_HANDLE), WEISS);
    
        Ki = true;
    
       //KI errechnet einen Wert von 1-7
       //srand((unsigned int)time(0));
       int Entscheidung = rand() % (1 + 1 + 1 + 1 + 1 + 1 + 1)+ 1;
    
        cout << Entscheidung;
        if (Ki == true)
        {
        if (Entscheidung == 1)
        {
                         if (gegHolzspeicher >= 100)
                         {
                                             cout << "Holzfaeller wird gebaut!" << endl;
                                             gegHolzfaeller = gegHolzfaeller + 1;
                                             gegHolzspeicher = gegHolzspeicher - 100;
                                             gegEnde = gegEnde + 100;
                                             Ki = false;
                                             Sleep(2000);
    
                         }
        }
        }
    
        if (Ki == true)
        {
        if (Entscheidung == 2)
        {
                         if (gegHolzspeicher >= 500)
                         {
    
                                             cout << "Haus wird gebaut!" << endl;
                                             gegHaus = gegHaus + 1;
                                             gegHolzspeicher = gegHolzspeicher - 500;
                                             gegSoldatenlimit = gegSoldatenlimit + 200;
                                             Ki = false;
                                             Sleep(2000);
    
                         }
        }
        }
    
        if (Ki == true)
        {
        if (Entscheidung == 3)
        { 
                         if (gegHolzspeicher >= 1000)
                         {
                                            cout << "Mine wird gebaut!" << endl;
                                            gegMine = gegMine + 1;
                                            gegHolzspeicher = gegHolzspeicher - 1000;
                                            gegErzende = gegErzende + 100;
                                            Ki = false;
                                            Sleep(2000);
    
                         }
        }
        }
    
         if (Ki == true)
         {
         if (Entscheidung == 4)
        { 
            if (gegHolzspeicher >= 10000)
            {
                                if (gegErzspeicher >= 5000)
                                {
    
                                                   cout << "Kaserne wird gebaut!" << endl;
                                                   gegKaserne = gegKaserne + 1;
                                                   gegHolzspeicher = gegHolzspeicher - 10000;
                                                   gegErzspeicher = gegErzspeicher - 5000;
                                                   Ki = false;
                                                   Sleep(2000);
    
                                }
            }
        }
        }
    
         if (Ki == true)
         {
         if (Entscheidung == 5)
        { 
            if (gegHolzspeicher >= 50000)
            {
                                if (gegErzspeicher >= 35000)
                                {
    
                                                   cout << "Werkstatt wird gebaut!" << endl;
                                                   gegWerkstatt = gegWerkstatt + 1;
                                                   gegHolzspeicher = gegHolzspeicher - 50000;
                                                   gegErzspeicher = gegErzspeicher - 35000;
                                                   Ki = false;
                                                   Sleep(2000);
    
                                }
            }
        }
        }
    
         if (Ki == true)
         {
         if (Entscheidung == 6)
        { 
            if (gegKaserne >= 1)
               {
                        if (gegHaus >= 1)
                        {
                             if (gegHolzspeicher >= 1000)
                             {
                                if (gegSoldaten <= gegSoldatenlimit)
                                   {                       
    
                                              cout << "Soldaten werden produziert!" << endl;
                                              gegSoldaten = gegSoldaten + 100;
                                              gegHolzspeicher = gegHolzspeicher - 1000;
                                              Ki = false;
                                              Sleep(2000);
    
                                              }
                                   }
                             }
                        }
               }
    
        }
    
        if (Ki == true)
        {
               if (Entscheidung == 7)
               {
                                if (gegSoldaten > 0)
                                {
                                                cout <<" Der Computer greift dich an!" << endl;
                                                Soldaten = Soldaten - gegSoldaten;
                                                cout << "Die " << gegSoldaten << " greifen deine " << Soldaten << " an!" << endl;
                                                                  if (Soldaten <= 0)
                                                                  {
                                                                              Haus = Haus -1;
                                                                              Mine = Mine -1;
                                                                              Kaserne = Kaserne -1;
                                                                              Werkstatt = Werkstatt -1;
                                                                              }
                                                Ki = false;
                                                Sleep(2000);
                                }
               }
        }
    
       }
    while(Ki == false);
    
    };
    

    Eigentlich sollte die Entscheidungsfindung solange durchlaufen bis eine Entscheidung getroffen ist, aber leider funktioniert dies nicht...
    Wenns nicht klappt am Anfang passiert einfach garnichts.

    Hoffentlich versteht ihr worauf ich hinaus will.

    Danke schonmal im Voraus.

    mfg
    Last-Boyscout



  • was bedeutet denn "geht nicht?"

    kanns grad nicht in meiner kugel erkennen



  • Vom entsetzlichen Stil abgesehen, ist das Problem wohl, dass die bool-Variable genauso heißt wie die Funktion: Ki. Wenn man das trennt, sieht man, dass die Bedingung eine Variable prüft, die in der Schleife definiert ist. Kann nicht klappen.



  • Wenn ich das Bool aber weglassen, dann funktionierst garnicht mehr.

    Wie muss ich das umschreiben, damit die Schleife solange durchlaufen wird bis der Wert Ki == false ist?



  • du sollst die variable auch nciht weglassen, aber viell den name mal ändern von fkt oder variable



  • Kann es sein, dass einfach manchmal keine Bedingung erfüllt ist? Wenn zum Beispiel das Programm die Entscheidung "1" trifft, aber der Holzspeicher <100 ist?!

    LOTN



  • Last-Boyscout schrieb:

    Wie muss ich das umschreiben, damit die Schleife solange durchlaufen wird bis der Wert Ki == false ist?

    Wenn du willst das deine Schleife solange läuft bist "Ki" false ist, dann ist deine abbruchbedingung aber wohl nicht richtig.

    while(Ki == false);
    


  • LOTN schrieb:

    Kann es sein, dass einfach manchmal keine Bedingung erfüllt ist? Wenn zum Beispiel das Programm die Entscheidung "1" trifft, aber der Holzspeicher <100 ist?!

    LOTN

    Ja genauso soll es auch funktionieren.
    Solange bis eine Bedingung zutrifft soll die Schleife durchlaufen werden.
    Mit Gotos hats damals geklappt, ist aber ein ziemliches Wirwarr.

    @EEK
    genau das steht doch ganz unten in meinem Code!



  • überleg nochmal genau....



  • Last-Boyscout schrieb:

    @EEK
    genau das steht doch ganz unten in meinem Code!

    Ja eben deshalb hab ich es ja auch geschrieben. Vielleicht meinst du ja auch was anderes, aber wenn ich dich richtig verstanden habe dann heißt es

    while(Ki != false);
    


  • EEK schrieb:

    Last-Boyscout schrieb:

    @EEK
    genau das steht doch ganz unten in meinem Code!

    Ja eben deshalb hab ich es ja auch geschrieben. Vielleicht meinst du ja auch was anderes, aber wenn ich dich richtig verstanden habe dann heißt es

    while(Ki != false);
    

    mhm, jetzt ist der Wert Ki immer true.
    Naja ich muss mich da noch mal schlauer machen.
    Ich weiß zu wening und will zu viel^^

    Danke an alle! 🙂



  • nein, ds bedeutet das die schleife solange geh, wie Ki true ist, sollte sie falsch sein geht er aus der schleife raus



  • So es geht jetzt dank

    while(Ki != false);
    

    Ich hatte vergessen dem Computer Anfagsrohstoffe zuzuweisen und deshalb wiederholte sich die Schleife, sie konnte nur weiterhin true bleiben.

    Aber jetzt funktioniert es. Juchu!

    Danke nochmal an alle.



  • BTW: was soll eigentlich

    LastBoyscout schrieb:

    int Entscheidung = rand() % (1 + 1 + 1 + 1 + 1 + 1 + 1)+ 1;
    

    Is recht witzig...

    Greetz, Swordfish


Log in to reply