UE1 - UT What is the UT99 equivalent of “PlayerController”?

[Silver_Ibex]

I have a map decoration item I am coding and I need it to call a function (PlayerCalcView) in the local player pawn, and only the local player pawn of the local machine. The FX of the decoration will change and be different to each of the players, depending on their viewing location.

I know how to do it in UT2k4 script, and want to reproduce the same effect in UT99.

From the UT2k4 code

// UT2k4 script example in map decoration

var PlayerController localPlayer;

simulated function PostBeginPlay() {
	if (Level.NetMode == NM_DedicatedServer) 
	{
		Disable('Tick');
	}
LocalPlayer = Level.GetLocalPlayerController();
}

simulated event Tick(float d) {
	local actor MyA;
	local vector MyV;
	local rotator MyR;
	if (LocalPlayer == None) 
	{
		LocalPlayer = Level.GetLocalPlayerController();
		if (LocalPlayer == None) return;
	}
	LocalPlayer.PlayerCalcView(MyA,MyV,MyR);

	//do the FX stuff here
}

 

[meowcat]

PlayerPawn was the equivalent, but it basically had both pawn and controller functions combined.

 

[Silver_Ibex]

Thanks, but what has me stumped is how to get it to return the info from the actor being controlled by the player.


UT2K4 has it easy, just use “Level.GetLocalPlayerController()” to set up a nametag like variable.

var PlayerController HelloMyNameIs;

HelloMyNameIs = Level.GetLocalPlayerController();

And then you can spam that actor every time you need updated info returned from it.

HelloMyNameIs.PlayerCalcView(A,B,C);

so how would that work in UT99? I am guessing it is going to be a bit more complex

 

[meowcat]

Well that is definitely a tricky one, but I think the RegisterHUDMutator function from the base UT99 mutator class may give the only real way to do this by iterating through all playerpawns and seeing if the myHud reference does not equal 'none'.

Another tricky part could be that you may need to perform that check every time your custom decoration becomes relevant to a given client (unless it is spawned clientside with a remote role of ROLE_authority or something like that). I don't quite remember how UE1 handles decorations (are there any truely 'static' actors that are treated authoritatively clientside?)

 

[Wormbo]

so how would that work in UT99? I am guessing it is going to be a bit more complex

It's exactly the same in UT1, except that you need to implement GetLocalPlayerPawn() yourself. Just copy and adapt the UT2004 function from Engine.LevelInfo.

 

[Silver_Ibex]

Thanks I will look into that.

 

[Raven]

I have quite similar function in the emitter.

simulated function PlayerPawn GetLocalPlayer()
{
        local PlayerPawn pp, LocalPlayer;
	if(Level.NetMode != NM_DedicatedServer)
	{
           foreach AllActors(class'PlayerPawn',pp)
   	   {
	               if(Viewport(pp.Player) != None)
	               {
	               	   LocalPlayer=pp;
	   	       	   break;
	               } 
	   }
	   return LocalPlayer;
	}
	return none;
}

It works clientside only.

 

[Wormbo]

LocalPlayer should not be a local variable, but be declared in the class. UT200x LevelInfo.GetLocalPlayerController() demonstrates that very nicely.

 

[meowcat]

@nargil: I don't think that there was a viewport class in UT99 (class 'player' extends object).

 

[Wormbo]

As in UT200x, Viewport is a native class in UT that extends Player. I think you can also see this if you browse the object class hierarchy in UnrealEd's actor browser.
In network games, by the way, there's also another kind of Player subclass used: the NetConnection. Like Viewport it's a native-only class. You only need to know it's there, because on a listen server, every PlayerPawn/Playercontroller has a Player object. Only the local player's Player will be a Viewport, the others have a NetConnection.

 

[meowcat]

Ahhh, Ok (I learn something new every day...). I had initially done a search of the UT99 source code for a viewport class and did not find one (and I did not see any references to a 'viewport' in the playerpawn class). And now that you mention it, UT2kx did not have a specific viewport class (well a uscript stub anyways) either.

 

[Wormbo]

Both UT and UT200x have a Viewport-type variable called Viewport in their Engine.Canvas class. This means, if you have access to a Canvas object (i.e. in just about all functions called during rendering) you can easily access the local PayerPawn/PlayerController through Canvas.Viewport.Actor, where "Actor" is a variable declared in the Player class. That's something I already miss in UT3.