Neue Frage zu Snake

[TaIPaN]

Hi Leute^^ habe auch mal eine Frage zu Snake... (mal wieder Wink )
Also wir haben in der Schule unglücklicherweise einen kleinen Anfang zu Snake bekommen der blöderweise vollkommen anders aussieht,
wie alles was bisher zu diesem Thema hier erörtert wurde, weswegen ich nun das Problem habe, dass ich leider durch lesen der sourcecodes auch nicht weiter komme... Sad
ALso meine Schlange kann:
1. Fressen(Apfel)
2. Durch Wände gehen(findich cooler wie dabei zu sterben^^)
3. Score wird gezählt
4. Richtungswechsel wie Rechts==>Links, Hoch==>Runter gehn nich

Mein großes Problem ist: Ich bekomme es einfach nicht gebacken, dass meine Schlange beim Fressen eines Apfels länger wird.
Deswegen wollte ich diejenigen die Ahnung haben darum bitten sich meinen Versuch mal anzuschaun und mir zu sagen was ich falsch mache wies richtig geht oder mir einfach einen kleinen Denkanstoß geben^^
Wie ich sehe sind hier ja eindeutig Leute dies echt sau gut drauf haben Smile und würde mich daher echt über eine hilfreiche Antwort freun...


Bin leider wie man sieht alles andere als begabt und hocke nun schon seid mehreren Tagen hilflos vor Delphi und komme einfach nicht weiter... 2Spielermodus, Highscore etc. stelle ich mir da ja um einiges einfacher vor...aber hier bin ich einfach nur aufgeschmissen...

Für die Unordnung die durch exzessives Rumprobiern entstanden ist im Sourcecode willich mich schonmal im Voraus entschuldigen^^

Delphi-Quellcode:

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, ExtCtrls, StdCtrls;

type
  Trichtung = (Hoch,Runter,Links,Rechts);

  TSpielfeld = class(TForm)
    Bild: TImage;
    Timer1: TTimer;
    Panel1: TPanel;
    Label1: TLabel;
    m_start: TMemo;
    l_start: TLabel;
    b_start: TButton;
    Label2: TLabel;
    procedure FormCreate(Sender: TObject);
    procedure Timer1Timer(Sender: TObject);
    procedure FormKeyDown(Sender: TObject; var Key: Word;
      Shift: TShiftState);
    procedure b_startClick(Sender: TObject);
    end;

tsnake = class
  x,y:array[1..100] of integer;
  vx,vy,r,laenge:integer;
  farbe:tcolor;
  richtung:trichtung;
  procedure init(fneu:tcolor; xneu, yneu, vxneu, vyneu, rneu:integer);
  procedure zeigedich;
  procedure bewegedich;
  procedure wachsen;
  end;

tapfel = class
  x,y,r,score:integer;
  farbe:tcolor;
  procedure ini; overload;
  procedure ini(fneu:tcolor; xneu, yneu, rneu:integer); overload;
  procedure zeigediche;
  procedure fressen;
  end;


var
  Spielfeld: TSpielfeld;
   snake    : Tsnake;
   apfel    : Tapfel;
   big      : bool;
implementation

{$R *.dfm}


// -------------------------------------------------------------------------- //
// alle Prozeduren, die ausschließlich mit "Snake" zu tun haben
// -------------------------------------------------------------------------- //
procedure tsnake.init(fneu:tcolor; xneu, yneu, vxneu, vyneu, rneu:integer);
begin
  laenge:= 1;
  farbe:= fneu;
  x[laenge]    := xneu;
  y[laenge]    := yneu;
  vx   := vxneu;
  vy   := vyneu;
  r    := rneu;

end;

procedure tsnake.zeigedich;
var i:integer;
begin
  Spielfeld.Bild.Canvas.Brush.Color:=Farbe;
  for i:=1 to snake.laenge do
  begin
  Spielfeld.Bild.Canvas.Rectangle(x[i], y[i], x[i]+2*r, y[i]+2*r);
  end;
end;

procedure tsnake.bewegedich;
begin

  case snake.richtung of
  Links: begin //Links
    snake.vx:=-1;
    snake.vy:= 0;
    end;

Hoch: begin //Hoch
    snake.vx:= 0;
    snake.vy:= -1;
    end;

Rechts: begin //Rechts
    snake.vx:= 1;
    snake.vy:= 0;
    end;

Runter: begin //Runter
    snake.vx:= 0;
    snake.vy:= 1;
    end;
  end;

  //Bewegungsberechnung
  x[1] := x[1] + 2*r*vx;
  y[1] := y[1] + 2*r*vy;

  if (x[1]>Spielfeld.Bild.Width-2*r) then
  begin
    x[1] := 0;
  end;

  if x[1]<0 then
  begin
    x[1] := Spielfeld.Bild.Width-2*r;
   end;

  if (y[1] > Spielfeld.Bild.Height-2*r) then
  begin
    y[1] := 0;
  end;

  if y[1] < 0 then
  begin
    y[1] := Spielfeld.Bild.Height-2*r;
  end;

end;

//wachsen
procedure Tsnake.wachsen;
var i:integer;
begin
laenge:= laenge +1;
spielfeld.Label2.Caption:='Länge : ' + inttostr(laenge);
//Array erweitern
for i:=1 to laenge do
  begin
  x[i+1]:=x[i];
  y[i+1]:=y[i];
  Spielfeld.Bild.Canvas.Rectangle(x[i], y[i], x[i]+2*r, y[i]+2*r);


  end;
end;

procedure TSpielfeld.FormKeyDown(Sender: TObject; var Key: Word;
  Shift: TShiftState);
begin
  case key of
27:close;

37: begin //Links
    if snake.richtung <> Rechts then snake.richtung:=Links;
    end;
38: begin //Hoch
    if snake.richtung <> Runter then snake.richtung:=Hoch;
    end;
39: begin //Rechts
    if snake.richtung <> Links then snake.richtung:=Rechts;
    end;
40: begin //Runter
    if snake.richtung <> Hoch then snake.richtung:=Runter;
    end;
end;
end;

// -------------------------------------------------------------------------- //
// Alle Prozeduren, die ausschließlich mit "Apfel" zu tun haben
// -------------------------------------------------------------------------- //

procedure tapfel.ini;
begin
  farbe:= clGreen;
  x    := Random(30)*20;
  y    := Random(20)*20;
  r    := 10;
end;

procedure tapfel.ini(fneu:tcolor; xneu, yneu, rneu:integer);
begin                                       //
  farbe:= fneu;
  x    := xneu;
  y    := yneu;
  r    := rneu;
end;


procedure tapfel.zeigediche;                //
begin
  Spielfeld.Bild.Canvas.Brush.Color:=clGreen;
  Spielfeld.Bild.Canvas.ellipse(x, y, x+2*r, y+2*r);
end;

procedure tapfel.fressen;
begin

if (x = snake.x[1]) and (y = snake.y[1]) then

    begin
      score:= score +1;
      spielfeld.label1.caption:='Score : ' + inttostr(score);
      apfel.zeigediche;
      apfel.ini;
      apfel.zeigediche;
      big:= true;
    end;
end;
// -------------------------------------------------------------------------- //
// Durch diese Prozedur wird das Spiel gestartet und der Anfangsbildschirm ausgeblendet
// -------------------------------------------------------------------------- //
procedure TSpielfeld.b_startClick(Sender: TObject);
begin
l_start.Visible:=false;
b_start.Visible:=false;
m_start.Visible:=false;
panel1.Visible:=true;
bild.Visible:=true;
end;

// -------------------------------------------------------------------------- //
// Diese Prozedur bringt die Bewegungs- und Fressprozeduren in Gang(regelmäßig
// -------------------------------------------------------------------------- //

procedure TSpielfeld.Timer1Timer(Sender: TObject);
begin
//spielfeld.Timer1.Enabled:=false;

                   //
snake.zeigedich;
snake.bewegedich;
snake.zeigedich;
apfel.fressen;
if big = true then
begin
snake.wachsen;
big:= false;
end;
//spielfeld.Timer1.Enabled:=true;
end;

// -------------------------------------------------------------------------- //
// Alles was von Anfang an existieren soll ist hier aufgeführt
// -------------------------------------------------------------------------- //

procedure TSpielfeld.FormCreate(Sender: TObject);
begin                                //
  with bild.Canvas do
  begin
  pen.Width:=5;
  Brush.Color:=clWhite;
  Brush.Style:=bsSolid;
  Pen.Width:=2;
  Pen.Mode:=pmNOTXOR;

  Rectangle(0,0,Bild.width,Bild.Height);
  end;

  snake.init(clRed, Random(30)*20, Random(20)*20,0,0,10);
  snake.zeigedich;
  apfel.ini;
  apfel.zeigediche;
end;

initialization                      //
  randomize;
  snake := tsnake.Create;
  apfel := tapfel.Create;
  big:= false;
end.

In Hoffnung auf hilf- und lehrreiche Antwort(en)

mfg Taipi

[edit=alcaeus]Delphi-Tags eingefuegt. In Zukunft solche grossen Codestuecke bitte anhaengen. Mfg, alcaeus[/edit]

[vlees91]

setze doch bitte die [delphi] tags, dann sieht der code schöner aus und ich (ich denke auch andere) mache mir die mühe ihn mir durchzulesen

[TaIPaN]

Delphi-Quellcode:

unit Unit1;

interface

uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, ExtCtrls, StdCtrls;

type
Trichtung = (Hoch,Runter,Links,Rechts);

TSpielfeld = class(TForm)
Bild: TImage;
Timer1: TTimer;
Panel1: TPanel;
Label1: TLabel;
m_start: TMemo;
l_start: TLabel;
b_start: TButton;
Label2: TLabel;
procedure FormCreate(Sender: TObject);
procedure Timer1Timer(Sender: TObject);
procedure FormKeyDown(Sender: TObject; var Key: Word;
Shift: TShiftState);
procedure b_startClick(Sender: TObject);
end;

tsnake = class
x,y:array[1..100] of integer;
vx,vy,r,laenge:integer;
farbe:tcolor;
richtung:trichtung;
procedure init(fneu:tcolor; xneu, yneu, vxneu, vyneu, rneu:integer);
procedure zeigedich;
procedure bewegedich;
procedure wachsen;
end;

tapfel = class
x,y,r,score:integer;
farbe:tcolor;
procedure ini; overload;
procedure ini(fneu:tcolor; xneu, yneu, rneu:integer); overload;
procedure zeigediche;
procedure fressen;
end;


var
Spielfeld: TSpielfeld;
snake : Tsnake;
apfel : Tapfel;
big : bool;
implementation

{$R *.dfm}


// -------------------------------------------------------------------------- //
// alle Prozeduren, die ausschließlich mit "Snake" zu tun haben
// -------------------------------------------------------------------------- //
procedure tsnake.init(fneu:tcolor; xneu, yneu, vxneu, vyneu, rneu:integer);
begin
laenge:= 1;
farbe:= fneu;
x[laenge] := xneu;
y[laenge] := yneu;
vx := vxneu;
vy := vyneu;
r := rneu;

end;

procedure tsnake.zeigedich;
var i:integer;
begin
Spielfeld.Bild.Canvas.Brush.Color:=Farbe;
for i:=1 to snake.laenge do
begin
Spielfeld.Bild.Canvas.Rectangle(x[i], y[i], x[i]+2*r, y[i]+2*r);
end;
end;

procedure tsnake.bewegedich;
begin

case snake.richtung of
Links: begin //Links
snake.vx:=-1;
snake.vy:= 0;
end;

Hoch: begin //Hoch
snake.vx:= 0;
snake.vy:= -1;
end;

Rechts: begin //Rechts
snake.vx:= 1;
snake.vy:= 0;
end;

Runter: begin //Runter
snake.vx:= 0;
snake.vy:= 1;
end;
end;

//Bewegungsberechnung
x[1] := x[1] + 2*r*vx;
y[1] := y[1] + 2*r*vy;

if (x[1]>Spielfeld.Bild.Width-2*r) then
begin
x[1] := 0;
end;

if x[1]<0 then
begin
x[1] := Spielfeld.Bild.Width-2*r;
end;

if (y[1] > Spielfeld.Bild.Height-2*r) then
begin
y[1] := 0;
end;

if y[1] < 0 then
begin
y[1] := Spielfeld.Bild.Height-2*r;
end;

end;

//wachsen
procedure Tsnake.wachsen;
var i:integer;
begin
laenge:= laenge +1;
spielfeld.Label2.Caption:='Länge : ' + inttostr(laenge);
//Array erweitern
for i:=1 to laenge do
begin
x[i+1]:=x[i];
y[i+1]:=y[i];
Spielfeld.Bild.Canvas.Rectangle(x[i], y[i], x[i]+2*r, y[i]+2*r);


end;
end;

procedure TSpielfeld.FormKeyDown(Sender: TObject; var Key: Word;
Shift: TShiftState);
begin
case key of
27:close;

37: begin //Links
if snake.richtung <> Rechts then snake.richtung:=Links;
end;
38: begin //Hoch
if snake.richtung <> Runter then snake.richtung:=Hoch;
end;
39: begin //Rechts
if snake.richtung <> Links then snake.richtung:=Rechts;
end;
40: begin //Runter
if snake.richtung <> Hoch then snake.richtung:=Runter;
end;
end;
end;

// -------------------------------------------------------------------------- //
// Alle Prozeduren, die ausschließlich mit "Apfel" zu tun haben
// -------------------------------------------------------------------------- //

procedure tapfel.ini;
begin
farbe:= clGreen;
x := Random(30)*20;
y := Random(20)*20;
r := 10;
end;

procedure tapfel.ini(fneu:tcolor; xneu, yneu, rneu:integer);
begin //
farbe:= fneu;
x := xneu;
y := yneu;
r := rneu;
end;


procedure tapfel.zeigediche; //
begin
Spielfeld.Bild.Canvas.Brush.Color:=clGreen;
Spielfeld.Bild.Canvas.ellipse(x, y, x+2*r, y+2*r);
end;

procedure tapfel.fressen;
begin

if (x = snake.x[1]) and (y = snake.y[1]) then

begin
score:= score +1;
spielfeld.label1.caption:='Score : ' + inttostr(score);
apfel.zeigediche;
apfel.ini;
apfel.zeigediche;
big:= true;
end;
end;
// -------------------------------------------------------------------------- //
// Durch diese Prozedur wird das Spiel gestartet und der Anfangsbildschirm ausgeblendet
// -------------------------------------------------------------------------- //
procedure TSpielfeld.b_startClick(Sender: TObject);
begin
l_start.Visible:=false;
b_start.Visible:=false;
m_start.Visible:=false;
panel1.Visible:=true;
bild.Visible:=true;
end;

// -------------------------------------------------------------------------- //
// Diese Prozedur bringt die Bewegungs- und Fressprozeduren in Gang(regelmäßig
// -------------------------------------------------------------------------- //

procedure TSpielfeld.Timer1Timer(Sender: TObject);
begin
//spielfeld.Timer1.Enabled:=false;

//
snake.zeigedich;
snake.bewegedich;
snake.zeigedich;
apfel.fressen;
if big = true then
begin
snake.wachsen;
big:= false;
end;
//spielfeld.Timer1.Enabled:=true;
end;

// -------------------------------------------------------------------------- //
// Alles was von Anfang an existieren soll ist hier aufgeführt
// -------------------------------------------------------------------------- //

procedure TSpielfeld.FormCreate(Sender: TObject);
begin //
with bild.Canvas do
begin
pen.Width:=5;
Brush.Color:=clWhite;
Brush.Style:=bsSolid;
Pen.Width:=2;
Pen.Mode:=pmNOTXOR;

Rectangle(0,0,Bild.width,Bild.Height);
end;

snake.init(clRed, Random(30)*20, Random(20)*20,0,0,10);
snake.zeigedich;
apfel.ini;
apfel.zeigediche;
end;

initialization //
randomize;
snake := tsnake.Create;
apfel := tapfel.Create;
big:= false;
end.

SRY dassich neu posten musste aber war leider schon zu spät dran...
Vll erbarmt sich meiner ja noch einer^^

mfg taipi

[bttb930]

naja, in wachsen sagst du

Delphi-Quellcode:

for i:=1 to laenge do
begin
  x[i+1] := x[i];
  y[i+1] := y[i];

Danach ist x[2] = x[1] und y[2] = y[1]

das heißt die schlange ist länger geworden, aber zwei felder (1 und 2) liegen übereinander

du musst beim verlängern die bewegung berücksichtigen.

[terryblack]

hi ich muss auch snake in der schule programmieren. mit dem wachsen komm ich auch nich weiter aber ich kann dir zeigen wie man die keys richtig programmiert.

Delphi-Quellcode:

procedure TSpielfeld.FormKeyDown(Sender: TObject; var Key: Word;
  Shift: TShiftState);
begin



case key of
37: begin
    snake.vx:=-1;
    snake.vy:=0;
          end;
38: begin
    snake.vx:=0;
    snake.vy:=-1;
          end;
39: begin
     snake.vx:=1;
     snake.vy:=0;
          end;
40: begin
     snake.vx:=0;
     snake.vy:=1;
          end;
end;
end;

ich werd jedoch weiter dran arbeiten also werd ich eventuell was posten wenn ich es geschafft habe die schlange wachsen zu lassen

gruß terry

[edit=alcaeus]Delphi-Tags gesetzt. Siehe obigen Kommentar von Meflin Mfg, alcaeus[/edit]

[Cöster]

Zitat von TaIPaN:

Delphi-Quellcode:

for i:=1 to laenge do
begin
  x[i+1]:=x[i];
  y[i+1]:=y[i];
  Spielfeld.Bild.Canvas.Rectangle(x[i], y[i], x[i]+2*r, y[i]+2*r);
end;

In dieser Schleife aus TSnake.Wachsen liegt wohl der Fehler: x[2] wird auf x[1] gesetzt. Beim nächsten Durchlauf wird x[3] dann auf x[2] gesetzt, was ja beim vorherigen Durchlauf auf x[1] gesetzt wurde. Am Ende ist also x[1] = x[2] = x[3] = x[Laenge]. Das gleiche gilt natürlich für's y.
Versuchs mal mit einer For-downto-Schleife:

Delphi-Quellcode:

for i := Laenge downto 2 do
begin
  x[i] := x[i - 1];
  y[i] := y[i - 1];
  Spielfeld.Bild.Canvas.Rectangle(x[i], y[i], x[i]+2*r, y[i]+2*r);
end;

[terryblack]

also meine snake wächst jetzt...
jedoch hab ich eine procedur zum zeichnen und eine zum bewgen :

Delphi-Quellcode:

procedure tsnake.zeigedich(Canvas:TCanvas);
var i:integer;
begin
i:=1;
   Canvas.Brush.Color:=Farbe;  // hier wird festgelegt, das snake die farbe "Fkare hat, die wir in der klasse
   for i:=1 to laenge do
     begin
      canvas.Rectangle(x[i],y[i],x[i]+2*r,y[i]+2*r);
      Canvas.Brush.Color:=clgreen;
     end;
end;


// -------------------------------------------------------------------------- //
//               Alle Prozeduren durch diese MArkierung getrennt !!
// -------------------------------------------------------------------------- //
procedure tsnake.bewegedich(Image:TImage);
var i:integer;
begin
for i:=laenge-1 downto 1 do
begin
x[i+1]:=x[i];
Y[i+1]:=y[i];
end;

x[1]:=x[1] + 2*r*vx;
Y[1]:=y[1] + 2*r*vy;


if(x[1]>Image.Width) then //wenn die x-Koordinate(linkes oberes Eck von snake)
begin
x[1] := image.Width-600;    //am rechten Rand steht, soll er snake am linken rand "befördern" ohne richtungswechsel

end;
if x[1]<-2*r then // hier wird snake befohlen, dass wenn er mit seinem durchmesser hinter dem linken rand steht, zum rechten rand befördert wird, ohne richtungswechsel
begin
x[1]:=image.Width-2*r;

end;
if(y[1]> image.Height) then    //bei der folgenden procedure
begin                                   //passiert das selbe wie in der vorrigen
y[1]:=image.height-400;          //mit der Ausnahme das snake hier nicht über den oberen
                             //und unteren rand stoßen kann
end;
if y[1] <-2*r then
begin
y[1]:=image.Height-2*r;

end;
end;

wunder dich nich über die klammern nach den procedures(zb.Canvas:TCanvas), das kommt daher, dass ich mehrere units in meinem programm hab

[edit=Phoenix]Alcaeus hatte Dich im ersten Beitrag schon darauf hingewiesen: Bitte füge bei solchen Coceblöcken selber Delphi-Tags ein! Mfg, Phoenix[/edit]

[Cöster]

Setz deine Codes doch auch mal in ... , dann sind sie viel besser lesbar und dir wird sicher auch jemand helfen.