Irgendwo ein Rechenfehler

[bl4ckb1rd]

Ich programmier gerade ein spiel wo sich rote punkte auf mich zu bewegen und ich diese abknallen kann. Wenn ich wohin click, entsteht eine weisse linie. Kreuzt die Linie einen Roten Punkt so soll dieser verschwinden. Problem dabei ist das ist viele rote Punkte hab. Nun hab ich eine For schleife geschrieben die sich auf meiner weissen geraden (schusslinie) bewegt und dabei überprüft ob jetzt direkt daneben ein roter pixel da ist, hat sie einen gefunden, so berechne ich die strecke zwischen dem punkt wo sich gerade die for schleife auf der schusslinie befindet und allen mittelpunkten der roten punkte. Bei 100 punkten habe ich nun 100 verschiedene strecken. Nun nehme ich einfach die kürzeste strecke, schau welche punkt diese strecke habe, übermal ihn, und entfern ihn aus der 'bot'-Liste damit er nicht mehr gezeichnet wird. Hoffe ihr konntet mir folgen o.O

Leider verschwindet bei mir nicht genau der punkt der 'angeschossen' wurde sondern irgendein anderer o.O

Code-Abschnitt der For-Schleife die nach roten pixeln sucht und den besitzter des Pixels eliminiert/eliminieren sollte:

Delphi-Quellcode:

for I2 := msx1 to x1 do begin    // msx1 = anfang der weißen linie   x1 = ende der weißen linie
    posy:=steigung*I2+c;   // y-wert der weißen linie an position I2, also die funktion der linie ;)



      if image1.Canvas.Pixels[round(I2+1),round(posy-1)] = clred then begin   //wenn ein roter kreis überschnitten wurde
        {bottimer.Enabled := false;}       // unwichtig
        image1.Canvas.Pen.Color := cl3DDkShadow;
        image1.Canvas.brush.Color := cl3DDkShadow;
           //puyt1[I] gleich strecke von bot zu punkt
        for I := 1 to bots do begin          // bots = anzahl aller bots
          pyt1[I] := sqrt(((I2-botkx[I])*( I2-botkx[I])) + (posy -botky[I])*(posy-botky[I]));   //mit satz des pytagoras berechne ich die strekcne zwischen botmittelpunkt und weißer linie wo der rote pixel entdeckt wurde. botkx = x-wert des bots, botky = y-wert des bots 
        end;

            //strecken zwischen speichern
        for I := 1 to bots do begin

          pyt2[I] := pyt1[I];    //bevor alle strecken sortiert werden, kurz zwischen speichern

        end;
              // pyt[1] gleich kleinste strecke
        repeat                 //sortiert wird mit bubblesort, fand es unkompliziert^^ ist zwar bisschen lahm aber schnell hingeschrieben :P
          getauscht := false;
          for I :=1 to bots - 1 do begin
            if pyt1[I] > pyt1[I+1] then begin
              pyt4 := pyt1[I];
              pyt1[I] := pyt1[I+1];
              pyt1[I+1] := pyt4;
              getauscht := true;
            end;
          end;
        until getauscht = true;

        for I := 1 to bots do begin

        if pyt1[1] = pyt2[I] then begin                  // hier schaue ich welcher bot die kürzeste strecke hat und übermal ihn dann.


        image1.Canvas.ellipse(botkx[I]-10,botky[I]-10,botkx[I]+10,botky[I]+10);
        soundtimer.Enabled := true;
        zw1 := botky[I];
        zw :=  botkx[I];
        botkx[I] := botkx[bots];         // da der bot nicht mehr gezeichnet werden soll, wird er ans ende der bot liste geschoben, 
        botky[I] := botky[bots];         // und die liste um 1 verkleinert, so wird der 'tote' bot nicht mehr neu gezeichnet
        botky[bots] := zw1;
        botkx[bots] := zw;
        bots := bots-1;
        exit;        // da der bot aus mehreren roten pixeln besteht und die for schleife nicht jedes mal ihn eliminieren soll,
// soll hier die schleife beendet werden, ist zwar nicht die beste möglichkeit dies zu tun, leider fällt mir grad nix besseres ein o.O
        end;
        end;


      end;

    end;

Falls ihr mein Problem immer noch nicht verstanden habt, oder ihr hier keinen fehler seht, kann ich euch den ganzen quelltext (690 zeilen o.O) geben. Wäre aber nicht so toll weil ihr euch evt. dort gar nicht zurecht finden würdet^^

[edit=mkinzler]Tag korrigiert Mfg, mkinzler[/edit]

[Noedel]

mal uns lieber ein Bild^^

[quendolineDD]

Da ich nicht durch deinen Code jetzt so schnell Blicke, wäre es doch gut zu wissen, wie groß die Abweichung ist. Wenn du noch debugen würdest und dir dann die Werte anschaust, dürfte dir doch auffallen, ab welcher Stelle der Fehler auftritt.

Nebenbei möchte ich noch anmerken, dass das Prüfen auf TRUE und FALSE schlimme Folgen haben kann.
Mach lieber repeat ... until getauscht; Edit:
Da ich gerade sehe, das du eine for-Schleife UND eine Fußgesteuerte Schleife verwendest, wäre es wohl besser dich selber auf eine zu beschränken
Entweder, du nimmst die for-Schleife in Verbindung mit Exit, oder eine FußgesteuerteSchleife mit einem Boolschen Ausdruck.

[mquadrat]

Wie sicher biste dir mit dem Sortierer?

[bl4ckb1rd]

ziemlich sicher den diesen hatten wir mal in der schule benutzt und er hat dort auch funktioniert

[Satty67]

Ich glaube Deine BubbleSort Routine ist mangelhaft, zumindest im Nachbau funktionierte es nicht.

Hier mal der Nachbau, der aber mit ein paar Änderungen funktioniert:

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
const
  pyt1 : array[1..10] of Byte = (4,7,2,9,4,1,0,8,3,5);
var
  pyt4 : Byte;
  i, bots : Integer;
  getauscht : Boolean;
begin
  // Init
  bots := High(pyt1);
  ListBox1.Clear;
  ListBox1.Items.Add('Items: '+IntToStr(bots));

  // Bubblesort
  repeat
    getauscht := false;
    for i := 1 to bots - 1 do begin
      if pyt1[i] > pyt1[i+1] then begin
        pyt4 := pyt1[i];
        pyt1[i] := pyt1[i+1];
        pyt1[i+1] := pyt4;
        getauscht := true;
      end;
    end;
    dec(bots); // Laut Pseudocode Max -1

  until (not getauscht) and (bots < 2); // Laut Pseudocode Abbruch bei "Nicht getauscht" und "Liste fertig"

  // Zum Prüfen des Ergebnis
  for i := 1 to High(pyt1) do
    ListBox1.Items.Add(IntToStr(pyt1[i]));

Im Pseudocode steht ja am Ende "solange vertauscht und n >= 1". Da Delphi aber auf "solange nicht" prüft, müssen beide Bedingungen negiert geprüft werden. Zudem muss nach Durchlauf einer Schleife der Zeiger auf das letzte Listen-Element decrementiert werden.