NEED HELP: Single Player Controller with Input Contexts

Development Programming & Scripting
, , ,
1

TL;DR - I want to add keyboard/gamepad input for selecting items in Main Menu. You press button, you select next/previous menu item/option: Play, Load Game, etc.

I just don’t know what I’m asking for anymore.
I’m trying to make Player Controller, handling Title/Main Menu, Gameplay and Pause Menu.

At first I was thinking about making separate Player Controller classes.
One for Main Menu (CndController_Title) second for Gameplay/Pause Menu (CndController_Player).

I only keep finding the basic tutorials with Hover and Press, that don’t cover any of this.

Already made Input assets for Menu. I just don’t know how make them work inside my Main Menu widget.

2

I think the best way, based on the engine design, is to use a Player Controller for the Menus (instead of handling input in the Menu’s tick, for example).

Then, maybe the best approach is creating a Game Mode and Player Controller specific for the Menus. You may find some menus/UI that can share the same Game Mode/Player Controller.

3

Okay, but how is that supposed to be helpful?

4

Hello @GraczCourier ,
You could use CommonUI, since it allows your UI to work properly with keyboard, mouse, gamepad, or touch without having to write different logic for each one.

Also, if you want to have specific buttons for each function, you can try using InputActions and InputMappings.

Here’s a simple example of how to use CommonUI, along with some documentation and a link to the learning page, where you can find many examples of how to use it in different situations that might help

Documentation

Learning Site

Example:

First, enable the CommonUI plugin.
Go to Edit - Plugins- Common UI and enable it, then restart the editor.

image
image1671×917 140 KB

Next, in Project Settings, look for Game Viewport Client Class and set it to CommonGameViewportClient, you’ll need to restart the editor again after that.

image
image1535×686 61.3 KB

Create a new Blueprint using CommonActivatableWidget , this will be your main widget.

image
image621×711 52.1 KB

Then, wherever you want the widget to open (in this example, when pressing the 3 key or the Start button on the controller), create the following setup.

image
image1283×603 81.5 KB

In your widget Blueprint, override the function Get Desired Focus Target so that it returns the first button you want to focus on when the menu opens.
This ensures that the focus starts there when using a controller or keyboard.

image
image1721×989 98.3 KB

When closing the widget, you can use something like this.

image
image1494×676 97.6 KB

With this setup, your UI should be fully controllable with a gamepad or keyboard.

I’m also leaving you the documentation about Input Actions and Input Mapping Contexts, which might be useful.

Hope it helps!

1 Like
5

Sorry, but that doesn’t speak to me.

How about making PlayerPawn_Master class with centralized inputs, used for both Menu and Gameplay handling?

And then use input functions to call things inside the widgets?

Get Active Widget

void ACndPlayer_Master::BP_IA_MenuSelectUp()
{

// Derives from CndWgt_MenuPage_Master
CndWgt_MenuPage_Options->BPF_Update_SelectItem(CndHA_Item_Prev);

}

void ACndPlayer_Master::BP_IA_MenuSelectDown()
{

// Derives from CndWgt_MenuPage_Master
CndWgt_MenuPage_Options->BPF_Update_SelectItem(CndHA_Item_Next);

}
6

Redigging this, because I found a way to do this WITHOUT CommonUI, by going the “hard” way.

I needed my Custom Player Pawn Controller with Input Action Pointers and Functions to navigate the Menu.
Firstly fetching the input action and mapping context assets filepaths and assigning them to these functions.

class MYGAME_API ACndPlayer_Master : public APawn

UPROPERTY()
UCndWgt_MenuPage_Master* CndMenu = nullptr;


void ACndPlayer_Master::BP_IA_MenuSelectUp()
{

if (CndMenu)
{

	CndMenu->BPF_Update_SelectListItem(CndWgt_HA_ListItemUp);

}

}

void ACndPlayer_Master::BP_IA_MenuSelectDown()
{

if (CndMenu)
{

	CndMenu->BPF_Update_SelectListItem(CndWgt_HA_ListItemDown);

}

}

Then make Master Page Widget, that stores menu buttons (List Items), navigational data (such as current list item, page, tab) and derives (such as Options Page). Along with ability to cast tasks to the derives.

First what Options Page Derive (for ex.) does, when created, it tries to find the owner of the widget, with the following function.

UFUNCTION(BlueprintCallable, Category = "CndWgt_Menu")
void BPF_InitWidget(ACndPlayer_Master* InOwner);

void UCndWgt_MenuPage_Master::BPF_InitWidget(ACndPlayer_Master* InOwner)
{

WidgetOwner = InOwner;

}

If found, I can navigate any Widget Menu, that derives from Master.

ListItem_Options that derive from ListItem_Master, are collected from the UMG and stored into MasterListItem array, inside Page Master, then filtered based on desired parameters (such as which tab/page they are assigned to - Gameplay, Accessibility, HUD, Graphics, Audio, Controls).

Of course to know which element is active, I had to make highlight animation that plays forward and reverse, and Custom Event for the derived ListItem Widget.

And to do these hover based events and others for other widget parts:

void UCndWgt_MenuParts_ListItem_Master::NativeConstruct()
{
Super::NativeConstruct();

if (Button_ListItem)
{
    Button_ListItem->OnHovered.AddDynamic(this, &UCndWgt_MenuParts_ListItem_Master::BPF_Handle_ListItem_Hovered);
    Button_ListItem->OnUnhovered.AddDynamic(this, &UCndWgt_MenuParts_ListItem_Master::BPF_Handle_ListItem_Unhovered);
}

}

void UCndWgt_MenuParts_ListItem_Master::BPF_Handle_ListItem_Hovered()
{

    BPF_Handle_ListItem_Highlighted(true);

}
void UCndWgt_MenuParts_ListItem_Master::BPF_Handle_ListItem_Unhovered()
{

    BPF_Handle_ListItem_Highlighted(false);

}

	UFUNCTION(BlueprintNativeEvent, Category = "CndWgt_Menu", DisplayName = "On ListItem Highlighted")
	void BPF_Handle_ListItem_Highlighted(bool Highlight);
	virtual void BPF_Handle_ListItem_Highlighted_Implementation(bool Highlight);

void UCndWgt_MenuParts_ListItem_Master::BPF_Handle_ListItem_Highlighted_Implementation(bool Highlight)
{

    BPF_Highlight_Switcher(Highlight);

    ED_OnListItem_Highlighted.Broadcast(Highlight);

}

That’s all I can tell… but it finally works. And all WITHOUT CommonUI.