Abwechselnd angreifen

[Doenercola]

Hallo!

Ich habe eine Frage, und zwar programmiere ich eine Art Textrollenspiel, es klappt soweit auch alles, aber bei den Angriffen bräuchte ich noch etwas Hilfe...

Folgende Situation : Man wählt ein Gebiet in das man reisen möchte und es "erscheint" ein Gegner. Dieser Gegner hat, wie der Spieler Treffer- und Angriffspunkte. Mit einem Klick auf einen Button "angreifen" wird der Kampf initiiert.
Es wird nacheinander angegriffen, bis die Lebenspunkte von einem der beiden auf 0 oder kleiner geht.
ICh habs mal versucht aber es funktioniert net.

Delphi-Quellcode:

// 
case WerIstDran of // 1 = Spieler, 2 = Computer

  1:  begin
          if GegnerLP > 0
          then
              begin
                GegnerLP := GegnerLP - SpielerAP;
                 WerIstDran := 2;
              end
          else
              begin
                Memo_Textausgabe.Text := Memo_Textausgabe.Text +
                                       'Du hast gewonnen! Glückwunsch!';
                MemoFeld_NachUnten;
              end;
     end;

  2:  begin
           if SpielerLP > 0
           then
               begin
                  SpielerLP := SpielerLP - GegnerAP;
                  Aktualisiere_Lebenspunkte;
                  WerIstDran := 1;
               end;
           else
              begin
                  Memo_Textausgabe.Text := Memo_Textausgabe.Text +
                                  'Du hast leider verloren! :( Versuchs morgen nochmal!';
                  MemoFEld_NachUnten;

           end;
     end;

Das alles befindet sich in einer on-click Prozedur des Angreifen-Buttons.
Wie und was muss ich einbinden, damit man sich nacheinander duelliert? Hat es was mit einer "Flag" zu tun? Wenn ja, was ist das genau? Ich programmiere leider noch net so lange.
Wenn einer der beiden stirbt, soll das Ergebnis in einem Memo_Feld ausgegeben werden, aber das bekomm ich hin :)

Liebe Grüße
Marcel

[stahli]

Ein Flag ist eine Boolean-Variable, das "JA" beinhalten kann (oder eben nicht).
Wechseln kann man das sehr leicht durch

Delphi-Quellcode:

Flag := not Flag;

Man kann auch eine Intergervariable nutzen und diese hochzählen.

Delphi-Quellcode:

I := 1;
...
Inc(I);
if I > 2 then
  I := 1;

Es gibt da unterschiedliche Möglichkeiten. Du musst Dich an Deinen jeweiligen Bedürfnissen orientieren.

[hans ditter]

Hi,
also mir sind zwei Sachen aufgefallen:
1)

Delphi-Quellcode:

Aktualisieren_Lebenspunkte

hast du nur in dem Angriff des Computers. Was wird dabei gemacht, ist die wichtig?
2) Ich glaube, du hast noch ein logisches Problem. Wenn du den Computer angreifst, dann hat er noch LP, soweit korrekt. Angenommen, deine AP ist 10 und die LP des Gegners 9, dann ist er nach dem Angriff tod. Eigentlich müsstest du nachdem die Attacke ausgeführt wurde nochmal überprüfen, ob der Gegner nicht vielleicht jetzt tod ist. Also etwa so:

Delphi-Quellcode:

if Gegner_LP > 0 then
begin
  Gegner_LP:=Gegner_LP - Angreifer_AP;
  if Gegner_LP <= 0 then
    Verloren(Gegner)
  else 
    WerIstDran:=Gegner;

Dann bräuchtest du auch den else-Zweig nicht mehr. Die Prozedur "Verloren" könnte dann so aussehen:

Delphi-Quellcode:

procedure Verloren(Spieler: String);
begin
  Memo.Text:=Memo.Text + 'Spieler ' + Spieler + ' hat verloren! Versuchs wann anders nochmal!';
end;

Bei der Prozedur kannst du dann natürlich auch noch weitere Abfragen einbauen. Also das z.B. unterschiedliche Nachrichten ausgegeben werden, wenn der Spieler gewonnen oder verloren hat, oder du gibst noch an, wie das Spiel verlaufen ist, oder wie das Endergebnis war, oder oder oder... :wink:

Hoffe, ich konnte dir helfen!

LG; hans ditter

P.S.: Ich hoffe, dass trifft dein Problem. Du hast nämlich (ist mir jetzt grad erst aufgefallen...:oops:) keine wirkliche Beschreibung deines Problems mit reingestellt...:roll:

[Doenercola]

Danke für die schnellen Antworten! :)

Die Prozedur "Aktualisiere Lebenspunkte" sieht so aus:

Delphi-Quellcode:

procedure Aktualisiere_Lebenspunkte;
begin
Lebenspunkte := Lebenspunkte + ZusatzLP;
Form1.Pnl_Lebenspunkte.Caption := IntToStr(Lebenspunkte);

Sie stellt die aktuellen LP in nem Panel dar und aktualisiert den Wert :)
E: Zur ERklärung, in der Prozedur im Startpost hab ich gesagt: SpielerLP := Lebenspunkte;

Mein Problem ist das, dass ich nicht weiß wie ich das Programm dazu bringen soll, immer abwechselnd anzugreifen. Das heißt, zuerst greift der Spieler den Gegner an, dann der Gegner den Spieler, dann ist wieder der Spieler dran,... und das soll gestoppt werden, wenn einer der beiden zu Boden geht sozusagen.

[stahli]

ungefähr so...

Delphi-Quellcode:

Ende := False;
SpielerIstAmZug := True;
...
repeat
  if SpielerIstAmZug then
  begin
    SpielerZieht(Ende); // kann Ende auf True setzen
  end
  else
  begin
    GegnerZieht(Ende); // kann Ende auf True setzen
  end;
  SpielerIstAmZug := not SpielerIstAmZug;
until Ende;

[Doenercola]

Ich habs schon geahnt dass es mit repeat geht! :) Danke euch beiden!
Zum Verständnis: SpielerZieht und GegnerZieht sind eigene Prozeduren, eben die die angreifen, und am Ende einer Prozedur soll gecheckt werden ob die LP 0 oder unter 0 sind? Wird das net bei dem until auch festgelegt?

Delphi-Quellcode:

SpielerIstAmZug := not SpielerIstAmZug;

und mit dieser Zeile stellt man die Flag auf False sozusagen, für weitere Missionen, richtig?

[stahli]

Ja richtig.

Deine Prozedur könnte so aussehen:

Delphi-Quellcode:

procedure SpielerZieht(var XYZ: Boolean; LP: Integer);
begin
  ...
  if SpieleristTot then
    XYZ := True;
end;

Du solltest alle benötigten Variablen in der Prozedur übergeben. Sollen veränderte Werte zurückgegeben werden können, muss man sie mit "var" definieren.
Wie die Parameter der Prozedur benannt sind, ist dabei egal. XYZ wäre natürlich trotzdem nicht sinnvoll.

[Doenercola]

Alles klar DAnkeschön! :) Ihr glaubt garnet wie sehr ihr mir geholfen habt :) Ich mach mich gleich dran und meld mich morgen nochmal obs geklappt hat, Danke! :)

[Doenercola]

Ich hab ein wenig rumprobiert aber es will noch net so recht klappen :( Er lässt den Gegner nicht angreifen. Der Spieler greigt die ganze Zeit den Gegner an. Wenn ich in der Schleife nur die GegnerZieht Prozedur drinnen habe verliere ich, wenn ich beide verschiedene Prozeduren drinnen habe gewinne ich immer, egal wie ich es drehe.

Alle Variablen hab ich mal der Einfachheit halber Global gesetzt, bis auf die Flag und die Abbruchbedingung in der SChleife.

Delphi-Quellcode:

procedure SpielerZieht(var Ende : Boolean);
begin
 GegnerLP := GegnerLP - SpielerAP;  // Kampf
 Rundenzahl := Rundenzahl + 1;
        if GegnerLP <= 0 then
        begin
          Ende := True;  // Abbruchbedingung auf True setzen
          Gold := Gold + ((Stufe * 30) * GoldMultiplikator);  // Goldbelohnung
          SpielerLP := Lebenspunkte;  // Lebenspunktevariable mit dem Wert der SpielerLP Variable überschreiben
          Form1.Pnl_Lebenspunkte.Caption := IntToStr(Lebenspunkte);  // LP-Anzeige aktualisieren
          Aktionspunkte := Aktionspunkte - 20;  // AP abziehen
          Form1.Pnl_Aktionspunkte.Caption := IntToStr(Aktionspunkte);  // AP-Anzeige aktualisieren

          Form1.Memo_Textausgabe.Text := Form1.Memo_Textausgabe.Text +        // Informationen über Kampf ausgeben
                                 'Du hast den Kampf nach ' +
                                 IntToStr(Rundenzahl) +
                                 ' Runden gewonnen. :) Nach dem Kampf hast Du noch ' +
                                 IntToStr(SpielerLP) + ' Lebenspunkte und ' +
                                 IntToStr(Aktionspunkte) + ' Aktionspunkte übrig.';
        end;
end;

procedure GegnerZieht(var Ende : Boolean);
begin
  SpielerLP := SpielerLP - GegnerAP;  // Kampf
  Rundenzahl := Rundenzahl +1;
     if SpielerLP <= 0 then                                                 // Was passiert wenn SpielerLP <= Null sind
     begin
       Ende := True;                                                       // Abbruchbedingung auf True setzen
       Lebenspunkte := 1;     // LP auf 1 setzen
       Form1.Pnl_Lebenspunkte.Caption := IntToStr(Lebenspunkte);   // LP-Anzeige aktualisieren
       Aktionspunkte := Aktionspunkte - 20;   // AP abziehen
       Form1.Pnl_Aktionspunkte.Caption := IntToStr(Aktionspunkte);  // AP-ANzeige aktualisieren
       Form1.Memo_Textausgabe.Text := Form1.Memo_Textausgabe.Text +       // Informationen über Kampf ausgeben
                                 'Du hast den Kampf nach ' +
                                 IntToStr(Rundenzahl) +
                                 ' Runden verloren. :( Der Gegner hatte noch  ' +
                                 FloatToStr(GegnerLP) + ' Lebenspunkte übrig.';
     end;
end;


procedure TForm1.BitBtn_AngriffClick(Sender: TObject);
var Ende, SpielerIstAmZug : Boolean;
begin

if Aktionspunkte > 20 then
  begin
    Ende := False;  // Abbruchbedingung noch nicht gegeben
    SpielerIstAmZug := True;  // Flag auf True setzen
    GegnerLP  := 20*Stufe*GegnerLP_Multiplikator+20;  // LP des Gegners berechnen
    GegnerAP  := random(Stufe*10)+ (Stufe*5);  // Angriffspunkte des Gegners erechnen
    SpielerLP := Lebenspunkte;  // Variable für SpielerLP zuweisen
    SpielerAP := random(Max_Schaden) + Min_Schaden;  // Zufallswert zwischen max Schaden und min Schaden des Spielers
    showmessage(FloatToStr(GegnerLP));  // Nur Information, ANzeige der GegnerLP

  repeat  // Schleife initiieren
    if SpielerIstAmZug then  // Wenn Flag auf True steht dann...
    begin
      GegnerZieht(Ende);
    end
    else  // Wenn Flag nicht auf True steht dann...
    begin
      SpielerZieht(Ende);
    end;
    SpielerIstAmZug := not SpielerIstAmZug;  // Flag auf False setzen
  until Ende;  

  Rundenzahl := 0;  // Rundenzahl auf 0 setzen
  end;
end;

[stahli]

Hast Du mal einen Haltepunkt gesetzt und den Ablauf schrittweise verfolgt?
M.E. müssten die Funktionen abwechselnd aufgerufen werden (wobei man als Nutzer davon natürlich nichts weiter merkt, da ja nur Variableninhalte geändert werden.

Von der Logik her würde ich die Funktionen tauschen:

Delphi-Quellcode:

  repeat // Schleife initiieren
    if SpielerIstAmZug then // Wenn Flag auf True steht dann...
    begin
      GegnerZieht(Ende); // Spieler sollte ziehen
    end
    else // Wenn Flag nicht auf True steht dann...
    begin
      SpielerZieht(Ende); // Gegner sollte ziehen
    end;

Oder das Flag sollte GegnerIstAmZug heißen.