Just yse the pixel's position as the center, i minimized Alimonster's example to only use one pixel.[pascal]
unit tank_class;

interface

uses
Graphics;

type
// The following represents a point of the tank. It would have x,y and z in
// the case of a 3D vector, but we don't need that for this example program
TVector2D = record
case Boolean of
False: (pts: array[0..1] of Real);
True : (x,y: Real);
end;


TTank = class
private
FDirection: TVector2D;
FShowDirection: Boolean;
protected
FPosition: TVector2D;
property Direction: TVector2D read FDirection write FDirection;
public
constructor Create;
destructor Destroy; override;
procedure Draw(Where: TCanvas);
procedure Move(const Speed: Real);
procedure Rotate(const rotation: Real);

property ShowDirection: Boolean read FShowDirection write FShowDirection default True;
end;

implementation

////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

//
// MakeVector
//
// A little helper function to set a vector to the wanted values
//
procedure MakeVector(var Vec: TVector2D; _x,_y: Real);
begin
with Vec do
begin
x := _x;
y := _y;
end;
end;

//
// VectorLength
//
// Calculates the length of a 2D vector (for 3D, adjust to include the z value)
//
function VectorLength(var Vec: TVector2D): Real;
begin
with Vec do
Result := Sqrt(x*x + y*y);
end;

//
// Normalize
//
// Normalises the vector so that it's of unit length
//
procedure Normalize(var Vec: TVector2D);
var
RecipLength: Real;
begin
RecipLength := 1 / VectorLength(Vec);
with Vec do
begin
x := x * RecipLength;
y := y * RecipLength;
end;
end;


//
// Create
//
// The constructor for the class. Does constructor-y things
//
constructor TTank.Create;
var
i: Cardinal;
begin
inherited;
FPosition.x:=160;
FPosition.y:=120;

MakeVector(FDirection, 0, -1); // facing up -- y is positive down the screen
end;

//
// Destroy
//
// A destructor. No cleaning up to do yet
//
destructor TTank.Destroy;
begin
inherited;
end;

//
// Draw
//
// Displays the tank to a given canvas using LineTo
//
procedure TTank.Draw(Where: TCanvas);
var
i: Cardinal;
begin
with Where do
begin
// Move to the first point
Where.Pixels[Round(FPosition.x),
Round(FPosition.y)] := ClBlack;

// draw the direction too
if FShowDirection then
begin
Pen.Color := clRed;
MoveTo(Round(FPosition.X), Round(FPosition.Y));
LineTo(Round((FDirection.x * 140) + FPosition.X),
Round((FDirection.y * 140) + FPosition.Y));

Pen.Color := clBlack;
end;
end;
end;


//
// Move
//
// Moves the tank forward at a given speed in the direction it's facing
//
procedure TTank.Move(const Speed: Real);
var
i: Cardinal;
begin
FPosition.x := FPosition.x + (FDirection.x * Speed);
FPosition.y := FPosition.y + (FDirection.y * Speed);
end;

//
// Rotate
//
// Rotates the tank and its direction vector by the given angle (in degrees).
// This is the interesting part in terms of the tutorial .
//
procedure TTank.Rotate(const rotation: Real);
const
DEG_TO_RAD: Real = PI/180;
var
i: Cardinal;
Angle: Real;
OldX, OldY: Real;
begin
Angle := Rotation * DEG_TO_RAD; // convert from degrees to radians

// Update the direction too. This doesn't need to be translated as we're only
// interested in which way it's pointing, not where it is
OldX := FDirection.x;
OldY := FDirection.y;
FDirection.x := OldX * cos(Angle) - OldY * sin(Angle);
FDirection.y := OldX * sin(Angle) + OldY * cos(Angle);
Normalize(FDirection);
end;

end.[/pascal]