It's not a daft question -- we all have to start somewhere!

The process of using those sprites can be divided into these steps:

1) Grab the images from a file and load it into memory
2) Find a way to specify each sprite's position as a rectangle/square (up to you!) of the larger bitmap
3) Draw the things at some point by copying the wanted rectangle from the big bitmap onto the screen (or somewhere else)

There are a great many ways to achieve this since there are lots of different methods for drawing stuff (e.g. Direct3d, DirectDraw, OpenGL, GDI, GDI+, and others I forgot...). It's not difficult though.

The simplest method is to use the TBitmap class. You create a bitmap (and free it once finished) and use the LoadFromFile method to get the _entire_ bitmap into memory. You can then decide what sprites you need -- this is a case of specifying a rectangle (TRect) using the Bounds or Rect functions. You'd pass the coordinates of your sprite when you want to draw it using the CopyRect method available in TCanvas.

If it makes things simpler, you could just cut-and-paste each sprite into many small, individual bitmaps manually (with Paint or whatever) rather than having them all crammed into one tileset. It's your call, as always .

Here's some quick example code:

[pascal]// the following is used for the characters
// in the game -- a creature with a position (x, y) on
// the screen and a picture (specified by the coords)
type
TMonster = record
x, y: Integer; // current screen position
PicCoords: TRect; // rect of the picture in overall bitmap
end;

procedure TYourForm.Blah(const Monster: TMonster);
var
Bmp: TBitmap; // stores the large image w/ lots of sprites
begin
Bmp := TBitmap.Create;
try
Bmp.LoadFromFile('somebitmap.bmp'); // load your sprites into memory

// copy this monster onto the screen, grabbing the
// picture as a small rectangle of the big bitmap. Make sense?
// assuming that the sprites are 32 by 32 pixels, change appropriately
Canvas.CopyRect(Bounds(Monster.x, Monster.y, 32, 32), Bmp.Canvas, Monster.PicCoords);
finally
Bmp.Free;
end;
end;[/pascal]
Of course, you'd want to initialise some of your monsters with positions and so on, but that demonstrates the basic idea.

There are variations on this of course. You can store the sprite-coords-within-larger-pic as an array of TRects, then have the monster record store an index instead of the coordinates directly. This would save space if you have lots of monsters with the same picture.

The change would look like this:

[pascal]type
TMonster = record
x, y: Integer; // current screen position
Picture: Integer; // index of the monster's picture
end;

Coords: array[0..MonsterCount - 1] of TRect; // each sprite you want

// init the coords somehow, maybe
// ... LoadCoordsFromFile(Coords); // write this function
// or Coords[0] := Rect(0, 0, 32, 32); Coords[1] := Rect(32, 0, 64, 32);

// then later, when drawing...
Canvas.CopyRect(Bounds(Monster.x, Monster.y, 32, 32), Bmp.Canvas, Coords[Monster.Picture]);[/pascal]

If the above isn't clear then let me know and I'll write a small example app to demonstrate what I mean.

You'd usually only create and load the bitmap at the start, keeping it in memory for as long as you can. At the end, you'd free it. This may well mean creating + loading in the form's OnCreate method and freeing in the OnDestroy. You should hopefully understand the reason why -- avoid unnecessary work each update if you can.

Also, the different graphics libraries will function much like the above. In most cases, there's something like the TBitmap class (like an IDirectDrawSurface7 for DirectDraw, a texture in OpenGL, and so on). There will be a "stores pictures and things" class, and some way to copy smaller parts of it (like Blt in DDraw).

You can also copy the smaller parts of the bitmap into an array and use those pictures directly, instead of with CopyRect. In other words:

[pascal]type
TMonster = record
x, y: Integer;
Pic: Integer; // index to TBitmap for the sprite
end;
Pics: array[0..TotalSprites - 1] of TBitmap;

procedure CreateThePics;
var
i: Integer;
MainBmp: TBitmap;
begin
MainBmp := TBitmap.Create;
MainBmp.LoadFromFile('c:\wherever.bmp');

for i := Low(Pics) to High(Pics) do
begin
Pics[i] := TBitmap.Create;
Pics[i].Width := SpriteSize; // 32 or whatever
Pics[i].Height := SpriteSize; // 32 or whatever
// Use CopyRect to copy from the big bitmap into this small one
// remembering that you need some way to specify the coords.
end;
MainBmp.Free;
end;[/pascal]

Keep in mind that TBitmap/TCanvas won't produce the best results, but they'll do for starters. You can have a look at http://terraqueous.f2o.org/dgdev/viewtopic.php?t=199 for a tutorial on TBitmap, etc., before moving onto cooler APIs (see the huge amount listed on dgdev's main page and pick one ).

The main challenge is specifying the coordinates for your sprites. You can do this either by putting the coordinates into a hard-coded array or by loading them from file (better, since you can change stuff without recompiling the program). It's still pretty tedious work whatever you choose, though!