Kampfskript oder ähnliches
-
Last-Boyscout schrieb:
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-BoyscoutIch 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>>
-
Hallo
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
-
akari schrieb:
Hallo
Daraus dann den Quellcode zu schreiben wird danach leichter sein als du denkst.bis bald
akariDas 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 ^^
-
Eigentlich ganz einfach, mehrere Schleifen(hatte vorher gotos drin^^) dann saumäßigviele If-Anweisungen, dann einfache Textausgaben.
Reccaucenschleifen und und... ok dann poste ich mal den Code wenn ihr wollt://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^^
-
Sind wirklich zuviele if.
Schau mal: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).
-
:schland: schrieb:
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
-
Es geht immer ohne globale Variablen. Ich programmiere jetzt seit 8 Jahren in C++ und in dieser Zeit hat es noch keinen einzigen Fall gegeben, wo ich nicht ohne globale Variablen ausgekommen wäre.
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).
-
Auch, wenn es nicht deine Frage ist:
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.
-
Kampffunktion:
float power = zufallszahlZwischen0und2oderSo(); int neueAnzahlEinheiten = anzahlEinheiten - (int)((float)anzahlGegner * power);
-
Jetzt noch zum \1:
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.
-
Hier fehlt es mir dann an Wissen.
Danke für die vielen Vorschläge.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?
-
Du kannst, wie du lust und laune hast 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.
-
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
-
Klassen wären natürlich ideal. Aber wie es aussieht würde dich das im Moment noch überfordern. Also fassen wir die Variablen zumindest mal in structs zusammen, z.B. so:
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 }
-
Last-Boyscout schrieb:
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.
-
Alles sehr viel neues für micht, aber die nötigen Verbesserungen.
Dankeschön.
Ich geh jetzt erstmal pennen.
Gute Nacht^^
mfg
Last-Boyscout
-
Hier mal ein Ansatz:
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.
-
Hammer! Danke, endlich ein Ansatz den ich versteh, man hast du dir eine Arbeit gemacht.
Vielen dank!
-
Ähm. Der zweite Ansatz ist doch eher fragwürdig. Mal abgesehen davon, daß da ein paar dicke Fehler im Code sind (ok, das kann in der Eile passieren), ist das Konzept nicht in Ordnung. Im Orignal-Quelltext wird von state-losen Einheiten ausgegegangen, d.h. zwei Einheiten des gleichen Types sind ununterscheidbar. In dem Fall genügt ein einfacher Zähler und man braucht keinen std::vector. Du gibst in deinem Beispiel den Einheiten zwar Attribute, aber du verwendest diese nirgendwo in der Kampfauswertung (hoffe mal, ich habe da nichts übersehen; es ist schon spät
).