Pac-Man Hilfe

[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......

[Popov]

Zuerst musst du mir erklären was in den einzelnen StringGrids steht? Wieso ist der eine 24x24 Zellen groß, der andere 48x48?

Ansonsten habe ich dir bereits einen Tipp gegeben: wo PackMan war, da gibt es keine Punkte mehr. Und wenn ich mir das zweite StringGrid angucke, steht da nichts, wo PackMan noch nicht war, 1, wo PackMan gerade ist und 0, wo PackMan schon war. Schlussfolgerung: wo in StringGrid nichts steht, da sind noch Punkte.

Außerdem:

"Warum wir über die StringGrids gehen weiß ich auch nicht genau.. ich hab den Plan nicht gemacht...."

Das ist doch auch dein Projekt, du warst doch bei der Planung dabei.

Aber nur damit du verstehst wie deine Bitte klingt...

"Kannst du mir nen Tipp geben, wie ich es mit Hilfe eines StringGrids bewältigen Könnte die Punkte rein zu bekommen? "

Ich versuche die Bitte mal zu übersetzten. Stellt euch vor ihr währt KFZ-Designer Azubis und ihr hättet die Aufgabe bekommen ein Auto zu bauen. Einer aus euer Gruppe erinnerst sich an seinen Opa, der war Bauer, und im Schuppen steht noch ein Heuwagen. Der hat vier Räder, ein Auto hat auch vier Räder, also ist ein Heuwagen doch schon eine gute Grundlage für ein Auto. Da spart man sich etwas Arbeit, eine Art Karosserie ist da, Räder sind dran, also schon fast ein Auto.

Nun habt ihr die Leitern demontiert und die Deichsel. Ihr habt paar Sitze eingebaut, vielleicht schon eine Lenkvorrichtung, mit der sich die vorderen Räder drehen lassen. Eventuell liegt schon ein alter Dieselmotor vom Schrottplatz schon auf dem Wagen. Und nun kommt ihr mit der Frage, wie man daraus ein Auto machen kann.

Nur damit man das versteht, irgendwas wird man schon daraus machen können, aber der Ansatz ist schwierig. Ihr habt euch am Anfang sehr einfach gemacht und nun wird es schwieriger.