Mehrere Bilder in den RAM laden - Array, ImageList oder was?

[Master_RC]

hi leutz!

Eine ganz kleine Frage, die mich aber schon die ganze Zeit nervt und ich find einfach keine Lösung...

Und zwar:
Ich möchte, dass die ganzen Tilesets einer Map meines Spiels am Anfang in einen Array geladen werden, damit sie nicht immer von der Festplatten geholt werden.
(Bitte sagen, falls ein Array falsch ist!)

Mein Problem:
Jetzt möchte ich es so machen, dass der Array nicht immer gleich is, also die Bilder werden immer dynamisch geladen - alle aus einem/mehreren Verzeichnis/sen ausgelsen und geladen.

So...
Das Array-Element sollte jetzt einen Namen haben + dem Bild (32x32px groß)

in PHP wärs ja einfach: $array['elementname'] = ...

nur in Delphi... mmh...
Hab schon probiert:

Delphi-Quellcode:

type
   record = TTile
    Name: string;
    Bild: TBitmap;
   end;

und einfach nur

Delphi-Quellcode:

maptiles: array of TBitmap

abba keins funzt so richtig, weil ich ja immer maptiles[X] machen muss (fettgedrucktes)...

Ich wär also gerne für Lösungen offen ;)

[Pr0g]

Wenn du das Record hast müsstest du ja auch schreiben:

Delphi-Quellcode:

maptiles: array of TTile;

Du könntest auch eine TList nehmen, um die Tiles zu verwalten.

MfG Pr0g

[Khabarakh]

Lustig, genau das Gleiche hab ich vor kurzem auch gebraucht. Hier mal mein Code, jedes Bitmap hat einen zugehörigen String:

[Quellcode entfernt, siehe unten]

Den Code kannst du sicher für dich anpassen, LoadGraphicRessources musst du natürlich selbst implementieren.

[Master_RC]

schon klar das mit den Array

mein gezeigtes Array sollte ja dann auch aus "TBitmaps" bstehen, was ich jedoch voll doof finde...

bitt egebt mir zu euren lösungen auch beispiele, weil bei mir NIX funzt :(

[Khabarakh]

Nagut, hier noch der Rest: Ich verwende eine globale Variable, STOP, bitte nicht hauen, das ist auch die einzige in allen 10 Units und einfach schnell und unkompliziert :wink: .

Delphi-Quellcode:

type
  TBitmapCollection = class
  private
    FBitmapList: TObjectList;
    FNameList: TStringList;
    function GetBitmap(AName: string): TBitmap32;
    procedure LoadGraphicRessources;
  public
    constructor Create;
    destructor Destroy; override;

    procedure Add(ABit: TBitmap32; AName: string);
    function AddNew(AName: string): TBitmap32;

    property Bitmap[AName: string]: TBitmap32 read GetBitmap; default;
  end;

var
  BitmapCollection: TBitmapCollection;

implementation

{ TBitmapCollection }

function TBitmapCollection.GetBitmap(AName: string): TBitmap32;
begin
  Result := TBitmap32(FBitmapList.Items[FNameList.IndexOf(AName)]);
end;

procedure TBitmapCollection.Add(ABit: TBitmap32; AName: string);
begin
  FBitmapList.Add(ABit);
  FNameList.Add(AName);
end;

function TBitmapCollection.AddNew(AName: string): TBitmap32;
begin
  Result := TBitmap32.Create;
  Add(Result, AName);
end;

destructor TBitmapCollection.Destroy;
begin
  FBitmapList.Free;
  FNameList.Free;
  inherited;
end;

constructor TBitmapCollection.Create;
begin
  inherited;
  FBitmapList := TObjectList.Create;
  FNameList := TStringList.Create;
  LoadGraphicRessources;
end;

procedure TBitmapCollection.LoadGraphicRessources;
var
  Stream: TFileStream;
  Alpha: Boolean;
begin
  try
    Stream := TFileStream.Create('Graphics.prr', fmOpenRead);

    LoadPNGintoBitmap32(AddNew('Hugo'), Stream, Alpha);
    LoadPNGintoBitmap32(AddNew('Helmut'), Stream, Alpha);
    LoadPNGintoBitmap32(AddNew('Hannes'), Stream, Alpha);
    LoadPNGintoBitmap32(AddNew('Hannah'), Stream, Alpha);
  finally
    Stream.Free;
  end;
end;

initialization

  BitmapCollection := TBitmapCollection.Create;

finalization

  BitmapCollection.Free;
end.

[Master_RC]

kewl, THX! :thumb:

ich werds mal ausprobieren!