| Home Page | Recent Changes | Preferences

# Wizzie/HUDRadar

The radar I use for my mod. The function RestartPlayer() in pGameInfo shows how to add an actor to be shown in the radar area. Any kind of actor can be added, not just playerpawns. Hope someone finds it usefull. Enjoy.

#### pGameInfo.uc

    class pGameInfo extends GameInfo;

    function RestartPlayer( Controller aPlayer )
    {
        super.RestartPlayer( aPlayer );
        if( aPlayer != none && aPlayer.Pawn != none )
            pGameReplicationInfo(GameReplicationInfo).CreateRadarActor( aPlayer.Pawn, TYPE_PlayerPawn );
    }

    defaultproperties
    {
        PlayerControllerClassName = "myMod.pPlayerController"
        GameReplicationInfoClass = class'pGameReplicationInfo'
        HUDType = "myMod.pHUDBase"
    }

#### pGameReplicationInfo.uc

    class pGameReplicationInfo extends GameReplicationInfo;

    enum EItemType
    {
        TYPE_PlayerPawn,
        TYPE_DeadPawn,
    };

    struct RadarActor
    {
        var int PosX;
        var int PosY;
        var float Distance;
        var EItemType ItemType;
    };

    var array<pRadarActor> RadarActorsArray;

    simulated function PostNetBeginPlay()
    {
        local pRadarActor actor;

        super.PostNetBeginPlay();

        ForEach DynamicActors(class'pRadarActor', actor)
            AddRadarItem( actor );
    }

    function CreateRadarActor( Actor aActor, EItemType ItemType )
    {
        local int i;
        local pRadarActor RRI;

        if( !aActor.bDeleteMe )
        {
            for( i=0; i<RadarActorsArray.Length; i++ )
            {
                if( RadarActorsArray[i].Owner == aActor )
                    return;
            }

            RRI = Spawn(class'pRadarActor', aActor,,vect(0,0,0),rot(0,0,0));
            if( RRI != none )
                RRI.ItemType = ItemType;
        }
    }

    simulated function AddRadarItem( pRadarActor RRI )
    {
        RadarActorsArray[RadarActorsArray.Length] = RRI;
    }

    simulated function RemoveRadarItem( pRadarActor RRI )
    {
        local int i;

        for( i=0 ; i<RadarActorsArray.Length ; i++ )
            if( RadarActorsArray[i] == RRI )
                break;

        if( i == RadarActorsArray.Length )
        {
            log("GameReplicationInfo::RemoveRadarItem() RRI="$RRI$" not found.", 'Error');
            return;
        }
        RadarActorsArray.Remove( i, 1 );
    }

    simulated function Array<RadarActor> GetVisibleRadarActors( Pawn PawnOwner )
    {
        local Array<RadarActor> RadarActors;
        local RadarActor rActor;
        local vector OriginLoc, TargetLoc;
        local rotator OriginRot, TargetRot;
        local float Distance;
        local int i, TeamIndex;

        TeamIndex = PawnOwner.PlayerReplicationInfo.Team.TeamIndex;

        OriginLoc = PawnOwner.Location * vect(1,1,0);
        OriginRot = PawnOwner.Rotation;
        OriginRot.Yaw += 16384;

        for( i=0; i < RadarActorsArray.length ; i++ )
        {
            if( RadarActorsArray[i].PlayerOwner == PlayerController(PawnOwner.Controller) )
                continue;

            if( TeamIndex == RadarActorsArray[i].TeamIndex || RadarActorsArray[i].TeamIndex == 255 )
            {
                TargetLoc.X = RadarActorsArray[i].RadarLocationX;
                TargetLoc.Y = RadarActorsArray[i].RadarLocationY;
                TargetLoc.Z = 0.0;
                Distance = VSize( OriginLoc - TargetLoc ) * 0.03125;    // 2048 units radius viewrange (64/2048=0.03125)
                if( Distance < 64 )
                {
                    TargetRot = rotator( TargetLoc - OriginLoc );
                    TargetRot.Yaw -= OriginRot.Yaw;
                    TargetLoc = vector( TargetRot ) * Distance;
                    rActor.PosX = TargetLoc.X+64;
                    rActor.PosY = TargetLoc.Y+64;
                    rActor.ItemType = RadarActorsArray[i].ItemType;
                    rActor.Distance = Distance;
                    RadarActors[RadarActors.Length] = rActor;
                }
            }
        }
        return RadarActors;
    }

#### pRadarActor.uc

    class pRadarActor extends ReplicationInfo;

    var float RadarLocationX, RadarLocationY;
    var byte TeamIndex;
    var PlayerController PlayerOwner;
    var pGameReplicationInfo.EItemType ItemType;

    replication
    {
        reliable if( bNetInitial && (Role == ROLE_Authority) )
            TeamIndex, PlayerOwner;

        reliable if( bNetDirty && (Role == ROLE_Authority) )
            ItemType;

        unreliable if( bNetDirty && (Role == ROLE_Authority) )
            RadarLocationX, RadarLocationY;
    }

    event PostBeginPlay()
    {
        local Pawn P;

        if ( Role < ROLE_Authority )
            return;

        P = Pawn(Owner);
        if( P != none )
        {
            if( P.Controller != none )
                PlayerOwner = PlayerController(P.Controller);

            if( (P.PlayerReplicationInfo != none) && (P.PlayerReplicationInfo.Team != none) )
                TeamIndex = P.PlayerReplicationInfo.Team.TeamIndex;
        }
        SetTimer( 1.0/NetUpdateFrequency, true );
    }

    simulated event PostNetBeginPlay()
    {
        local pGameReplicationInfo GRI;

        foreach DynamicActors(class'pGameReplicationInfo',GRI)
            GRI.AddRadarItem(self);
    }

    simulated function Destroyed()
    {
        local pGameReplicationInfo GRI;

        ForEach DynamicActors(class'pGameReplicationInfo',GRI)
            GRI.RemoveRadarItem(self);

        Super.Destroyed();
    }

    event Timer()
    {
        if( Owner == none )
        {
            Destroy();
            return;
        }

        RadarLocationX = Owner.Location.X;
        RadarLocationY = Owner.Location.Y;

        if( (Pawn(Owner) != none) && (ItemType != TYPE_DeadPawn) && (Pawn(Owner).Health <= 0) )
            ItemType = TYPE_DeadPawn;
    }

    DefaultProperties
    {
        TeamIndex = 255
        NetUpdateFrequency = 10.00
    }

#### pHUDBase.uc

    class pHUDBase extends HudBase
        config(User);

    var Material HUDMaterial1;
    var Material RadarBase;

    var globalconfig bool bShowRadar;
    var globalconfig float RadarPosX;
    var globalconfig float RadarPosY;

    simulated function UpdatePrecacheMaterials()
    {
        Level.AddPrecacheMaterial(Material'InterfaceContent.HUD.SkinA');
        Level.AddPrecacheMaterial(Material'Radar.RadarFinal');
    }

    simulated function DrawHudPassC (Canvas C)
    {
        if( bShowRadar )
            DrawRadar(C);
    }

    simulated function DrawRadar( Canvas C )
    {
        local float DotSize;
        local int i, Alpha;
        local pGameReplicationInfo GRI;
        local Array<pGameReplicationInfo.RadarActor> RadarActors;

        if( PlayerOwner == none || PawnOwner == none ||
            PawnOwner.PlayerReplicationInfo == none || PawnOwner.PlayerReplicationInfo.Team == none )
            return;

        GRI = pGameReplicationInfo(PlayerOwner.GameReplicationInfo);
        if( GRI == none )
            return;

        C.SetPos( RadarPosX * C.ClipX, RadarPosY * C.ClipY );
        C.DrawTile( RadarBase, 128, 128, 0, 0, RadarBase.MaterialUSize(), RadarBase.MaterialVSize() );

        DotSize = 6;
        RadarActors = GRI.GetVisibleRadarActors( PawnOwner );
        for( i=0 ; i<RadarActors.Length ; i++ )
        {
            if( RadarActors[i].Distance < (64-8) )
                Alpha = 160;
            else
                Alpha = 160*((8-(RadarActors[i].Distance-(64-8)))/8)+1;

            if( RadarActors[i].ItemType == TYPE_PlayerPawn )
                C.DrawColor = C.MakeColor( 255, 255, 255 );
            else if( RadarActors[i].ItemType == TYPE_DeadPawn )
                C.DrawColor = C.MakeColor( 255, 0, 0 );

            C.DrawColor.A = Alpha;

            C.SetPos( RadarPosX*C.ClipX+RadarActors[i].PosX-0.5*DotSize , RadarPosY*C.ClipY+RadarActors[i].PosY-0.5*DotSize );
            C.DrawTile( HUDMaterial1, DotSize, DotSize, 838, 238, 144, 144 );
        }
    }

    defaultproperties
    {
        HUDMaterial1 = Material'InterfaceContent.Hud.SkinA'
        RadarBase = Material'Radar.RadarFinal'

        RadarPosX = 0.87
        RadarPosY = 0.03
    }

### Comments

Category Custom Class

The Unreal Engine Documentation Site

Wiki Community

Topic Categories

Image Uploads

Random Page

Recent Changes

Offline Wiki

Unreal Engine

Console Commands

Terminology

Mapping Topics

Mapping Lessons

UnrealEd Interface

Questions&Answers

Scripting Topics

Scripting Lessons

Making Mods

Class Tree

Questions&Answers

Modeling Topics

Questions&Answers

Log In