Also ich habe mir das folgendermaßen überlegt, es gibt 2 Arten von Einheiten die man bauen kann. Soweit funktioniert es auch schon.
Man kann Soldaten bauen(sind immer 100), oder Panzer (nur 1).
Gebaut gut und schön.

Jetzt habe ich noch folgendes Festgelegt:
Panzer:

// 1 Panzer
int PLeben = 1000;
int PAngriffskraft = 500;

Soldaten:

// 100 Soldaten
int SLeben = 100;
int SAngriffskraft = 35;

Beim Gegner genau die gleichen Werte:

gegPanzer:

// 1 gegPanzer
int gegPLeben = 1000;
int gegPAngriffskraft = 500;

gegSoldaten:

// 100 gegSoldaten
int gegSLeben = 100;
int gegSAngriffskraft = 35;

Ich habe bisher nicht mehr geschafft als das man die Angriffskraft zusammenzählt und damit die zusammengezählte Lebenskraft des Gegners davon zu subtrahieren.
Aber das bringt mir nicht wirklich was und ist auch doof finde ich.

Mein Ziel ist es das man, den Gegner unterlegen Angreifen kann, verliert alle Einheiten, der Gegner bleibt aber nicht Verlustlos, es sei den er ist in ganz großer überzahl.
Mhm, könnt ihr mir da helfen?
Anregungen geben?

Würde mich freuen.

mfg
Last-Boyscout

Zeig mal den Quelltext,...

Das würde dir nicht sonderlich viel bringen, weil der Code zum Angriff komplett fehlt.
Die Variablen stehen oben.
Mehr ist auch nicht von nöten.
Das andere sind nur die Auswahlmenüs, die sim Ki, die Schleifen und soweiter.

Ich brauch nur eine kleine Berechnung für die Obenstehenden Werte.

Zb.:

2 Panzer und 500 Soldaten greifen 1 Panzer und 300 Soldaten an.
Dem Angreifer gehen 1 Panzer und 100 Soldaten verloren, der Gegner verliert alles oder behält 100 Soldaten übrig.

mehr will ich garnicht.
Wenns mit einfach if Anweisungen und so gehen sollte währe das vollkommen in Ordnung.

mfg
Last-Boyscout

Martin Braun schrieb:

Zeig mal den Quelltext,...

Das würde dir nicht sonderlich viel bringen, weil der Code zum Angriff komplett fehlt.
Die Variablen stehen oben.
Mehr ist auch nicht von nöten.
Das andere sind nur die Auswahlmenüs, die sim Ki, die Schleifen und soweiter.

Ich brauch nur eine kleine Berechnung für die Obenstehenden Werte.

Zb.:

2 Panzer und 500 Soldaten greifen 1 Panzer und 300 Soldaten an.
Dem Angreifer gehen 1 Panzer und 100 Soldaten verloren, der Gegner verliert alles oder behält 100 Soldaten übrig.

mehr will ich garnicht.
Wenns mit einfach if Anweisungen und so gehen sollte währe das vollkommen in Ordnung.

mfg
Last-Boyscout

Ich habe mich mit diesem Thema noch nicht beschäftigt,dennoch aber will ich dir umbedingt helfen,weil wenn ich mal hilfe brauch,hilfst du mir ja wahrscheinlich auch

Also aus was besteht dein Programm(Schleifen,Arrays..)?

Martin

EDIT:

Also verwende mal ein array(),denn das wäre die einfachste lösung,nur wie man es ausrechnet,weiss ich nicht ,sorry
Versuch mal evt. einen Platzhalter einzusetzen.. oder cin>>

Formuliere doch erstmal die Regeln deiner Angriffsmanöver in einfachen mathematischen Formeln, und bedenke möglichst alle Sonderfälle. Dabei werden wir dir nicht groß helfeln könnem, schließlich ist es dein Spiel und du must wissen wie dein Spiel laufen soll.
Daraus dann den Quellcode zu schreiben wird danach leichter sein als du denkst.

bis bald
akari

Hallo
Daraus dann den Quellcode zu schreiben wird danach leichter sein als du denkst.

bis bald
akari

Das denke ich auch

Aber bin mal gespannt,wie er das in der Konsole programmiert hat ^^
Geht denn das überhaupt?

akari schrieb:

Es geht garnicht mal in der Konsole mit Grafiken zu programmieren

doch nur schwarzweiß

Alles ur cool editiert ^^

//Krieg im Überblick

//******************************************************************************
#include <string>
#include <windows.h>
#include <iostream.h>
#include <tchar.h>
#include <cstdlib>  
#include <ctime>
#include <stdio.h>
#include <conio.h>
#include <windows.h>
//******************************************************************************

//Clearscreen!
//******************************************************************************
void gotoxy (int x, int y)
{
    COORD pos={x, y};

    cout.flush ();
    SetConsoleCursorPosition (GetStdHandle (STD_OUTPUT_HANDLE), pos);
}

void clrscr ()
{
    HANDLE handle=GetStdHandle (STD_OUTPUT_HANDLE);
    CONSOLE_SCREEN_BUFFER_INFO info;
    COORD pos={0, 0};
    DWORD dw;

    cout.flush ();
    GetConsoleScreenBufferInfo (handle, &info);

    cout.flush ();
    FillConsoleOutputAttribute (handle, info.wAttributes, info.dwSize.X*info.dwSize.Y, pos, &dw);
    cout.flush ();
    FillConsoleOutputCharacter (handle, ' ', info.dwSize.X*info.dwSize.Y, pos, &dw);

    gotoxy (0, 0);
}
//******************************************************************************

//Farbengine von Adam!
//******************************************************************************
void farbe(WORD farbe) { 

     SetConsoleTextAttribute(::GetStdHandle(STD_OUTPUT_HANDLE), farbe); 
     } 

#define DUNKELBLAU      0x0001 
#define GRUEN           0x0002 
#define TUERKIS         0x0003 
#define ROT             0x0004 
#define VIOLETT         0x0005 
#define BRAUN           0x0006 
#define NORMAL          0x0007 
#define GRAU            0x0008 
#define BLAU            0x0009     
#define HELLGRUEN       0x000a 
#define HELLBLAU        0x000b 
#define HELLROT         0x000c 
#define PINK            0x000d 
#define GELB            0x000e 
#define WEISS           0x000f
#define ADAMadd         0x00f1
#define ADAM2           0x00f4
#define ADAM            0x00fc
#define bli             0x00f9
//******************************************************************************

//Variablen vom Spieler
//******************************************************************************
//Globale Variablen

//Verschiedene Variablen
int Rundenzaehler = 0;
int Eingabe;

//Alles für Holz
int Ende = 100;
int Holz = 100;
int Holzspeicher = 500;
int Holzfaeller = 1;

//Alles für Erz
int Mine = 0;
int Erz = 0;
int Erzspeicher = 0;
int Erzende  = 0;

//Alles für den Krieg
int Kaserne = 0;
int Soldaten = 0;
int Soldatenlimit = 0;
int Panzer = 0;

//Alles für Nahrung
int Nahrung = 0;
int Farm = 0;
int Nahrungsende = 0;
int Nahrungsspeicher = 0;
int Hunger = 2;

//Sonstige Gebäude
int Werkstatt = 0;
int Haus = 0;

//******************************************************************************

//Variablen vom Computer
//******************************************************************************

//Verschiedene Variablen

//Alles für Holz
int gegHolz = 100;
int gegHolzfaeller = 1;
int gegEnde = 100;
int gegHolzspeicher = 500;

//Alles für Erz
int gegMine =0;
int gegErz = 0;
int gegErzende = 100;
int gegErzspeicher = 0;

//Alles für Krieg
int gegKaserne = 0;
int gegSoldaten = 0;
int gegSoldatenlimit = 0;
int gegPanzer = 0;

//Alles für Nahrung
int gegNahrung = 0;
int gegFarm = 0;
int gegNahrungsende = 0;
int gegNahrungsspeicher = 0;

//Sonstige Gebäude
int gegWerkstatt = 0;
int gegHaus = 0;

//******************************************************************************

//******************************************************************************
//Alle Schleifen:

void Schleifen()

{
     //Spieler Holzschliefe
      for (Holz = 1; Holz < Ende; Holz++) 

     //Spieler Erzschleife
     if (Mine >= 1)
       {
             for (Erz = 1; Erz < Erzende; Erz++);
       }

     //Spieler Nahrungsschleife
     if (Farm >= 1)
     {
              for (Nahrung = 1; Nahrung < Nahrungsende; Nahrung++);
     }  

     //Gegnerische Holzschleife
     for (gegHolz = 1; gegHolz < gegEnde; gegHolz++)

     //Gegnerische Erzschleife  
     if (gegMine >= 1)
       {
             for (gegErz = 1; gegErz < gegErzende; gegErz++);
       }

       //Gegnerische Nahrungsschleife
     if (gegFarm >= 1)
     {
              for (gegNahrung = 1; gegNahrung < gegNahrungsende; gegNahrung++);
     }  

       //Berechnung der Speicher des Spielers:
       Holzspeicher = (Holzspeicher + Holz);
       Erzspeicher = (Erzspeicher + Erz);
       Nahrungsspeicher = (Nahrungsspeicher + Nahrung);

       //Berechnung der Speicher des Gegners:
       gegHolzspeicher = (gegHolzspeicher + gegHolz);
       gegErzspeicher = (gegErzspeicher + gegErz);
       gegNahrungsspeicher = (gegNahrungsspeicher + gegNahrung);    
};

//******************************************************************************

//******************************************************************************
void Interface()
{
    SetConsoleTextAttribute(::GetStdHandle(STD_OUTPUT_HANDLE), ROT);
    cout << "                              Krieg 2006                " << endl;
    SetConsoleTextAttribute(::GetStdHandle(STD_OUTPUT_HANDLE), GELB);
    cout << "      Spieler                                           Computer         " << endl;
    cout << "________________________________________________________________________________" << endl;
    cout << "Holzproducktion: " << Holz  << "   " << "                         Holzproducktion: " << gegHolz <<  endl;
    cout << "Holzreserven   : " << Holzspeicher << "    " << "                        Holzreserven   : " << gegHolzspeicher << endl;
    cout << "" << endl;
    cout << "" << endl;
    cout << "Erzproducktion : " << Erz   << "   " << "                           Erzproducktion : " << gegErz << endl;
    cout << "Erzreserven    : " << Erzspeicher  << "    " << "                          Erzreserven    : " << gegErzspeicher << endl;
    cout << "" << endl;
    cout << "" << endl;
    cout << "Nahrungsprod   : " << Nahrung      << "         " << "                     Nahrungsprod   : " << gegNahrung << endl;
    cout << "Nahrung        : " << Nahrungsspeicher << "         " << "                     Nahrung        : " << gegNahrungsspeicher << endl;                           
    cout << "________________________________________________________________________________" << endl;
    SetConsoleTextAttribute(::GetStdHandle(STD_OUTPUT_HANDLE), WEISS);

    SetConsoleTextAttribute(::GetStdHandle(STD_OUTPUT_HANDLE), GRUEN);
    cout << "________________________________________________________________________________" << endl;
    cout << "Holzf\x84ller: " << Holzfaeller << " H\x84user     : " << Haus << " Minen: " << Mine << "|" << "Holzf\x84ller: " << gegHolzfaeller << " H\x84user     : " << gegHaus << " Minen: " << gegMine << endl;
    cout << "Kasernen  : " << Kaserne  <<       " Werkst\x84tten: " << Werkstatt << "         |" << "Kasernen  : " << gegKaserne  <<       " Werkst\x84tten: " << gegWerkstatt << endl;
    cout << "Soldaten  : " << Soldaten <<       "                        |" << "Soldaten  : " << gegSoldaten << endl;
    cout << "Farmen    : " << Farm     <<  endl;
    cout << "________________________________________________________________________________" << endl;
    SetConsoleTextAttribute(::GetStdHandle(STD_OUTPUT_HANDLE), WEISS);

    cout << "" << endl;
    cout << "       " << "___     " << "            " << "        " << "            " << "             " << "        " << "        " << endl;
    cout << "       " << "| |     " << "            " << "        " << " ________   " << "/\\/\\/\\/\\ " << "        " << "        " << endl;
    cout << "       " << "|_|     " << "____        " << " _     " << " / __  __ \\ " << " |______|     " << " ** **  " << "        " << endl;
    cout << "____   " << "/ \\__  " << "/____\\____ " << "  / \\_  " <<"  | ||  || |  " << "|Panzer|     " << " ||-||- " << "   <>-- " << endl;
    cout << "|__|-| " << "|_|__\\ " << "|_____|__|  " << " |___|  " << " |________|  " << "|______|     " << " ^^ ^^  " << " <=====>" << endl;
    cout << "" << endl;
    cout << "Holz.: "<< Holzfaeller << " Mien: " << Mine << " Farmen: " << Farm << " Haus.: " << Haus << " Kaser.: " << Kaserne << "  Werkst.:" << Werkstatt << "  Solda.: " << Soldaten << " Panzer: " << Panzer << endl;

    cout << "" << endl;
    Sleep(50);

};

bool Ki;

void Kii()
{
     do
     {

//****************************************************************************** 
//****************************************************************************** 
//Anfang Gegner KI   

    SetConsoleTextAttribute(::GetStdHandle(STD_OUTPUT_HANDLE), ROT);
    cout << "" << endl;
    cout << "" << endl;
    cout << "                           Dein Gegner überlegt sich seinen Zug..." << endl;
    Sleep(20);
    SetConsoleTextAttribute(::GetStdHandle(STD_OUTPUT_HANDLE), WEISS);

    Ki = true;

   //KI errechnet einen Wert von 1-9
   //srand((unsigned int)time(0));
   int Entscheidung = rand() % (1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1)+ 1;

    if (Ki == true)
    {
    if (Entscheidung == 1)
    {
                     if (gegHolzspeicher >= 200)
                     {
                                         cout << "Holzfaeller wird gebaut!" << endl;
                                         gegHolzfaeller = gegHolzfaeller + 1;
                                         gegHolzspeicher = gegHolzspeicher - 200;
                                         gegEnde = gegEnde + 100;
                                         Ki = false;
                                         Sleep(2000);

                     }
    }
    }

    if (Ki == true)
    {
    if (Entscheidung == 2)
    {
                     if (gegHolzspeicher >= 500)
                     {
                                         if (gegErzspeicher >= 500)
                                         {

                                                            cout << "Haus wird gebaut!" << endl;
                                                            gegHaus = gegHaus + 1;
                                                            gegHolzspeicher = gegHolzspeicher - 500;
                                                            gegErzspeicher = gegErzspeicher - 500;
                                                            gegSoldatenlimit = gegSoldatenlimit + 200;
                                                            Ki = false;
                                                            Sleep(2000);
                                          }

                     }
    }
    }

    if (Ki == true)
    {
    if (Entscheidung == 3)
    { 
                     if (gegHolzspeicher >= 600)
                     {

                                        cout << "Mine wird gebaut!" << endl;
                                        gegMine = gegMine + 1;
                                        gegHolzspeicher = gegHolzspeicher - 600;
                                        gegErzende = gegErzende + 100;
                                        Ki = false;
                                        Sleep(2000);

                     }
    }

    }

     if (Ki == true)
     {
     if (Entscheidung == 4)
    { 
        if (gegHolzspeicher >= 10000)
        {
                            if (gegErzspeicher >= 7000)
                            {

                                               cout << "Kaserne wird gebaut!" << endl;
                                               gegKaserne = gegKaserne + 1;
                                               gegHolzspeicher = gegHolzspeicher - 10000;
                                               gegErzspeicher = gegErzspeicher - 7000;
                                               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 >= 100)
                         {
                                             if(gegErzspeicher >= 500)
                                             {
                                                               if(Nahrungsspeicher >= 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);
                            }
           }
    }

    if (Ki == true)
    {
           if (Entscheidung == 8)
           {
                            if(gegHolzspeicher >= 1000)
                            {
                                               if(gegErzspeicher >= 500)
                                               {
                                                                 cout << "Farm wird gebaut!" << endl;
                                                                 gegFarm = gegFarm + 1;
                                                                 gegHolzspeicher = gegHolzspeicher - 1000;
                                                                 gegErzspeicher = gegErzspeicher - 500;
                                                                 gegNahrungsende = gegNahrungsende +100;
                                                                 Ki = false;
                                                                 Sleep(2000);
                                               }
                            }                  
           }
    }

    if (Ki == true)
    {
           if (Entscheidung == 9)
           {
                            if(gegHolzspeicher >= 500)
                            {
                                               if(gegErzspeicher >= 2000)
                                               {

                                                                 if(gegNahrungsspeicher >= 2000)
                                                                 {
                                                                                        cout << "Er baut Panzer!" << endl;
                                                                                        gegPanzer = gegPanzer +1;
                                                                                        gegHolzspeicher = gegHolzspeicher - 500;
                                                                                        gegErzspeicher = gegErzspeicher - 2000;
                                                                                        gegNahrungsspeicher = gegNahrungsspeicher - 2000;
                                                                                        Ki = false;
                                                                                        Sleep(2000);
                                                                 }
                                               }
                            }
           }
    }                                    

   }
while(Ki != false);
clrscr();
};

//****************************************************************************** 

void Auswahl()
{

    cout << "________________________________________________________________________________" << endl;
    cout << "                         Baumenue:   "   << "Kosten:                     " << endl;
    cout << "                                       " << "Holz:   / Erz:    / Nahrung:" << endl;
    cout << ""                                        << "                            " << endl;
    cout << "                         1. Holzfaeller" << "  200                        " << endl;
    cout << "                         2. Mine       " << "  600                        " << endl;
    cout << "                         3. Farm       " << " 1000      500               " << endl;
    cout << ""                                            << endl;
    cout << "                         4. Haus       " << "  500      500               " << endl;
    cout << "                         5. Kaserne    " << "10000     7000               " << endl;
    cout << "                         6. Werkstatt  " << "50000    35000               " << endl;
    cout << "                         7. Soldaten   " << "  100      500        1000   " << endl;
    cout << "                         8. Panzer     " << "  500     2000        2000   " << endl;
    cout << "________________________________________________________________________________" << endl;

     int eingabe;
     cin >> eingabe;
     switch (eingabe)
     // Hier fängt die switchanweisung an!
     {
            //Holzfäller
            case 1:
            {
                 if (Holzspeicher >= 200)
                 {

                         Holzfaeller = Holzfaeller + 1;
                         Ende = Ende + 100;
                         Holzspeicher = Holzspeicher - 200;
                         cout << "Wird gebaut, bitte warten!" << endl;
                         Sleep(500);
                         break;
                 }
             }

            //Mine
            case 2:
            {
                 if (Holzspeicher >= 600)
                 {
                                         Mine = Mine + 1;
                                         Erzende = Erzende + 100;
                                         Holzspeicher = Holzspeicher - 600;
                                         cout << "Wird gebaut, bitte warten!" << endl;
                                         Sleep(500);
                                         break;
                 }

             }

            //Farm
            case 3:
            {
                 if (Holzspeicher >= 1000)
                 {
                                  if (Erzspeicher >= 500)
                                  {
                                                 Farm = Farm +1;
                                                 Nahrungsende = Nahrungsende + 100;
                                                 Holzspeicher = Holzspeicher - 1000;
                                                 Erzspeicher = Erzspeicher - 500;
                                                 cout << "Wird gebaut, bitte warten!" << endl;
                                                 Sleep(500);
                                                 break;
                                  }

                 }
             }

            //Haus
            case 4:
            {
                 if (Holzspeicher >= 500)
                                  {
                                         if(Erzspeicher >= 500)
                                         {

                                                        Haus = Haus + 1;
                                                        Holzspeicher = Holzspeicher - 500;
                                                        Erzspeicher = Erzspeicher - 500; 
                                                        Soldatenlimit = Soldatenlimit + 200;
                                                        cout << "Wird gebaut, bitte warten!" << endl;
                                                        cout << " _    " << endl;
                                                        cout << "/ \\__  " << endl;
                                                        cout << "|___| " << endl;
                                                        Sleep(500);
                                                        break;
                                         }
                                  }       

             }

            //Kaserne
            case 5:
            {
                 if (Holzspeicher >=10000)
                 {
                                  if (Erzspeicher >= 7000)
                                  {
                                          Kaserne = Kaserne + 1;
                                          Holzspeicher = Holzspeicher - 10000;
                                          Erzspeicher = Erzspeicher - 7000;
                                          cout << "Wird gebaut, bitte warten!" << endl;
                                          Sleep(500);
                                          break;
                                  }
                 }
                            cout << "Du hast nicht gen\x81gend Holz/Erz um ein Haus/Mine/Kaserne zu bauen" << endl;

             }

            //Werkstatt
            case 6:
            {
                 if (Holzspeicher >= 50000)
                 {
                                  if (Erzspeicher >= 35000)
                                  {

                                                                Werkstatt = Werkstatt + 1;
                                                                Holzspeicher = Holzspeicher - 50000;
                                                                Erzspeicher = Erzspeicher - 35000;
                                                                cout << "Wird gebaut, bitte warten!" << endl;
                                                                Sleep(500);
                                                                break;

                                  }
                 }
                 cout << "Du hast zuwenig Holz/Erz um eine Werkstatt bauen zu können!" << endl;
                 Sleep(500);

             }

            //Soldaten
            case 7:
            {
                 if (Kaserne >=1)
                 {
                             if (Haus >=1)
                             {
                                      if (Soldaten <= Soldatenlimit)
                                      {
                                                   if (Holzspeicher >= 100)
                                                   {
                                                                    if (Erzspeicher >= 500)
                                                                    {
                                                                                    if (Nahrungsspeicher >= 1000)
                                                                                    {                    
                                                                                                         Soldaten = Soldaten + 100;
                                                                                                         Holzspeicher = Holzspeicher - 100;
                                                                                                         Erzspeicher = Erzspeicher - 500;
                                                                                                         Nahrungsspeicher = Nahrungsspeicher - 1000;
                                                                                                         cout << "Soldaten werden produziert!" << endl;
                                                                                                         Sleep(500);
                                                                                                         break;
                                                                                    }
                                                                    }
                                                   }       
                                      }      
                             }
                                 cout << "Du hast zu wenig Häuser, oder dein Soldatenlimit ist erreciht!" << endl;
                                 Sleep(200);

                 }
                                 else
                                 {
                                              cout << "Du hast doch garkeine Kaserne!" << endl;
                                              Sleep(200);

                                 }
             }

            //Panzer
            case 8:
            {
                 if (Werkstatt >= 1)
                 {
                               if (Holzspeicher >= 500)
                               {
                                                if (Erzspeicher >= 2000)
                                                {
                                                                if (Nahrungsspeicher >= 2000)
                                                                {
                                                                 Panzer = Panzer +1;
                                                                 Holzspeicher = Holzspeicher - 500;
                                                                 Erzspeicher = Erzspeicher - 2000;
                                                                 Nahrungsspeicher = Nahrungsspeicher -2000;
                                                                 cout << "Panzer wird gebaut, bitte warten!" << endl;
                                                                 Sleep(500);
                                                                 break;
                                                                 }
                                                }
                               }
                 }                   
             }

            //Platzhalter
            case 9:
            {
             }

     }
     //Hier hört die switchanweisung auf!

     //Bildschirm wird gelöscht
     clrscr();
}

//******************************************************************************

//******************************************************************************
//Main

int main()
{
    do
    {

    Interface();
    Auswahl();
    Schleifen();
    Kii();

    }
    while ( 1 < 100);

}

//******************************************************************************

jetzt kommt erstmal... Unübersichtlich, durcheinander, zuviele If-Anweisungen^^

if(holz >= 1000 && zeug >= 3442 && soweiter) {
      machDasDingFunktion(); //Aussagekräftiger Funktionsname.
}

Machs mal so, dann kann mas auch lesen

jetzt kommt erstmal... Unübersichtlich, durcheinander, zuviele If-Anweisungen^^

Richtig, aber nicht volltändig. Hinzuzufügen wäre noch:

Globale Variablen sind böse!

#define-Anweisungen sind sehr böse (ausgenommen include-Guards und eine sehr, sehr begrenzte Zahl anderer Fälle).

Sind wirklich zuviele if.
Schau mal:

if(holz >= 1000 && zeug >= 3442 && soweiter) {
      machDasDingFunktion(); //Aussagekräftiger Funktionsname.
}

Machs mal so, dann kann mas auch lesen

Das ist eine gute Idee.
Ich habe mir dieses Projeckt vorgenommen, weil C++ mich seht interessiert, komm aber nur langsam voran, aber ich verbessere den Code ständig, am Anfang sah er noch viel schlimmer aus. So lerne ich schneller und besser finde ich.
Außerdem bleibt mir die Motivation wenn ich an etwas arbeite was mir spaß macht.

@Z2: aber ohne Globale Variablen gehts hier glaube ich garnicht.

thx, an euch beide, jetzt brauch ich nur noch wen der mir erklärt wie eine einfache Kampfberechnung durchführen kann!

mfg
Last-Boyscout

Was das "Kampfscript" betrifft: akaris Tip ist gut. Formuliere das ganze als mathematische Formeln (wie die aussehen mußt du schon selbst festlegen; das ist keine Implementations-, sondern eine Design-Frage).

Es würde sich vielleicht auch lohnen, alles in Module zu verpacken, dann hast du mehr übersicht.
Die hier würde ich in eine Klasse bzw. Struktur packen.

//Verschiedene Variablen
int Rundenzaehler = 0;
int Eingabe;

//Alles für Holz
int Ende = 100;
int Holz = 100;
int Holzspeicher = 500;
int Holzfaeller = 1;

//Alles für Erz
int Mine = 0;
int Erz = 0;
int Erzspeicher = 0;
int Erzende  = 0;

//Alles für den Krieg
int Kaserne = 0;
int Soldaten = 0;
int Soldatenlimit = 0;
int Panzer = 0;

//Alles für Nahrung
int Nahrung = 0;
int Farm = 0;
int Nahrungsende = 0;
int Nahrungsspeicher = 0;
int Hunger = 2;

//Sonstige Gebäude
int Werkstatt = 0;
int Haus = 0;

--> Bis jetzt ist dein Prgramm noch sehr prozedual, probiere einfack mal alles etwas zu kapseln.

float power = zufallszahlZwischen0und2oderSo();
int neueAnzahlEinheiten = anzahlEinheiten - (int)((float)anzahlGegner * power);

Erstelle doch einfach eine Klasse Einheit:

class Einheit
{
int staerke;
int verteidigung;
...
}[/cpp]

--> die kannste dann alle mit fstream in eine Datei schreiben und manipulieren.
und halt wieder auslesen.

Mal sehen wie weit ich mich da schlau machen kann.
Ne kleine Vorlage habe ich ja jetzt.

Wie genau war das mit den Modulen gemeint?

zb.: du legst dir eine Datei names Ki.h an und schreibst dort die KI Funktion rein.

und über #include "ki.h" fügst du die dann in die main ein.

Du kannst, wie du willst neue Dateien anlegen:

zb.: du legst dir eine Datei names Ki.h an und schreibst dort die KI Funktion rein.

und über #include "ki.h" fügst du die dann in die main ein.

Probier ich direckt mal aus

struct seite // spieler oder gegner
{
    int Mine;
    int Erz;
    int Erzspeicher;
    int Erzende; 

    // und so weiter
};

in der main-Funktion:

int main()
{
    do
    {
        seite Spieler:
        seite Gegner;

        InitSpieler (Spieler);
        InitGegner (Gegner);    

        Interface();
        Auswahl (Spieler);
        Berechnung (Spieler); // ersetzt Schleife-Funktion (komischer Name)
        Berechnung (Gegner);
        Kii (Gegner);

    }
    while ( 1 < 100); // witzig ;)
}

Und deine Funktionen sehen dann so aus:

void Auswahl (seite& Seite) 
{
// irgendwas
}

Tc++H schrieb:

Du kannst, wie du willst neue Dateien anlegen:

zb.: du legst dir eine Datei names Ki.h an und schreibst dort die KI Funktion rein.

und über #include "ki.h" fügst du die dann in die main ein.

Probier ich direckt mal aus

Das würde ich übrigens an deiner Stelle nicht machen. Grundsätzlich ist der Hinweis schon korrekt. Aber du solltest erst anfangen zu modularisieren, wenn du auch was zu modularisieren hast. Lediglich einzelne Funktionen in andere Übersetzungseinheiten auszulagern bringt dir erst mal gar nichts.

Dankeschön.

Ich geh jetzt erstmal pennen.

Gute Nacht^^

mfg
Last-Boyscout

unsigned long anzPanzer = 23;
    unsigned long gegAnzPanzer = 42;
    unsigned long anzSoldaten = 11;
    unsigned long gegAnzSoldaten = 33;

    unsigned long PLeben = 1000;
    unsigned long PAngriffskraft = 500;
    unsigned long SLeben = 100;
    unsigned long SAngriffskraft = 35;
    unsigned long gegPLeben = 1000;
    unsigned long gegPAngriffskraft = 500;
    unsigned long gegSLeben = 100;
    unsigned long gegSAngriffskraft = 35;

// ## Angriff ##################################################################

// 1) Panzerbattle

// Haben beide Parteien gleich viel Panzer?
if (anzPanzer == gegAnzPanzer)
{
    // Alle Panzer haben sich gegenseitig ausgeschaltet!
    anzPanzer = 0;
    gegAnzPanzer = 0;
}

    // Hat der Gegner mehr Panzer?
if     (anzPanzer < gegAnzPanzer)
{
    // Der Gegner vernichtet alle Panzer des Spielers...
    gegAnzPanzer -= anzPanzer;
    anzPanzer = 0;

    // ...und greift danach mit den Panzern die Soldaten 
    // des Spielers an!
    if (anzSoldaten != 0)
    {
        while (1)
        {
            // Ein Panzer: Soldaten greifen an, bis keine mehr da 
            // sind oder der Panzer zerstört wurde
            for (long derGegPanzer = gegPLeben; 
                 derGegPanzer > 0 && anzSoldaten != 0;
                 derGegPanzer -= SAngriffskraft,
                 --anzSoldaten); // Hier können z.B. alle noch verbliebenden
                                 // Panzer auf die Soldaten schiessen und so
                                 // viel mehr von ihnen vernichten, denn die
                                 // einfache Dekrementierung hier wirkt, als
                                 // ob sich die Soldatengruppe in einer Reihe 
                                 // aufstellt, die Gruppe mal angreifen darf
                                 // und danach der Panzer dran ist. Alle anderen
                                 // schauen zu und warten ^^

            // Haben die Panzer etwa alle Soldaten erledigt?
            if (anzSoldaten == 0)
            {
                // SPIELER HAT VERLOREN!!!
                // exit, return, GAME OVER etc.
            }
            // Nein! Offensichtlich haben die Soldaten einen Panzer zerstört
            gegAnzPanzer--;
            // Hat der Gegner noch Panzer?
            if (gegAnzPanzer == 0)
            {
                // Alle gegnerischen Panzer wurden von den Soldaten zerstört!
                break;
            }
        }
    }
    else
    {
        // SPIELER HAT VERLOREN!!!
        // exit, return, GAME OVER etc.
    }
}

// Hat der Spieler mehr Panzer?
if (anzPanzer > gegAnzPanzer)
{
    // Der Spieler vernichtet alle Panzer des Gegners...
    anzPanzer -= gegAnzPanzer;
    gegAnzPanzer = 0;

    // ...und greift danach mit den Panzern die Soldaten 
    // des Gegners an!
    if (gegAnzSoldaten != 0)
    {
        while (1)
        {
            // Ein Panzer: Soldaten greifen an, bis keine mehr da 
            // sind oder der Panzer zerstört wurde
            for (long derPanzer = PLeben; 
                 derPanzer > 0 && gegAnzSoldaten != 0;
                 derPanzer -= gegSAngriffskraft,
                 --gegAnzSoldaten); // Hier können z.B. alle noch verbliebenden
                                    // Panzer auf die Soldaten schiessen und so
                                    // viel mehr von ihnen vernichten, denn die
                                    // einfache Dekrementierung hier wirkt, als
                                    // ob sich die Soldatengruppe in einer Reihe 
                                    // aufstellt, die Gruppe mal angreifen darf
                                    // und danach der Panzer dran ist. Alle anderen
                                    // schauen zu und warten ^^

            // Haben die Panzer etwa alle Soldaten erledigt?
            if (gegAnzSoldaten == 0)
            {
                // SPIELER HAT GEWONNEN!!!
                // exit, return, GAME OVER etc.
            }
            // Nein! Offensichtlich haben die Soldaten einen Panzer zerstört
            anzPanzer--;
            // Hat der Spieler noch Panzer?
            if (anzPanzer == 0)
            {
                // Alle eigenen Panzer wurden von den Soldaten zerstört!
                break;
            }
        }
    }
    else
    {
        // SPIELER HAT GEWONNEN!!!
        // exit, return, GAME OVER etc.
    }
}

// 2) Soldatenkampf

// Haben beide Parteien gleich viele Soldatengruppen?
if (anzSoldaten == gegAnzSoldaten)
{
    // UNENTSCHIEDEN!!!
    // exit, return, GAME OVER etc.
}

// Hat der Gegner mehr Soldaten?
if (anzSoldaten < gegAnzSoldaten)
{
    // SPIELER HAT VERLOREN!!!
    // exit, return, GAME OVER etc.
}

// Hat der Spieler mehr Soldaten?
if (anzSoldaten > gegAnzSoldaten)
{
    // SPIELER HAT GEWONNEN!!!
    // exit, return, GAME OVER etc.
}

Ein weiterer (objektorientierterer) Ansatz:

#include <vector>

// ## Einheiten ################################################################

// -- Panzer -------------------------------------------------------------------
class Panzer
{
public:
    Panzer(int setLeben, int setAngriffskraft);
private:
    int Leben;
    int Angriffskraft;
};

Panzer::Panzer(int setLeben, int setAngriffskraft):
Leben(setLeben), Angriffskraft(setAngriffskraft)
{

}

// -- Soldaten -----------------------------------------------------------------
class Soldaten
{
public:
    Soldaten(int setLeben, int setAngriffskraft);
private:
    int Leben;
    int Angriffskraft;
};

Soldaten::Soldaten(int setLeben, int setAngriffskraft):
Leben(setLeben), Angriffskraft(setAngriffskraft)
{   }

// ## Streitkräfte #############################################################
class Streitkraefte
{
public:
    // Der Vereinfachung halber als public
    std::vector<Panzer> Panzerstreitkraefte;
    std::vector<Soldaten> Soldatengruppen;
private:

};

// Allgemeine Angriffsfunktion
void angriff(Streitkraefte Angreifer, Streitkraefte Verteidiger);

// Dient nur zur Veranschaulichung, in Wirklichkeit
// kommt dieser Code halt irgendwo in deinem Programm
int main()
{

    unsigned long anzPanzer = 23;
    unsigned long gegAnzPanzer = 42;
    unsigned long anzSoldaten = 11;
    unsigned long gegAnzSoldaten = 33;

    unsigned long PLeben = 1000;
    unsigned long PAngriffskraft = 500;
    unsigned long SLeben = 100;
    unsigned long SAngriffskraft = 35;
    unsigned long gegPLeben = 1000;
    unsigned long gegPAngriffskraft = 500;
    unsigned long gegSLeben = 100;
    unsigned long gegSAngriffskraft = 35;

    Panzer templateEigenePanzer(1000, 500);
    Soldaten templateEigeneSoldaten(100, 35);
    Panzer templateGegnerPanzer(1000, 500);
    Soldaten templateGegnerSoldaten(100, 35);

    Streitkraefte EigeneArmee;
    Streitkraefte GegnerArmee;

    // Bau-Routinen
    // z.B.:
    //
    // EigeneArmee.Panzerstreitkraefte.push_back(templateEigenePanzer);

    angriff(EigeneArmee, GegnerArmee);  // call-by-value, sollte man dann später
                                        // natürlich ändern

    return 0;
}

// ## Angriff ##################################################################
// Angriffsfunktion mit etwas anderer Logik als zuvor (last man standing, 
// Panzer greifen keine Soldaten an und umbekehrt)
void angriff(Streitkraefte Angreifer, Streitkraefte Verteidiger)
{
    short einheitenAngreifer = Angreifer.Panzerstreitkraefte.size() + Angreifer.Soldatengruppen.size();
    short einheitenVerteidiger = Verteidiger.Panzerstreitkraefte.size() + Verteidiger.Soldatengruppen.size();

    // -- Panzer ---------------------------------------------------------------

    if (Angreifer.Panzerstreitkraefte.size() == Verteidiger.Panzerstreitkraefte.size())
    {
        Angreifer.Panzerstreitkraefte.clear();
        Verteidiger.Panzerstreitkraefte.clear();
    }

    if (Angreifer.Panzerstreitkraefte.size() < Verteidiger.Panzerstreitkraefte.size())
    {
        while (Angreifer.Panzerstreitkraefte.size() != 0)
        {
            Angreifer.Panzerstreitkraefte.pop_back();
            Verteidiger.Panzerstreitkraefte.pop_back();
        }
    }

    if (Angreifer.Panzerstreitkraefte.size() > Verteidiger.Panzerstreitkraefte.size())
    {
        while (Verteidiger.Panzerstreitkraefte.size() != 0)
        {
            Angreifer.Panzerstreitkraefte.pop_back();
            Verteidiger.Panzerstreitkraefte.pop_back();
        }
    }

    // -- Soldaten -------------------------------------------------------------

    if (Angreifer.Soldatengruppen.size() == Verteidiger.Soldatengruppen.size())
    {
        Angreifer.Soldatengruppen.clear();
        Angreifer.Soldatengruppen.clear();
    }

    if (Angreifer.Soldatengruppen.size() < Verteidiger.Soldatengruppen.size())
    {
        while (Angreifer.Soldatengruppen.size() != 0)
        {
            Angreifer.Soldatengruppen.pop_back();
            Verteidiger.Soldatengruppen.pop_back();
        }
    }

    if (Angreifer.Soldatengruppen.size() > Verteidiger.Soldatengruppen.size())
    {
        while (Verteidiger.Soldatengruppen.size() != 0)
        {
            Angreifer.Soldatengruppen.pop_back();
            Verteidiger.Soldatengruppen.pop_back();
        }
    }

    if (Angreifer.Panzerstreitkraefte.size() == 0 && Angreifer.Soldatengruppen.size() == 0)
    {
        // ANGREIFER HAT VERLOREN!!!
    }
    if (Verteidiger.Panzerstreitkraefte.size() == 0 && Verteidiger.Soldatengruppen.size() == 0)
    {
        // VERTEIDIGER HAT VERLOREN!!!
    }
}

Das ganze ist als Hinweissammlung und Baukasten zu verstehen, hatte jetzt nicht die Zeit, das zu prüfen und zu kompilieren, aber ich denke, man kann im Ansatz erkennen, was der Code nach ein paar Modifikationen bewerkstelligen sollte. Auch sollte auffallen, dass die objektorientierte Variante weitaus mehr Möglichkeiten bietet, auch wenn ich viele davon gar nicht verwendet habe.

Vielen dank!

abend,

Zum Originalquelltext: Den habe ich erst gesehen, als ich schon so 3/4 hatte, da will ich mich jetzt ehrlich gesagt nicht einarbeiten

Hehe, danke, danke du hast schon genug getan^^
Ihr sollt mich ja nicht komplett übercoden hier...
Jetzt habe ich nen guten Ansatz das zusammenschustern mach ich dann noch selber.

Das der Code noch so ziemlich unsauber ist liegt daran das mir die Erfahrung fehlt, aber sowas braucht ja nunmal seine Zeit.