So in this thread i want to show you, how you make a custom Hud and a radar and a minimap, only with Canvas.
It's a working update of this tutorial:
http://udn.epicgames.com/Three/Maste...G%20INTERFACES

I've uploaded the needed packages:
http://www.gamefront.com/files/21314684/Content.zip

1. Create a custom gametype:

Code:
class MyGame extends UTGame;

var MU_Minimap GameMinimap;

defaultproperties
{
        HUDType=class'YourPackage.CustomHUD'
        bUseClassicHUD = true
        
}
2. Create other classes:

Code:
class MU_Minimap extends Compass;

var() MaterialInstanceConstant Minimap;
var() MaterialInstanceConstant CompassOverlay;

var Vector2D MapRangeMin,MapRangeMax;

var() Bool bForwardAlwaysUp;

var Vector2D MapCenter;

var() Const EditConst DrawSphereComponent MapExtentsComponent;

function PostBeginPlay()
{
	Super.PostBeginPlay();

	MapCenter.X = Location.X;
	MapCenter.Y = Location.Y;
	MapRangeMin.X = MapCenter.X - MapExtentsComponent.SphereRadius;
	MapRangeMax.X = MapCenter.X + MapExtentsComponent.SphereRadius;
	MapRangeMin.Y = MapCenter.Y - MapExtentsComponent.SphereRadius;
	MapRangeMax.Y = MapCenter.Y + MapExtentsComponent.SphereRadius;
}

defaultproperties
{
	Begin Object Class=DrawSphereComponent Name=DrawSphere0
     	SphereColor=(B=0,G=255,R=0,A=255)
     	SphereRadius=5000.000000
	End Object
	MapExtentsComponent=DrawSphere0
	Components.Add(DrawSphere0)

	bForwardAlwaysUp=True
	Minimap = MaterialInstanceConstant'CompassContent.M_minimap_INST'
    CompassOverlay = MaterialInstanceConstant'CompassContent.M_compass_INST'
}
Code:
interface ICompass;

function float GetDegreeHeading();
function float GetRadianHeading();

function int GetYaw();
function Rotator GetRotator();
function vector GetVectorizedRotator();
Code:
class Compass extends actor placeable implements(ICompass);

event PostBeginPlay()
{                                                             
 	`log(GetRadianHeading()@GetDegreeHeading(),,'compass heading');
}

function float GetRadianHeading()
{
	local Vector v;
	local Rotator r;
	local float f;
 
	r.Yaw = rotation.Yaw;   // a
	v = vector(r);          // b

	f = GetHeadingAngle(v); // c
	f = UnwindHeading(f);   // d

	while (f < 0)		    // e
		f += PI * 2.0f;

	return f;
} 

function float GetDegreeHeading()
{
	local float f;

	f = GetRadianHeading();

	f *= RadToDeg;

	return f;
}

// Return the yaw of the actor
function int GetYaw()
{
	return Rotation.Yaw;
}
					  
function Rotator GetRotator()
{
	return Rotation;
}

function vector GetVectorizedRotator()
{
	return vector(Rotation);
}

DefaultProperties
{
	Begin Object Class=ArrowComponent Name=Arrow
		ArrowColor = (B=80,G=80,R=200,A=255)
		ArrowSize = 1.000000
		Name = "North Heading"
	End Object
	Components(0) = Arrow

	Begin Object Class=SpriteComponent Name=Sprite 
		Sprite=Texture2D'UTBookTextures.compass'
		HiddenGame = True
		AlwaysLoadOnClient = False
		AlwaysLoadOnServer = False
		Name  = "Sprite"
	End Object
	Components(1) = Sprite

	bStatic   = True
	bHidden   = True
	bNoDelete = True
	bMovable  = False
}

3. Now the Hud :
There will be a warning on the screen
You can disable it, be typing "DisableAllScreenMessages" into the console

Code:
class CustomHUD extends UTHUD;

var MaterialInstanceConstant GameMinimapMIC;
var Material GameMinimapp;

var MU_Minimap GameMinimap;
var Float TileSize;
var Int MapDim;
var Int BoxSize;
var color PlayerColors[2];

var float MPosXMap;
var float MPosYMap;

simulated function PostBeginPlay()
{
	Super.PostBeginPlay();

	GameMinimap = Mygame(WorldInfo.Game).GameMinimap;
}


function DrawLivingHUD()
{
    DrawMap();

    MPosXMap = Canvas.OrgX + 30;
    MPosYMap = Canvas.ClipY/1.6;
}


/////////////////////////////////
//Radar/Minimap
/////////////////////////////////

function float GetPlayerHeading()
{
	local Float PlayerHeading;
	local Rotator PlayerRotation;
	local Vector v;

	PlayerRotation.Yaw = PlayerOwner.Pawn.Rotation.Yaw;
	v = vector(PlayerRotation);
	PlayerHeading = GetHeadingAngle(v);
	PlayerHeading = UnwindHeading(PlayerHeading);

	while (PlayerHeading < 0)
		PlayerHeading += PI * 2.0f;

	return PlayerHeading;
}


//There will be a warning on the screen
//You can disable it, be typing "DisableAllScreenMessages"

function DrawMap()
{
	local Float TrueNorth,PlayerHeading;
	local Float MapRotation,CompassRotation;
	local Vector PlayerPos, ClampedPlayerPos, RotPlayerPos, DisplayPlayerPos, StartPos;
	local LinearColor MapOffset;
	local Float ActualMapRange;
	local Controller C;

	//Set MapDim & BoxSize accounting for the current resolution
	MapPosition.X = MPosXMap;  //default.MapPosition.X * FullWidth;
	MapPosition.Y = MPosYMap;  //default.MapPosition.Y * FullHeight;
	MapDim = default.MapDim * ResolutionScale;
	BoxSize = default.BoxSize * ResolutionScale;

	//Calculate map range values
	ActualMapRange = FMax(	GameMinimap.MapRangeMax.X - GameMinimap.MapRangeMin.X,
						GameMinimap.MapRangeMax.Y - GameMinimap.MapRangeMin.Y);

	//Calculate normalized player position
	PlayerPos.X = (PlayerOwner.Pawn.Location.Y - GameMinimap.MapCenter.Y) / ActualMapRange;
	PlayerPos.Y = (GameMinimap.MapCenter.X - PlayerOwner.Pawn.Location.X) / ActualMapRange;

	//Calculate clamped player position
	ClampedPlayerPos.X = FClamp(PlayerPos.X,-0.5 + (TileSize / 2.0),0.5 - (TileSize / 2.0));
	ClampedPlayerPos.Y = FClamp(PlayerPos.Y,-0.5 + (TileSize / 2.0),0.5 - (TileSize / 2.0));

	//Get north direction and player's heading
	TrueNorth = GameMinimap.GetRadianHeading();
	Playerheading = GetPlayerHeading();

	//Calculate rotation values
	if(GameMinimap.bForwardAlwaysUp)
	{
		MapRotation = PlayerHeading;
		CompassRotation = PlayerHeading - TrueNorth;
	}
	else
	{
		MapRotation = PlayerHeading - TrueNorth;
		CompassRotation = MapRotation;
	}

	//Calculate position for displaying the player in the map
	DisplayPlayerPos.X = VSize(PlayerPos) * Cos( ATan(PlayerPos.X) - MapRotation);
	DisplayPlayerPos.Y = VSize(PlayerPos) * Sin( ATan(PlayerPos.Y) - MapRotation);

	//Calculate player location after rotation
	RotPlayerPos.X = VSize(ClampedPlayerPos) * Cos( ATan(ClampedPlayerPos.X) - MapRotation);
	RotPlayerPos.Y = VSize(ClampedPlayerPos) * Sin( ATan(ClampedPlayerPos.Y) - MapRotation);

	//Calculate upper left UV coordinate
	StartPos.X = FClamp(RotPlayerPos.X + (0.5 - (TileSize / 2.0)),0.0,1.0 - TileSize);
	StartPos.Y = FClamp(RotPlayerPos.Y + (0.5 - (TileSize / 2.0)),0.0,1.0 - TileSize);
	StartPos.X = FClamp(DisplayPlayerPos.X + (0.5 - (TileSize / 2.0)),TileSize/-2,1.0 - TileSize/2);
	StartPos.Y = FClamp(DisplayPlayerPos.Y + (0.5 - (TileSize / 2.0)),TileSize/-2,1.0 - TileSize/2);

	//Calculate texture panning for alpha
	MapOffset.R =  FClamp(-1.0 * RotPlayerPos.X,-0.5 + (TileSize / 2.0),0.5 - (TileSize / 2.0));
	MapOffset.G =  FClamp(-1.0 * RotPlayerPos.Y,-0.5 + (TileSize / 2.0),0.5 - (TileSize / 2.0));
	MapOffset.R =  FClamp(-1.0 * DisplayPlayerPos.X,-0.5,0.5);
	MapOffset.G =  FClamp(-1.0 * DisplayPlayerPos.Y,-0.5,0.5);


        //Set the material parameter values
	GameMinimap.Minimap.SetScalarParameterValue('MapRotation',MapRotation);
	GameMinimap.Minimap.SetScalarParameterValue('TileSize',TileSize);
	GameMinimap.Minimap.SetVectorParameterValue('MapOffset',MapOffset);
	GameMinimap.CompassOverlay.SetScalarParameterValue('CompassRotation',CompassRotation);

	//Draw the map
	Canvas.SetPos(MapPosition.X,MapPosition.Y);
	Canvas.DrawMaterialTile(GameMinimap.Minimap,MapDim,MapDim,StartPos.X,StartPos.Y,TileSize,TileSize);

	//Draw the player's location
	Canvas.SetPos(	MapPosition.X + MapDim * (((DisplayPlayerPos.X + 0.5) - StartPos.X) / TileSize) - (BoxSize / 2),
				MapPosition.Y + MapDim * (((DisplayPlayerPos.Y + 0.5) - StartPos.Y) / TileSize) - (BoxSize / 2));
	Canvas.SetDrawColor(PlayerColors[0].R,
					PlayerColors[0].G,
					PlayerColors[0].B,
					PlayerColors[0].A);
	Canvas.DrawBox(BoxSize,BoxSize);
	//Canvas.DrawMaterialTile(PlayerTex, 1400 * ResolutionScale, 900 * ResolutionScale);

	/*****************************
	*  Draw Other Players
	*****************************/

	foreach WorldInfo.AllControllers(class'Controller',C)
	{
		if(PlayerController(C) != PlayerOwner)
		{
			//Calculate normalized player position
			PlayerPos.Y = (GameMinimap.MapCenter.X - C.Pawn.Location.X) / ActualMapRange;
			PlayerPos.X = (C.Pawn.Location.Y - GameMinimap.MapCenter.Y) / ActualMapRange;

			//Calculate position for displaying the player in the map
			DisplayPlayerPos.X = VSize(PlayerPos) * Cos( ATan(PlayerPos.X) - MapRotation);
			DisplayPlayerPos.Y = VSize(PlayerPos) * Sin( ATan(PlayerPos.Y) - MapRotation);

			if(VSize(DisplayPlayerPos - RotPlayerPos) <= ((TileSize / 2.0) - (TileSize * Sqrt(2 * Square(BoxSize / 2)) / MapDim)))
			{
				//Draw the player's location
				Canvas.SetPos(	MapPosition.X + MapDim * (((DisplayPlayerPos.X + 0.5) - StartPos.X) / TileSize) - (BoxSize / 2),
							MapPosition.Y + MapDim * (((DisplayPlayerPos.Y + 0.5) - StartPos.Y) / TileSize) - (BoxSize / 2));
				Canvas.SetDrawColor(PlayerColors[1].R,
								PlayerColors[1].G,
								PlayerColors[1].B,
								PlayerColors[1].A);
				Canvas.DrawBox(BoxSize,BoxSize);
			}
		}
	}

	//Draw the compass overlay
	Canvas.SetPos(MapPosition.X,MapPosition.Y);
	Canvas.DrawMaterialTile(GameMinimap.CompassOverlay,MapDim,MapDim,0.0,0.0,1.0,1.0);
}


exec function ChangeMapsize(int size)
{
   MapDim = size;

}

exec function MapSizeUp()
{
	MapDim *= 2;
	BoxSize *= 2;
}

exec function MapSizeDown()
{
	MapDim /= 2;
	BoxSize /= 2;
}

exec function MapZoomIn()
{
	TileSize = 1.0 / FClamp(int((1.0 / TileSize) + 1.0) + 0.5,1.5,10.5);
	TileSize = 1.0 / FClamp(int((1.0 / TileSize) + 1.0) + 0.5,1.5,10.5);

}

exec function MapZoomOut()
{
	TileSize = 1.0 / FClamp(Int((1.0 / TileSize) - 1.0) + 0.5,1.5,10.5);
}


defaultproperties
{
        MapDim=256
	BoxSize=12
	PlayerColors(0)=(R=255,G=255,B=255,A=255)
	PlayerColors(1)=(R=96,G=255,B=96,A=255)
	TileSize=1
	MapPosition=(X=0.000000,Y=0.000000)

}

Now we are done with coding.
In your level, you have to place a MU_Minimap actor (Select the Actor classes Tab and search for this actor)
You have to play with the radius (select the MU_Minimap actor and press F4) until it fits the size of your level.

If you've got any questions PN me or write a message in this thread!