hi leutz!

ich (versuche) gerade ein kleines RPG zu programmieren und hänge bei der Karte fest:

Ich benutze (Un)DelphiX und möchte ja eine Karte auf dem Bildschirm zaubern...
Nur... wie mache ich es, dass die Karte flüssig (also "pixelweise") "weiterscrollt", wenn ich in eine Richtung gehe?
Ich hab bei meiner "alten Karte" das so gemacht, dass es einfach 1 Tile (32x32) weiterscrollst, was aber primitiv, ruckelhaft und außerdem doof aussieht - und trotzdem hab ich nur eine FPS von 7-8!

prinzip:
man klickt auf ein feld und auf dieses soll der Charakter dann laufen. mmh...
gut, das wegesuchsystem muss wohl dan in einen eigenen thread, solange ich es nicht verstehe, aber das "1 Tile weiterbewegen und zwar flüssig" bleibt mir eben ein rätsel...

Du zeichnest die Tiles mit einem Offset von z.B. 0 bis 32 Pixeln (so breit ist ein Teil) und danach setzt du dann die Tiles eine komplette Position weiter.

Eigentlich ganz einfach

Gruß Igotcha

ja, das ist mir schon klar, nur wie soll ich das bewerkstelligen und das auch noch ohne verlust der prformance?

Also, da das eine Basisfrage von Tile-Scrolling-Lösungen ist, solltest Du erstmal googlen.

Aber in Kurzform so:

- Du hast ein Array mit der Map
- z.B. ist ein Tile 32x32 Pixel groß
- die in jedem Durchlauf zu zeichnende Map hat oben, unten, links und rechts jeweils eine zusätzliche Tilereihe, die man erstmal nicht sieht (der zu zeichnende Teil ist ein Ausschnitt aus dem Maparray)
- Du startest bei "vollen" Positionen, also erstes Tile bei x=0, nächstes bei x=32, etc.
- bewegt sich jetzt Deine Figur bzw. Deine Map, zeichnest Du alle Tiles (auch die unsichtbaren) mit dem entsprechenden Offset - also z.B. (2 Tiles) Tile[1] X=0-1, Tile[2] X=32-1 etc.
- hast Du einen vollen Tiledurchlauf (also 32 Pixel in diesem Beispiel) setzt Du den Offset auf 0 und jetzt das Wichtigste die zu zeichnenden Tiles im Array eins weiter. In dem Beispiel wird dann daraus: Tile[2] X=0 und Tile[3] X=32

Ich hoffe, Du verstehst: Im Offsetzzyklus verschiebst Du die aktuellen Tiles der Map, ist dieser Zyklus durch, änderst Du die anzuzeigenden Tiles um 1.

Gruß Igotcha

Ohne jetzt hier vom Thema abkommen zu wollen, aber wenn du OpenGL benutzt kannst du soetwas innerhalb von Wenigen Minuten Coden( Feld + Flüssige Scollen ) und zusätzlich ist das ganze noch Recht Konfortabel!

danke!

jetzt muss mir nur mehr erklärt werden, wie ich dann den offset zeichne und nicht immer die "kompletten" tiles

wie zeichnest du denn jetzt? auf ein image? in eine paintbox? per draw? per btiblt?

EDIT: ach so es geht um DelphiX... äh... da gibts doch sicher auch sowas wie draw?

Zitat von Master_RC:

danke!

jetzt muss mir nur mehr erklärt werden, wie ich dann den offset zeichne und nicht immer die "kompletten" tiles

Na indem du beim Zeichnen nicht immer nur in Vielfachen von 32 verschiebst, sondern auch mit den Zwischenwerten.

Am besten machst du es so: Du hast ein 2D-Array, das dein Spielfeld darstellt. Wenn jedes Feld 32x32 Pixel groß ist, und du z.B. 128 Felder in beide Richtungen hast, ist dein Spielfeld umgerechnet 4096x4096 Pixel groß. Den aktuellen Bildschirmausschnitt gibst du dann mit der linken oberen Koordinate des Bildschirms an.

Beispiel: Nehmen wir an, die linke obere Ecke des Bildschirms befindet sich an der Position ViewTopLeft = (1500/2700). Daraus berechnest du, welche Felder gezeichnet werden müssen:

markieren

Delphi-Quellcode:

  TileLeft := Trunc(ViewTopLeft.X / 32.0);
  TileTop := Trunc(ViewTopLeft.Y / 32.0);
  LeftOffset := ViewTopLeft.X mod 32;
  TopOffset := ViewTopLeft.Y mod 32;

Jetzt weißt du, dass du die Felder im Array ab den Indizes (TileLeft/TileTop) zeichnen musst, und davon noch LeftOffset bzw. TopOffset abziehen musst.

Die Zeichenroutine könnte so aussehen, wenn du ein TImage (Image1) als Zeichenfläche verwendest:

markieren

Delphi-Quellcode:

  for i := 0 to 20 do begin
    if i > MapWidth-1 then Continue;
    for j := 0 to 16 do begin
      if j > MapHeight-1 then Continue;
      BitBlt(Image1.Picture.Bitmap.Canvas.Handle,
             i * 32 - LeftFrac, j * 32 - TopFrac, 32, 32,
             Bitmaps[Map[BlockLeft+i, BlockTop+j]].Canvas.Handle,
             0, 0, SRCCOPY);
    end;
  end;

MapWidth ist die Breite der Karte, also z.B. 128 Felder. MapHeight analog dazu.
Map ist das 2D-Array der Karte, das Integers enthält. Dabei steht z.B. 0 für Wasser, 1 für Gras, 2 für Wege, etc.
Bitmaps ist ein Array aus Bitmaps, das die Bilder enthält, die schließlich gezeichnet werden.

mensch, ihr müsst doch programmierer sein

Vielen Dank!
In den meisten Schritten kapier ich dein Beispiel!
Ich kann es leider nur grade net ausprobieren, weil ich in der Schule bin und net zu Hause.

PS:
ja, ich benutze (Un)DelphiX; OpenGL muss ich mir mal anschauen... vlcht.

zum Beispiel:
wenn Bitmaps nun eine Variable ist, dann kann ich ja dann genauso das - mist, der name fällt mir grad net ein - "Picture-Array-Komponente" von DelphiX verwenden, oder?