Pac-Man Hilfe

[Zwinge112]

Glück auf,
Wir dürfen gerade in der Schule in Gruppen ein größeres Programm programmieren. Meine Gruppe Hat sich für einen Pac-Man Klon entschieden.
Wir haben uns dafür entschieden, das ganze mit StringGrids zu lösen, über die später dan einfach die Images drüber gelegt werden.
Meine Aufgabe soll es jetzt sein, die Punkte die Pac-Man immer frisst zu programmieren, und ich habe keine Ahnung wie ich das machen soll. (lacht nicht über mich ich bin was das programmieren angeht nicht wirklich begabt.).
Ich hab von der "Grafik-Abteilung" unserer Gruppe das Immage bekommen, das das Fressen von Pac-Man darstellen soll, sowie das fertige Programm, in dem Pac-Man schon durch das Labyrinth laufen kann.
Mein Problem ist jetzt, wie füge ich das "Fressen-Image" ein, und wie mache ich es, dass es gelöscht wird, wenn Pac-Man drüber läuft?
Danke schon mal im Voraus

[BadenPower]

Euer Pacman läuft schon durch Labyrinth. Also muss dieser irgendwo gezeichnet und auch wieder gelöscht werden.

Und genau so machst Du es mit den Punkten und dem Fressen-Bild.

Da wir den QuellCode natürlich nicht kennen können wir Dir auch nichts genaues sagen. Alternativ kannst Du den QuellCode auch als Zip-Datei hier anhängen.

[Sir Rufo]

Ein sportlicher Ansatz mit wenig bis keiner Erfahrung einen Pacman-Klon erstellen zu wollen.

Das mit einem StringGrid zu bewerkstelligen ist noch sportlicher. Es ist nicht unmöglich, genauso wie es nicht unmöglich ist mit Schlittschuhen beim Hamburg-Marathon zu laufen.

Da du anscheinend die Anzeige programmieren sollst brauchst du dich doch gar nicht um das Verschwinden lassen des Punktes zu kümmern. Du fragst den Zustand des Felds ab (Punkt da oder nicht) und dann pinselst du da den Punkt hin oder eben nicht.

[DelphiforNUBS]

also du hast die beiden Bilder: PACMAN & den Punkt...

du musst prüfen ob die beiden Rechtecke sich überschneiden. Das nennt man "bounding-Box-Collision".

also du hast die beiden image-Felder und ihre Koordianten:

wenn jetzt einer der Pacman Eckpunkte innerhalb des andren Images liegt muss der Punkt gefressen werden.
bzw. wenn sie sich überschneiden.

das kann man mit einer for-Schleife realisieren...

1) alle Eckpunkte von pacman durchgehen
--- mit jedem punkt:
prüfe ob pacman.X1 > punkt.X1 und pacman.X1 < punkt.X3

(das musst du dann jedesmal prüfen wenn pacman sich bewegt)

Ist schlampig geschrieben aber Google einfach nach "bounding box collision".

oder schau mal hier https://www.youtube.com/watch?v=8b_reDI7iPM

OOOOOOOOODER:


Wenn das Spielfeld in einem 2D-Array als zahlen angelegt ist (z.b. wände: 1, punkte: 2) dann brauchst du nur prüfen ob Pacman(X,Y) gerade auf einem Feld ist das einen punkt enthält. dann einfach den punkt bei (X,Y) ersetzen.
(das sollte auch eigentlich die zugrundelegende spiellogik darstellen, bounding boxes entfallen dann komplett man hat nur noch die X und Y Koordinaten von Pacman)

Pacman befindet sich zb bei [5,2].
wenn pacman im nächsten schritt nach rechts geht (X+1) dann muss die 2 dort in eine 0 geändert werden.
dann das Array mit for schleifen durchgehen und das Spielfeld neu zeichnen.
dann pacman zeichnen.

die X und Y Koordinaten werden in Bildschirmkoordinaten umgerechnet damit man weiß wo die Bilder zu zeichnen sind
(zb Array[1,1] muss in Pixeln 100,100 sein ... oder Feld[4,2] sind die pixelkoordinaten 400, 200 wenn ein Feld bei euch 100x100 Pixel sein soll)

als Beispiel das Array[X][Y]:

111111111111
100002222221
101000000121
101000000121
101000000121
100000000021
111111111111


viel erfolg

[DeddyH]

Zitat:

Zitat von DelphiforNUBS (Beitrag 1297086)

das kann man mit einer for-Schleife realisieren...

1) alle Eckpunkte von pacman durchgehen
--- mit jedem punkt:
prüfe ob X1 > X2 und X1 < X3

IntersectRect, das ermittelt auch völlige Überlappung (wenn ein Rechteck das andere komplett umschließt).

[BadenPower]

Zitat:

Zitat von DeddyH (Beitrag 1297087)

IntersectRect, das ermittelt auch völlige Überlappung (wenn ein Rechteck das andere komplett umschließt).

Ich glaube kaum, dass das hier zur Anwendung kommen muss, da ich eher vermute, dass dieser Pacman sowieso nur von einer Zelle zur anderen springen wird.

[Mavarik]

Zitat:

Zitat von Sir Rufo (Beitrag 1297073)

Ein sportlicher Ansatz mit wenig bis keiner Erfahrung einen Pacman-Klon erstellen zu wollen.

hmm.. Hände hoch... Welcher der hier mitlesenden Profis würde sich aus dem Handgelenk Pac-Man zutrauen?

Aber bitte in FMX und dann so! // Edit

Und dann für Rookies als Schulprojekt... :stupid: Naja...

Zitat:

Zitat von DelphiforNUBS (Beitrag 1297086)

also du hast die beiden Bilder: PACMAN & den Punkt...

du musst prüfen ob die beiden Rechtecke sich überschneiden. Das nennt man "bounding-Box-Collision".

also du hast die beiden image-Felder und ihre Koordianten:

Lol, klar kann man auch mit Kanonen auf Spatzen schießen...

Ich habe doch alle Koordinaten. also unnötig...

[DeddyH]

Zitat:

Zitat von BadenPower (Beitrag 1297089)

Zitat:

Zitat von DeddyH (Beitrag 1297087)

IntersectRect, das ermittelt auch völlige Überlappung (wenn ein Rechteck das andere komplett umschließt).

Ich glaube kaum, dass das hier zur Anwendung kommen muss, da ich eher vermute, dass dieser Pacman sowieso nur von einer Zelle zur anderen springen wird.

Mir ging es auch eher darum, etwas Fertiges zu verwenden, statt eine fehlerträchtige eigene Lösung anzustreben.

[Sir Rufo]

Pacman benötigt keinerlei Kollision-Detection wo sich Rechtecke überlagern.

Das gesamte Spiel läuft auf einem Gitter ab. Jede Zelle ist dabei entweder eine Wand oder ein Fresspunkt oder ein Powerpunkt. Pacman selber befindet sich entweder genau in einer Zelle oder ist auf dem Weg von einer Zelle zur anderen. Sobald sich Pacman direkt auf der Zelle befindet ist der Punkt gefressen.

Zusammenstösse mit den Geistern fragt man einfach über den Status ab, denn auch die sind entweder auf einer Zelle oder auf dem Weg zu einer anderen Zelle.

[Bjoerk]

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

[Mavarik]

Zitat:

Zitat von Bjoerk (Beitrag 1297100)

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

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

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

[Bjoerk]

Zitat:

Zitat von Zwinge112 (Beitrag 1297240)

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

Verständlich. Zweckmäßiger wäre es jedoch die anderen davon zu überzeugen ein PacManGrid zu entwerfen? Ist nicht sooo schwer.

[Popov]

@Zwinge112

Ich hab mir den Code angeguckt und muss sagen, ich blick da nicht durch. Lassen wir das mit dem StringGrid usw. Das ist ein Teil für sich, das meine ich jetzt nicht. Ich meine die Logik die hinter dem ganzen Steckt. Ich hab mich nun eine halbe Stunde mit dem Code auseinandergesetzt und hab keine Ahnung was deine Kollegen da gemacht haben.

Wenn di nun meinen ihren Part erledigt zu haben und nun bist du dran, dann darfst du denen einen schönen Gruß von mir bestellen und sagen: Schrott basteln und den dann umrechnen, so dass ein Teil funktioniert, bedeutet nicht fertig zu sein.

Es gibt zwei StringGrids, FeldFac und FeldMauer. FeldPac hat 24 Spalten und 24 Zeilen. Das entspricht der Aufteilung der Grafik. Auch die hat 24x24 Felder. FeldMauer hat dagegen 47 Spalten und 47 Zeilen. Also 1 Spalte und eine Zeile zu wenig.

Wozu nun FeldMauer doppelt so viele Spalten und Felder hat, weiß ich nicht. Vor allem wird jede zweite Spalte und jedes zweite Zeile nicht genutzt. Nun ist in dem StringGrid 0 eine Mauer, 1 ist frei. Da das StringGrid zu groß ist, steht die 1 für Frei nur jede zweite Spalte und Zeile. Somit muss man zwischen FeldMauer und FeldPac umrechnen. Wie auch immer, ich hab mal die FeldMauer StringGrid visualisiert (siehe Bild unten in der großen Grafik). Dann habe ich versucht die FeldMauer Wege in FeldPac nachzuzeichnen (siehe die 9-er). Natürlich, mit etwas mehr Zeit bekommt man den Umrechnungsfaktor raus. Aber momentan habe ich keine Lust dazu. Wozu ist FeldMauer überhaupt so groß.

Also, das das schon mal klein wenig funktioniert, bedeutet es nicht, dass die Kollegen fertig sind.

Am besten alles zurück. Meinetwegen sollen die das mit den StringGrids lassen, aber dann sollten beide StringGrid gleich sein. Weil so wie es ist habe ich keine Ahnung wie man dein Problem lösen sollte.

[Mavarik]

Eine sehr gute Anleitung findet man HIER.

Inkl. Erklärung wie die Geister funktionieren...

- Link
- Link

Zitat:

Zitat von Bjoerk (Beitrag 1297100)

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

Siehe 2. Link hier ist auch nochmal die Draw Routine erklärt, wie alles gezeichnet wird.

[Popov]

Der Code hat mir keine Ruhe gelassen, denn bisher habe ich für alles eine Lösung gefunden. Aber hier konnte ich ich keine finden.

Sag mal, die Gruppe mit der du das zusammen machst, sind das Freunde von dir oder so Jungs die noch eine Rechnung mit dir offen habe? Sagen wir mal so, was da produziert wurde ist kaum zu gebrauchen. Es wurde viel gemacht, aber im Grunde nur Schrott. Klar, man kann da eine Figur bewegen, mehr aber auch nicht. Selbst mach einer halben Stunde konnte ich zwischen den beiden Grids keine vernünftige Verbindung herstellen. Ich glaube das kann man auch nicht. Die FeldMauer StringGrid war so nutzlos, dass ich innerhalb von fünf Minuten einen Code geschrien habe der mit aus der Grafik die Daten bringt (weiß ist 0, rot ist 1). Glaub mir, das was dir deine Kollegen gegeben haben ist nutzlos. Klar, sie haben ihren Teil gemacht (den Heuwagen besorgt und den Dieselmotor) und nun wollen sie, dass du aus deren nutzlosem Code etwas macht (aus dem Heuwagen ein Auto).

Das Bild ist Schrott. Ignorieren wir mal die Größe 505x504, aber das Ergebnis ist ein Feld von 21x21. Etwas untypisch. Einfach hingemalt ohne überlegung.

Das PackMan.Bild ist Schrott. Ist 20x20 und passt nicht richtig ins Bild.

Beide StringGrids sind Schrott. Die passen nicht zueinander. Es reicht um eine Figur zu bewegen, aber nicht um Daten zu speichern.

Da ich mit dem StringGrid nichts anzufangen wusste, habe ich mir am Anfang zum Spaß die Daten aus der Grafik geholt. Dann paar Verbesserungen gemacht, den unnötigen Schrott entfernt, die FeldMauer StringGrid auch. Dann die Steuerung auf FeldPac umgestellt. Im Grunde hatte es auch keinen Sinn mit der alten Grafik zu arbeiten, denn die war unnütz. Wie gesagt, deine Kollegen haben ihren Part gemacht, aber nicht unbedingt ein Schritt weiter gedacht, so dass du es erweitern kannst. Also habe ich auch die Grafik neu gezeichnet. Damit war es möglich auch Punkte einzubauen.

Eigentlich wollte ich das Ergebnis hier veröffentlichen, aber dann dachte ich mir, dass du selber schuld bist. Wer so an ein Projekt ran geht, also die Kollegen zuerst machen lassen und sich komplett raushalten, braucht sich nicht wundern, wenn er unnützen Schrott bekommt.

Abschließend ein Tipp: der Code den du hast ist wertlos. Du hast zwei Möglichkeiten: du gehst zu den Kollegen und ihr macht alles neu, der du gehst zu Lehrer und sagst, dass du Schrott bekommen hast und damit nichts anzufangen weißt.

[Sir Rufo]

Zitat:

Zitat von Mavarik (Beitrag 1297250)

Eine sehr gute Anleitung findet man HIER.

Inkl. Erklärung wie die Geister funktionieren...

- Link
- Link

Zitat:

Zitat von Bjoerk (Beitrag 1297100)

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

Siehe 2. Link hier ist auch nochmal die Draw Routine erklärt, wie alles gezeichnet wird.

Man sieht auch sehr schön das Raster und könnte das sehr einfach mit einer PaintBox und einer ImageList (und einer Hand voll Bildchen) nachbauen - ok, man würde wohl für das ein oder andere eine eigene ImageList nehmen (PacMan, Geister, Früchte), (Rahmen, Punkte), (Zahlen, Buchstaben).

Das Labyrinth und die Punkte lassen sich aber sehr simpel mit einer PaintBox und einer ImageList darstellen. Die Spiellogik liefert der Anzeige nur noch einen Index für die Zelle und das Bild der ImageList wird dann dort gezeichnet.

[Mavarik]

Zitat:

Zitat von Sir Rufo (Beitrag 1297280)

Das Labyrinth und die Punkte lassen sich aber sehr simpel mit einer PaintBox und einer ImageList darstellen. Die Spiellogik liefert der Anzeige nur noch einen Index für die Zelle und das Bild der ImageList wird dann dort gezeichnet.

Da man eigentlich immer 4 Kachel painten muss einfach die Grafik doppelt halten im OR-Modus die Bilder Geister und Pac-Man malen und an vorhergehender Position aus der Kopie restaurieren....

Das ganz ist in Z80 nicht mal 4KB... ( Und ich kann es immer noch lesen... :-D )

Habe leider noch nicht die Sound-Daten gefunden...

[himitsu]

Als vor 5 Jahren der Pacman 30 wurde, da gab es erstmal das Spiel von Google.
https://www.google.de/search?q=pacma...GdgagE#clb=clb
Und dafür hatte man sich extra den originalen Quellcode, samt der Sounddaten und dem originalen Bewegunsmuster der Geister, rausgesucht und der wurde auch überall verlinkt.
Hab jetzt nicht nachgesehn, aber die Wiki weiß bestimmt auch wo der sich befindet.

[Mavarik]

Zitat:

Zitat von himitsu (Beitrag 1297294)

Hab jetzt nicht nachgesehn, aber die Wiki weiß bestimmt auch wo der sich befindet.

Hab doch die "wichtigsten" Links gepostet... :roll:

[himitsu]

Den zweiten Link (pacmandossier) hatte ich wohl nicht richtig erwischt, beim Anklicken ... der erklärt das ja ganz schön ausführlich.

Aber da geht es doch nur um die Geister?

Authentischer wäre es bestimmt, wenn man den Sound quasi auch live "generiert" (lässt sich alles im originalen Quellcode abgucken), aber im Notfall.
http://www.classicgaming.cc/classics/pacman/sounds.php

[Mavarik]

Zitat:

Zitat von himitsu (Beitrag 1297297)

Den zweiten Link (pacmandossier) hatte ich wohl nicht richtig erwischt, beim Anklicken ... der erklärt das ja ganz schön ausführlich.

Aber da geht es doch nur um die Geister?

Authentischer wäre es bestimmt, wenn man den Sound quasi auch live "generiert" (lässt sich alles im originalen Quellcode abgucken), aber im Notfall.
http://www.classicgaming.cc/classics/pacman/sounds.php

Hier ist der Source vom Sound in Z80!

Die Daten kann man sich ja aus den ROM's holen ab $1A0 wenn ich es richtig im Kopf habe...

[Mavarik]

Mal auf die Schnelle...

Delphi-Quellcode:

unit TestMaze;

interface

uses
  System.SysUtils, System.Types, System.UITypes, System.Classes, System.Variants,
  FMX.Types, FMX.Controls, FMX.Forms, FMX.Graphics, FMX.Dialogs,
  FMX.Controls.Presentation, FMX.StdCtrls, System.Rtti, FMX.Layouts, FMX.Grid,
  FMX.Objects, FMX.ScrollBox, FMX.Memo;

Const
    maze : array [0..377] of byte = (208, 210, 210, 210, 210, 210, 210, 210,
    210, 212, 252, 252, 252, 218, 2, 220, 252, 252, 252, 208, 210, 210, 210,
    210, 214, 216, 210, 210, 210, 210, 212, 252, 218, 9, 220, 252, 252, 252,
    218, 2, 220, 252, 252, 252, 218, 5, 222, 228, 5, 220, 252, 218, 2, 230, 232,
    234, 2, 230, 234, 2, 220, 252, 252, 252, 218, 2, 220, 252, 252, 252, 218, 2,
    230, 234, 2, 231, 235, 2, 230, 234, 2, 220, 252, 218, 2, 222, 252, 228, 2,
    222, 228, 2, 220, 252, 252, 252, 218, 2, 220, 252, 252, 252, 218, 2, 222,
    228, 5, 222, 228, 2, 220, 252, 218, 2, 222, 252, 228, 2, 222, 228, 2, 220,
    252, 252, 252, 218, 2, 220, 252, 252, 252, 218, 2, 222, 242, 232, 232, 234,
    2, 222, 228, 2, 220, 252, 218, 2, 231, 233, 235, 2, 231, 235, 2, 231, 210,
    210, 210, 235, 2, 231, 210, 210, 210, 235, 2, 231, 233, 233, 233, 235, 2,
    222, 228, 2, 220, 252, 218, 27, 222, 228, 2, 220, 252, 218, 2, 230, 232,
    248, 2, 246, 232, 232, 232, 232, 232, 232, 248, 2, 246, 232, 232, 232, 234,
    2, 230, 248, 2, 246, 232, 232, 244, 228, 2, 220, 252, 218, 2, 222, 252, 228,
    2, 247, 233, 233, 245, 243, 233, 233, 249, 2, 247, 233, 233, 233, 235, 2,
    222, 228, 2, 247, 233, 233, 245, 228, 2, 220, 252, 218, 2, 222, 252, 228, 5,
    222, 228, 11, 222, 228, 5, 222, 228, 2, 220, 252, 218, 2, 222, 252, 228, 2,
    230, 234, 2, 222, 228, 2, 236, 211, 211, 211, 238, 2, 230, 234, 2, 222, 228,
    2, 230, 234, 2, 222, 228, 2, 220, 252, 218, 2, 231, 233, 235, 2, 222, 228,
    2, 231, 235, 2, 220, 252, 252, 252, 218, 2, 222, 228, 2, 231, 235, 2, 222,
    228, 2, 231, 235, 2, 220, 252, 218, 6, 222, 228, 5, 240, 252, 252, 252, 218,
    2, 222, 228, 5, 222, 228, 5, 220, 252, 250, 232, 232, 232, 234, 2, 222, 242,
    232, 232, 234, 2, 206, 252, 252, 252, 218, 2, 222, 242, 232, 232, 234, 2,
    222, 242, 232, 232, 234, 2, 220);


type
  TForm55 = class(TForm)
    Button1: TButton;
    procedure Button1Click(Sender: TObject);
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
    Procedure LoadMaze;
    Procedure Draw(X,Y,C : Integer);
  end;

var
  Form55: TForm55;

implementation

{$R *.fmx}

procedure TForm55.Draw(X, Y, C: Integer);
var
  R : TRectangle;
begin
  Y := Y * 16;
  X := X * 16;
  R := TRectangle.Create(self); // todo: Mal das richte IMG nehmen...
  R.Parent := Self;
  R.Position.X := X;
  R.Position.Y := Y;
  R.Width := 15;
  R.Height := 15;
end;

Procedure TForm55.LoadMaze;
var
  F       : File;
  ROM     : Array[0..4095] of byte;
  i,X,Y,C : Integer;
begin
{
  AssignFile(F,'..\..\ROMS\pacman.6j');  // :-)
  Reset(F,1);
  Blockread(F,ROM[0],4095);
  CloseFile(F);
}
  Move(Maze[0],ROM[$437],Sizeof(Maze));
  X := 0;
  Y := 0;
  for i:=$437 to $5B1 do
    begin
      if (ROM[i] > 1) and (ROM[i] < $30)
        then X := X + ROM[I]-2
        else begin
               Draw(27-Y,X,ROM[I]);
               Draw(Y,X,ROM[I]);
             end;
      inc(X);
      if X >= 32 then
        begin
          inc(Y);
          X := 0;
        end;
    end;
end;

procedure TForm55.Button1Click(Sender: TObject);
begin
  LoadMaze;
end;

end.

[Popov]

Es gibt tonnenweise bessere Alternativen als das im Projekt von TE:

Delphi-Quellcode:

var
  StringGridErsatz: array[0..23, 0..23] of String;

procedure FillStringGrid;
var
  sl: TStringList;
  x, y: Integer;
begin
  sl := TStringList.Create;
  try
    //Nur ein Beispiel. Alternativ als Textdatei laden
    sl.Add('111111111111111111111111');
    sl.Add('100000000001000000000001');
    sl.Add('101110111001001111011101');
    sl.Add('101110111000001111011101');
    sl.Add('100000000000000000000001');
    sl.Add('101110110111111001011101');
    sl.Add('100000110001000001000001');
    sl.Add('111110111101001111011111');
    sl.Add('000010110000000001010000');
    sl.Add('000010110111011101010000');
    sl.Add('111110110100000101011111');
    sl.Add('000000000100000100000000');
    sl.Add('111110100111111101011111');
    sl.Add('000010100000000001010000');
    sl.Add('000010100111110001010000');
    sl.Add('111110000001000000011111');
    sl.Add('100000111001001111000001');
    sl.Add('100110000000000000011101');
    sl.Add('100010100111110011010001');
    sl.Add('111010100001000011010111');
    sl.Add('100000100001000011000001');
    sl.Add('101111111101011111111101');
    sl.Add('100000000000000000000001');
    sl.Add('111111111111111111111111');

    for y := 0 to 23 do
      for x := 0 to 23 do
        StringGridErsatz[x, y] := Copy(sl[y], x + 1, 1);
  finally
    sl.Free;
  end;
end;

procedure FeldMauer(Canvas: TCanvas; x, y: Integer);
const
  w = 21;
begin
  Canvas.Brush.Color := clMaroon;
  Canvas.Pen.Color := clMaroon;
  Canvas.Rectangle(x * w, y * w, x * w + w, y * w + w);
end;

procedure FeldLeer(Canvas: TCanvas; x, y: Integer);
const
  w = 21;
begin
  Canvas.Brush.Color := clWhite;
  Canvas.Pen.Color := clWhite;
  Canvas.Rectangle(x * w, y * w, x * w + w, y * w + w);
end;

procedure FeldSetzen(Canvas: TCanvas; x, y: Integer);
const
  w = 21;
begin
  if StringGridErsatz[x, y] = '0' then
    FeldLeer(Canvas, x, y)
  else FeldMauer(Canvas, x, y);
end;

procedure FeldKorrektur(Canvas: TCanvas);
const
  w = 21;
var
  x, y: Integer;
begin
  for y := 0 to 23 do
    for x := 0 to 23 do
      FeldSetzen(Canvas, x, y);
end;

procedure TForm1.Button1Click(Sender: TObject);
begin
  FillStringGrid;
  FeldKorrektur(Canvas);
end;

[DeddyH]

Und Ihr seid der Meinung, dass das den TE irgendwie weiterbringt?

[Popov]

Damit so ein Packman funktioniert, muss es ein nutzbares Feld geben. Ein Feld aus dem man Infos bekommt wo die Mauer ist, wo der Gang ist, wo die Bonbons liegen. Das hat das Projekt von dem TE nicht. Seine Kollegen haben haben ihm ein Projekt übergeben mit dem man sich in dem Labyrinth bewegen kann, aber wo man nicht wirklich ohne Umrechnung weiß in welcher Spalte und Zeile man sich befindet. Auch ist die Umrechnung nicht so einfach. Ich hab es zwar nicht lange versucht, nur eine halbe Stunden, aber ich konnte den Plan der in in der einen StringGrid 48 Spalten und Zeilen hat, auch 24 Spalten und Zeilen umrechnen. Der Grund ist die ungleichmäßige Verteilung. Mit etwas Mühe findet man da schon die Umrechnung, ich fand sie nicht.

Wie soll also der TE da seine Punkte platzieren? In dem ersten StringGrid geht es nicht, den zweiten müsste man erst aus dem ersten berechnen.

Es geht hier also weniger drum die Punkt in dem Labyrinth zu platzieren, als die Frage wo man das bitte machen soll. Es gibt kein nutzbares Feld dafür.

Ich beneide den TE also nicht. Ob ihm das alles was bringen wird? Ich weiß es nicht. Was würdest du vorschlagen?

[Bjoerk]

Popov, ich weiß jetzt weshalb die Kumpels von TE 2 unterschiedliche Grids haben. Pacman und die Guys sind ja doppelt so groß wie das Fressenraster.

[Mavarik]

Zitat:

Zitat von Mavarik (Beitrag 1297314)

Mal auf die Schnelle...

Dann kann man auch "einfach" die Paletten und die original Grafiken auslesen...

Mavarik :coder:

[Bjoerk]

Zitat:

Zitat von Mavarik (Beitrag 1297434)

Zitat:

Zitat von Mavarik (Beitrag 1297314)

Mal auf die Schnelle...

Dann kann man auch "einfach" die Paletten und die original Grafiken auslesen...

Mavarik :coder:

Man hätte TE einfach auch mitteilen können, daß er nur die 4 GridCells, die sich "unter" der momentanen GridCell von Pacman befinden, finden muß. Da du ja ein Pacman Profi seit Z80 Tagen bist, war das sicherlich klar? :wink:

[Mavarik]

Zitat:

Zitat von Bjoerk (Beitrag 1297487)

Man hätte TE einfach auch mitteilen können, daß er nur die 4 GridCells, die sich "unter" der momentanen GridCell von Pacman befinden, finden muß. Da du ja ein Pacman Profi seit Z80 Tagen bist, war das sicherlich klar? :wink:

Der Source war mir zu verwuschelt... Daher habe ich mir den nicht angeschaut...

[Bjoerk]

Hab ein Pacmanraster mal aufgemalt damit's etwas deutlicher wird. Pacman und die Guys bewegen sich in Palletsrasterschritten, sind aber selbst ca. doppelt so groß wie das Palletsraster. Falls man DrawCell o.ä. verwenden möchte müssten die also z.B. mit neg. Margins gezeichnet werden.

Falls sich jemand mal mit dem Geisterverhalten genauer beschäftigt hat und auf Deutsch hier kurz erläutern könnte, wäre seeeeeeeeeeehr nett, my english is too bad. Man findet im Internet nix in german darüber. :oops: