Pac-Man Hilfe

[Mavarik]

Zitat von Bjoerk:

Als "mitlesendender 10%-Profi" frage ich mich, weshalb diese Zwischenzustände?

Flüssigere Bewegungen...

[Popov]

Ich denke die Tipps bis jetzt sind klein wenig zu gut gemeint. Das sind Anfänger, ich denke nicht, dass sie Kollisionen prüfen wollen oder auf flüssige Bewegungen aus sind. Ich kann mich aber auch irren.

@TE

Jeder der so ein Schulprojekt anfängt stürmt zuerst auf das DrawGrid. Mit Bitmap kann man das übrigens genauso leicht lösen.

Zu dem eigentlichen Thema. Ich hab mal damals mit C64 ein Spiel gespielt, das ein sehr simples wie einfaches Konzept hatte. Es sah ganz normal aus, man bewegte sich in einem sehr großem Labyrinth, der Bildschirm hat immer nur ein Teil davon angezeigt. Es gab frei Flächen, Wände, Wände die man weg ballern konnte, usw.

Das interessante war aber die Mappe. Das war nicht eine große gezeichnete Grafik, das war eine Textdatei, wie z. B. diese hier.

Code:

ammmmmmmmmmmmb
mggggggggggggm
mgmmmmmgmmmmmm
mgggmmmggggggm
mmmgmmmgmmmmgm
mggggggggggggm
cmmmmmmmmmmmmd

Sie bestand aus lauter Buchstaben und Zahlen. Das Geniale dabei war nun, dass jeder Buchstabe für eine kleine Grafik stand (nennen wir sie mal Symbole). Alle Symbole waren gleich groß und jeder Buchstabe stand für einen Symbol.

Wenn also gezeichnet wurde, wurde im Speicher geguckt für was (um mal bei dem oberen Beispiel zu bleiben) g steht. Und dann wurde statt g eben das Symbole gezeichnet. Das war also eine simple Methode um aus einer kleinen Textdatei eine gewaltige Grafik-Mappe zu erstellen.

Was dieses Konzept nun möglich macht ist, die Mappe zu verändern. Bleiben wir bei PackMan. Hier könnte g für einen Punkt stehen. Hat PackMan den Punkt gefressen, wird g durch ein h ersetzt. Und h ist ein Symbol ohne den Punkt. Man ersetzt einfach g durch h und das Programm erledigt den Rest. Denn nun zeichnet das Programm die Grafik neu und zeichnet anstelle des Symbols für g, das Symbol für h.

Hier ein zwei Beispiele. Das erste nur mit Bitmap, dann habe ich noch ein Beispiel für DrawGrid gemacht:

[Zwinge112]

Danke für die viele Hilfe, ich versuche es weiter und hänge den Quellcode mal noch an.

[Popov]

@Zwinge112

Ich hab da kurz reingeschaut und gebe zu meine Schwierigkeiten gehabt zu haben euer Konzept zu verstehen. Ihr habt anscheinend einen StringGrid für die Mauern und ein für Packman wo der war. Beide StringGrids nutzt ihr eigentlich nur als Speicher. Dann übertragt ihr den Packman aus der Position des zweiten StringGrids auf die Image. Die Wände in der Image haben aber anscheinend nichts mit dem ersten StringGrid für Wände zu tun, bzw. die Werte sind von Hand eingetragen und entsprechen in etwa denen auf der Image. Und nun versucht ihr alles zu koordinieren. Erste StringGrid, zweite StringGrid und die Image.

Und wie ich es nun verstehe möchtest du wissen wie du auch noch die Punkte da in das Spiel bringst. Dazu brauchst du eigentlich eine dritte StringGrid.

Ich will eure bisherigen Programmierleistungen nicht schmälern, ihr habt vielleicht ein sonderbares Konzept, aber zumindest viel geschafft. Das Problem ist, dass ihr es etwas kompliziert macht. Aus eurer Sicht habt ihr vermutlich den einfachsten Lösungsansatz genommen, wobei StringGrid als Datenspeicher zu nutzen logisch erscheint, aber das rächt sich im weiteren Verlauf. Denn nun braucht ihr einen weitere StringGrid für andere Daten und nun eigentlich noch mal welche für wieder neue Daten.

Wenn ich nun sehe, dass ihr sogar eine Klasse entwickelt habt, frage ich mich wieso ihr einen so komplizierten Weg über die StringGrids geht? Warum löst ihr das alles nicht über einen Array Record?

Delphi-Quellcode:

type
  TPacLaby = record
    Wand: Integer;     //Hier die Wand programmieren
    Besucht: Integer;  //Hier vermerken wo PacMan schon war
    Punkte: Integer;   //Hier Punkte setzen, die PackMan schluckt. Wobei...
                       //wo Packman schon war, da sind auch die Punkte weg.
                       //Somit sind Punkte überall da wo Packman noch nicht war.
  end;

var
  PacLaby: array[0..23, 0..23] of TPacLaby;

procedure TForm1.FormCreate(Sender: TObject);
begin
  PacLaby[0, 0].Wand := 1;
  //...
end;

[DeddyH]

Oder vielleicht so in der Art:

Delphi-Quellcode:

const
  FELDER_X = 24;
  FELDER_Y = 24;
  
type
  TFeldZustand = (dtNix, dtWand, dtPunkt, dtGeist, dtPacman);
  
  TSpielfeld = array[0..FELDER_X - 1, 0..FELDER_Y - 1] of TFeldzustand;

[BadenPower]

Einmal abgesehen von besseren Lösungswegen.

Unverständlich ist auch, weshalb das Grid "FeldPac" 24x24 Felder besitzt aber das Grid "FeldMauer" 47x47.

Im Prinzip fehlt auch ein wirkliches Spielfeld, welches nach den Angaben in den Grids dynamisch gezeichnet/aufgebaut wird.

[Bjoerk]

Was ich ebenfalls vermisse ist das Konzept. Das könnte z.B. in etwa so aussehen (Siehe unten). Bin mir aber nicht sicher, zum Beispiel Sir Rufo kann doch sowas normalerweise immer recht gut.

Delphi-Quellcode:

unit uPacMan;

interface

uses
  Types, SysUtils, Dialogs, Classes, Graphics;

type
  TPacManStyle = (pmsPacMan, pmsRedGuy, pmsPinkGuy, pmsCyanGuy, pmsOrangeGuy);

  TPacManPowerStyle = (pmpDefault, pmpPower);

  TPacManOrientation = (pmoCenter, pmoLeft, pmoRight, pmoTop, pmoBottom);

  TPacManGuy = class
  private
    FStyle: TPacManStyle;
    FPowerStyle: TPacManPowerStyle;
    FOrientation: TPacManOrientation;
    FX, FY: integer;
  public
    property Style: TPacManStyle read FStyle write FStyle;
    property PowerStyle: TPacManPowerStyle read FPowerStyle write FPowerStyle;
    property Orientation: TPacManOrientation read FOrientation write FOrientation;
    property X: integer read FX write FX;
    property Y: integer read FY write FY;
  end;

  TPacManGuys = array[TPacManStyle] of TPacManGuy;

  TPacManCellStatus = (pmcEmpty, pmcWall, pmcPellet, pmcPowerPellet,
    pmcPacMan, pmcRedGuy, pmcPinkGuy, pmcCyanGuy, pmcOrangeGuy);

  TPacManCell = class
  private
    FX, FY, FWidth, FHeight: integer;
    FStatus: TPacManCellStatus;
  public
    procedure Draw(Canvas: TCanvas; Bitmap: TBitmap);
    property X: integer read FX write FX;
    property Y: integer read FY write FY;
    property Width: integer read FWidth write FWidth;
    property Height: integer read FHeight write FHeight;
    property Status: TPacManCellStatus read FStatus write FStatus;
  end;

  TPacManGrid = class
  private
    FColCount, FRowCount: integer;
    FCells: array of array of TPacManCell;
    function GetCell(X, Y: integer): TPacManCell;
  public
    property Cell[X, Y: integer]: TPacManCell read GetCell; default;
    property ColCount: integer read FColCount;
    property RowCount: integer read FRowCount;
    constructor Create(const ColCount, RowCount, Width, Height: integer);
    destructor Destroy; override;
  end;

  TPacManGame = class
  private
    FGuys: TPacManGuys;
    FGrid: TPacManGrid;
    function GetGuy(Style: TPacManStyle): TPacManGuy;
  public
    property Guy[Style: TPacManStyle]: TPacManGuy read GetGuy;
    property Grid: TPacManGrid read FGrid;
    constructor Create(const ColCount, RowCount, Width, Height: integer);
    destructor Destroy; override;
  end;

implementation

{ TPacManCell }

procedure TPacManCell.Draw(Canvas: TCanvas; Bitmap: TBitmap);
var
  Rect: TRect;
begin
  Rect.Left := FX * FWidth;
  Rect.Top := FY * FHeight;
  Rect.Right := Rect.Left + FWidth;
  Rect.Bottom := Rect.Top + FHeight;
  Canvas.MoveTo(Rect.Left, Rect.Top);
  Canvas.LineTo(Rect.Right, Rect.Top);
  Canvas.LineTo(Rect.Right, Rect.Bottom);
  Canvas.LineTo(Rect.Left, Rect.Bottom);
  Canvas.LineTo(Rect.Left, Rect.Top);
  if Bitmap <> nil then
  begin
    Rect.Left := Rect.Left + 4;
    Rect.Top := Rect.Top + 4;
    Rect.Right := Rect.Right - 4;
    Rect.Bottom := Rect.Bottom - 4;
    Canvas.StretchDraw(Rect, Bitmap);
  end;
end;

{ TPacManGrid }

constructor TPacManGrid.Create(const ColCount, RowCount, Width, Height: integer);
var
  X, Y: integer;
begin
  FColCount := ColCount;
  FRowCount := RowCount;
  SetLength(FCells, FColCount, FRowCount);
  for X := 0 to FColCount - 1 do
    for Y := 0 to FRowCount - 1 do
    begin
      FCells[X, Y] := TPacManCell.Create;
      FCells[X, Y].X := X;
      FCells[X, Y].Y := Y;
      FCells[X, Y].Width := Width div ColCount;
      FCells[X, Y].Height := Height div RowCount;
    end;
end;

destructor TPacManGrid.Destroy;
var
  X, Y: integer;
begin
  for X := 0 to FColCount - 1 do
    for Y := 0 to FRowCount - 1 do
      FCells[X, Y].Free;
  SetLength(FCells, 0);
  inherited;
end;

function TPacManGrid.GetCell(X, Y: integer): TPacManCell;
begin
  Result := FCells[X, Y];
end;

{ TPacManGame }

constructor TPacManGame.Create(const ColCount, RowCount, Width, Height: integer);
var
  Style: TPacManStyle;
begin
  FGrid := TPacManGrid.Create(ColCount, RowCount, Width, Height);
  for Style := pmsPacMan to pmsOrangeGuy do
  begin
    FGuys[Style] := TPacManGuy.Create;
    FGuys[Style].Style := Style;
  end;
end;

destructor TPacManGame.Destroy;
var
  Style: TPacManStyle;
begin
  FGrid.Free;
  for Style := pmsPacMan to pmsOrangeGuy do
    FGuys[Style].Free;
  inherited;
end;

function TPacManGame.GetGuy(Style: TPacManStyle): TPacManGuy;
begin
  Result := FGuys[Style];
end;

end.

[Zwinge112]

@Popov,
Warum wir über die StringGrids gehen weiß ich auch nicht genau.. ich hab den Plan nicht gemacht....
Kannst du mir nen Tipp geben, wie ich es mit Hilfe eines StringGrids bewältigen Könnte die Punkte rein zu bekommen?

[DeddyH]

Dann würde ich mit den anderen sprechen, ob man wirklich unbedingt ein StringGrid benutzen will. Es macht ja keinen Sinn, etwas mit Gewalt umsetzen zu wollen, was sich im Nachhinein als zu umständlich erweist.

[Zwinge112]

naja das Problem hierbei ist, dass die anderen ihre Teile alle schon fertig haben.... nur meiner mit den Punkten fehlt jetzt noch......