The open source repository for the action RPG game in development by Sig Productions titled 'Adventures in Lestoria'!
https://forums.lestoria.net
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
712 lines
27 KiB
712 lines
27 KiB
#pragma region License
|
|
/*
|
|
License (OLC-3)
|
|
~~~~~~~~~~~~~~~
|
|
|
|
Copyright 2024 Joshua Sigona <sigonasr2@gmail.com>
|
|
|
|
Redistribution and use in source and binary forms, with or without modification,
|
|
are permitted provided that the following conditions are met:
|
|
|
|
1. Redistributions or derivations of source code must retain the above copyright
|
|
notice, this list of conditions and the following disclaimer.
|
|
|
|
2. Redistributions or derivative works in binary form must reproduce the above
|
|
copyright notice. This list of conditions and the following disclaimer must be
|
|
reproduced in the documentation and/or other materials provided with the distribution.
|
|
|
|
3. Neither the name of the copyright holder nor the names of its contributors may
|
|
be used to endorse or promote products derived from this software without specific
|
|
prior written permission.
|
|
|
|
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
|
|
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
|
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
|
|
SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
|
|
TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
|
|
BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
|
|
ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
SUCH DAMAGE.
|
|
|
|
Portions of this software are copyright © 2023 The FreeType
|
|
Project (www.freetype.org). Please see LICENSE_FT.txt for more information.
|
|
All rights reserved.
|
|
*/
|
|
#pragma endregion
|
|
#include "AdventuresInLestoria.h"
|
|
#include "MenuComponent.h"
|
|
#include "DEFINES.h"
|
|
#include "safemap.h"
|
|
#include "Item.h"
|
|
#include "MenuItemButton.h"
|
|
#include "ScrollableWindowComponent.h"
|
|
#include "RowInventoryScrollableWindowComponent.h"
|
|
#include "MenuItemItemButton.h"
|
|
|
|
INCLUDE_ITEM_CATEGORIES
|
|
INCLUDE_DATA
|
|
|
|
bool Menu::MOUSE_NAVIGATION=true;
|
|
vi2d Menu::lastActiveMousePos{};
|
|
std::vector<Menu*>Menu::stack;
|
|
std::map<MenuType,Menu*>Menu::menus;
|
|
std::string Menu::themeSelection="BlueDefault";
|
|
safeunorderedmap<std::string,Theme>Menu::themes;
|
|
safemap<ITCategory,std::vector<std::weak_ptr<MenuComponent>>>Menu::inventoryListeners;
|
|
safemap<ITCategory,std::vector<std::weak_ptr<MenuComponent>>>Menu::merchantInventoryListeners;
|
|
std::vector<std::weak_ptr<MenuComponent>>Menu::equipStatListeners;
|
|
std::vector<std::weak_ptr<MenuComponent>>Menu::chapterListeners;
|
|
const vf2d Menu::CENTERED = {-456,-456};
|
|
MenuType Menu::lastMenuTypeCreated;
|
|
std::string Menu::lastRegisteredComponent;
|
|
bool Menu::alreadyClicked=false;
|
|
|
|
INCLUDE_game
|
|
INCLUDE_GFX
|
|
INCLUDE_WINDOW_SIZE
|
|
|
|
using A=Attribute;
|
|
|
|
Menu::Menu(vf2d pos,vf2d size)
|
|
:pos(pos==CENTERED?vi2d{WINDOW_SIZE/2-size/2}:vi2d{pos}),size(size){
|
|
this->window=ViewPort::rectViewPort({-24,-24},this->size+vi2d{48,48},this->pos);
|
|
}
|
|
|
|
void Menu::InitializeMenus(){
|
|
#define MAX_MENUS 32
|
|
stack.reserve(MAX_MENUS);
|
|
InitializeConsumableInventoryWindow();
|
|
InitializeClassSelectionWindow();
|
|
InitializeClassInfoWindow();
|
|
InitializeMainMenuWindow();
|
|
InitializeOverworldMapLevelWindow();
|
|
InitializeItemLoadoutWindow();
|
|
InitializeLevelCompleteWindow();
|
|
InitializeOverworldMenuWindow();
|
|
InitializeCharacterMenuWindow();
|
|
InitializeInventoryWindow();
|
|
InitializeMerchantWindow();
|
|
InitializeBuyItemWindow();
|
|
InitializeSellItemWindow();
|
|
InitializeBlacksmithCraftingWindow();
|
|
InitializeCraftItemWindow();
|
|
InitializeConsumableCraftingWindow();
|
|
InitializeConsumableCraftItemWindow();
|
|
InitializeSaveFileWindow();
|
|
InitializeLoadGameWindow();
|
|
InitializeUserIDWindow();
|
|
InitializeSettingsWindow();
|
|
|
|
for(MenuType type=MenuType(int(MenuType::ENUM_START)+1);type<MenuType::ENUM_END;type=MenuType(int(type+1))){
|
|
if(menus.count(type)==0){
|
|
ERR("WARNING! Menu Type "<<type<<" does not exist!")
|
|
}
|
|
for(auto&[key,value]:menus[type]->components){
|
|
value->AfterCreate();
|
|
}
|
|
if(menus.size()>MAX_MENUS)ERR("WARNING! Exceeded maximum expected menu count of "<<MAX_MENUS<<"!");
|
|
}
|
|
}
|
|
|
|
Menu*Menu::CreateMenu(MenuType type,vf2d pos,vf2d size){
|
|
menus[type]=NEW Menu(pos,size);
|
|
menus[type]->type=type;
|
|
lastMenuTypeCreated=type;
|
|
return menus.at(type);
|
|
}
|
|
|
|
void Menu::CheckClickAndPerformMenuSelect(AiL*game){
|
|
if(game->KEY_CONFIRM.Released()&&(MOUSE_NAVIGATION||(!MOUSE_NAVIGATION&&!game->GetMouse(Mouse::LEFT).bReleased&&!game->GetMouse(Mouse::RIGHT).bReleased&&!game->GetMouse(Mouse::MIDDLE).bReleased))){
|
|
if(!GetSelection().expired()){ //If we are on controller/gamepad it's possible we haven't highlighted a button yet, so don't click this button right away.
|
|
MenuSelect(game);
|
|
Menu::alreadyClicked=true;
|
|
}
|
|
}
|
|
}
|
|
|
|
void Menu::HoverMenuSelect(AiL*game){
|
|
if(!game->IsFocused()||selection.expired()||selection.lock()->disabled||selection.lock()->grayedOut||Menu::alreadyClicked)return;
|
|
|
|
if(selection.lock()->draggable){
|
|
if(buttonHoldTime<"ThemeGlobal.MenuHoldTime"_F){
|
|
CheckClickAndPerformMenuSelect(game);
|
|
}else{
|
|
draggingComponent=std::move(selection.lock()->PickUpDraggableItem());
|
|
buttonHoldTime=0;
|
|
}
|
|
}else{
|
|
CheckClickAndPerformMenuSelect(game);
|
|
}
|
|
}
|
|
|
|
void Menu::MenuSelect(AiL*game){
|
|
if(!game->IsFocused()||selection.expired()||selection.lock()->disabled||selection.lock()->grayedOut)return;
|
|
bool buttonStillValid=selection.lock()->onClick(MenuFuncData{*this,game,selection,dynamic_pointer_cast<ScrollableWindowComponent>(selection.lock()->parentComponent.lock())});
|
|
if(buttonStillValid){
|
|
if(selection.lock()->menuDest!=MenuType::ENUM_END){
|
|
if(stack.size()<32){
|
|
stack.push_back(menus[selection.lock()->menuDest]);//Navigate to the next menu.
|
|
}else{
|
|
ERR("WARNING! Exceeded menu stack size limit!")
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void Menu::Update(AiL*game){
|
|
if(!draggingComponent){
|
|
HoverMenuSelect(game);
|
|
}
|
|
|
|
if(!UsingMouseNavigation()&&geom2d::line<float>(lastActiveMousePos,game->GetMousePos()).length()>="ThemeGlobal.MouseActivationDistance"_F){
|
|
SetMouseNavigation(true);
|
|
}
|
|
|
|
for(auto&[key,button]:components){
|
|
if(!button->disabled){
|
|
button->hovered=false;
|
|
}
|
|
}
|
|
|
|
bool itemHovered=false;
|
|
|
|
if(!UsingMouseNavigation()){
|
|
if(!selection.expired()){
|
|
selection.lock()->hovered=true;
|
|
itemHovered=true;
|
|
}
|
|
}else{
|
|
selection={};
|
|
for(auto&[key,component]:components){
|
|
if(component->selectable){
|
|
if(!component->disabled&&!component->grayedOut){
|
|
if(component->GetHoverState(game)){
|
|
component->hovered=true;
|
|
itemHovered=true;
|
|
SetSelection(std::weak_ptr<MenuComponent>(component));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if(itemHovered&&draggingComponent&&!selection.expired()&&!UsingMouseNavigation()&&(game->KEY_CONFIRM.Held())){
|
|
buttonHoldTime+=game->GetElapsedTime();
|
|
}else{
|
|
buttonHoldTime=0;
|
|
}
|
|
|
|
if(draggingComponent){
|
|
auto ClearDraggingComponent=[&](){
|
|
draggingComponent={};
|
|
};
|
|
|
|
if(!UsingMouseNavigation()){
|
|
if(game->KEY_CONFIRM.Released()){
|
|
if(selection.expired()){//Dropping over an empty area.
|
|
ClearDraggingComponent();
|
|
}else
|
|
if(selection.lock()->DropDraggableItem(std::move(draggingComponent))){
|
|
ClearDraggingComponent();
|
|
}
|
|
}
|
|
}else{
|
|
if(game->KEY_CONFIRM.Released()){
|
|
if(selection.expired()){//Dropping over an empty area.
|
|
ClearDraggingComponent();
|
|
}else
|
|
if(selection.lock()->DropDraggableItem(std::move(draggingComponent))){
|
|
ClearDraggingComponent();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
KeyboardButtonNavigation(game,pos);
|
|
|
|
for(auto&[key,component]:components){
|
|
if(component->renderInMain){
|
|
component->_BeforeUpdate(game);
|
|
}
|
|
}
|
|
for(auto&[key,component]:components){
|
|
if(component->renderInMain){
|
|
component->_Update(game);
|
|
}
|
|
}
|
|
};
|
|
|
|
void Menu::Draw(AiL*game){
|
|
if(GetCurrentTheme().IsScaled()){
|
|
DrawScaledWindowBackground(game,pos,size,GetRenderColor());
|
|
}else{
|
|
DrawTiledWindowBackground(game,pos,size,GetRenderColor());
|
|
}
|
|
|
|
std::vector<std::weak_ptr<MenuComponent>>allComponents;
|
|
std::for_each(components.begin(),components.end(),[&](auto&pair){allComponents.push_back(pair.second);});
|
|
std::sort(allComponents.begin(),allComponents.end(),[](std::weak_ptr<MenuComponent>c1,std::weak_ptr<MenuComponent>c2){return c1.lock()->depth>c2.lock()->depth;});
|
|
|
|
if(GetCurrentTheme().IsScaled()){
|
|
DrawScaledWindowBorder(game,pos,size,GetRenderColor());
|
|
}else{
|
|
DrawTiledWindowBorder(game,pos,size,GetRenderColor());
|
|
}
|
|
|
|
for(const auto&component:allComponents){
|
|
if(!component.expired()&&component.lock()->renderInMain){
|
|
component.lock()->_DrawDecal(window,this==Menu::stack.back());
|
|
}
|
|
}
|
|
|
|
if(draggingComponent){
|
|
vf2d offsetPos=draggingComponent->rect.pos;
|
|
if(!UsingMouseNavigation()){
|
|
vf2d drawOffset{};
|
|
if(!selection.expired()){
|
|
if(!selection.lock()->parentComponent.expired()){
|
|
std::weak_ptr<ScrollableWindowComponent>scrollableComponent=DYNAMIC_POINTER_CAST<ScrollableWindowComponent>(selection.lock()->parentComponent.lock());
|
|
drawOffset+=scrollableComponent.lock()->GetScrollAmount();
|
|
}
|
|
draggingComponent->V(A::DRAW_OFFSET)=drawOffset+pos-offsetPos+selection.lock()->rect.pos+vi2d{1,-4};
|
|
}
|
|
draggingComponent->DrawDecal(window,this==Menu::stack.back());
|
|
}else{
|
|
draggingComponent->V(A::DRAW_OFFSET)-offsetPos+game->GetMousePos();
|
|
draggingComponent->DrawDecal(window,this==Menu::stack.back());
|
|
}
|
|
}
|
|
|
|
if(Menu::stack.back()==this){
|
|
helpDisplay.Draw();
|
|
}
|
|
};
|
|
|
|
void Menu::OpenMenu(MenuType menu,bool cover){
|
|
Menu::alreadyClicked=true;
|
|
menus[menu]->cover=cover;
|
|
if(menus[menu]->onOpenFunc){
|
|
Data returnData;
|
|
menus[menu]->onOpenFunc(menu,returnData);
|
|
if(std::holds_alternative<ButtonName>(returnData)&&std::get<ButtonName>(returnData).length()>0||std::holds_alternative<std::weak_ptr<MenuComponent>>(returnData))menus[menu]->SetSelection(returnData,true);
|
|
}
|
|
stack.push_back(menus[menu]);
|
|
}
|
|
|
|
void Menu::KeyboardButtonNavigation(AiL*game,vf2d menuPos){
|
|
std::weak_ptr<MenuComponent>prevSelection=selection;
|
|
|
|
if(!Menu::UsingMouseNavigation()){
|
|
for(auto&[input,data]:inputGroups){
|
|
bool activated=false;
|
|
switch(input.GetEngageType()){
|
|
case Released:{
|
|
activated=input.GetGroup().Released();
|
|
}break;
|
|
case Pressed:{
|
|
activated=input.GetGroup().Pressed();
|
|
}break;
|
|
case Held:{
|
|
activated=input.GetGroup().Held();
|
|
}break;
|
|
case Analog:{
|
|
activated=input.GetGroup().Analog()!=0.f;
|
|
}break;
|
|
[[unlikely]]default:ERR(std::format("WARNING! Unhandled input engage type {}! THIS SHOULD NOT BE HAPPENING!",int(input.GetEngageType())));
|
|
}
|
|
|
|
if(activated){
|
|
auto&action=data.second;
|
|
if(std::holds_alternative<ButtonName>(action))Component<MenuComponent>(type,std::get<ButtonName>(action))->Click();
|
|
else
|
|
if(std::holds_alternative<std::function<void(MenuType)>>(action))std::get<std::function<void(MenuType)>>(action)(type);
|
|
else{
|
|
ERR("WARNING! Navigation data has an unrecognized type or is empty! This should not be happening!")
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if(!selection.expired()){
|
|
std::string selectionButtonName=selection.lock()->GetName();
|
|
if(!selection.lock()->parentComponent.expired()){ //If a component has a parent, then we use the parent as the identifier for what should happen next.
|
|
selectionButtonName=selection.lock()->parentComponent.lock()->GetName();
|
|
}
|
|
|
|
if(navigationGroups.count(selectionButtonName)){
|
|
Navigation nav=navigationGroups[selectionButtonName];
|
|
|
|
if(game->KEY_UP.Pressed()){
|
|
SetMouseNavigation(false);
|
|
if(std::holds_alternative<std::string>(nav.up)&&std::get<std::string>(nav.up).length()>0)SetSelection(std::string_view(std::get<std::string>(nav.up)));
|
|
else
|
|
if(std::holds_alternative<MenuDataFunc>(nav.up)){
|
|
Data returnData;
|
|
std::get<MenuDataFunc>(nav.up)(type,returnData);
|
|
SetSelection(returnData);
|
|
}
|
|
}
|
|
if(game->KEY_DOWN.Pressed()){
|
|
SetMouseNavigation(false);
|
|
if(std::holds_alternative<std::string>(nav.down)&&std::get<std::string>(nav.down).length()>0)SetSelection(std::string_view(std::get<std::string>(nav.down)));
|
|
else
|
|
if(std::holds_alternative<MenuDataFunc>(nav.down)){
|
|
Data returnData;
|
|
std::get<MenuDataFunc>(nav.down)(type,returnData);
|
|
SetSelection(returnData);
|
|
}
|
|
}
|
|
if(game->KEY_LEFT.Pressed()){
|
|
SetMouseNavigation(false);
|
|
if(std::holds_alternative<std::string>(nav.left)&&std::get<std::string>(nav.left).length()>0)SetSelection(std::string_view(std::get<std::string>(nav.left)));
|
|
else
|
|
if(std::holds_alternative<MenuDataFunc>(nav.left)){
|
|
Data returnData;
|
|
std::get<MenuDataFunc>(nav.left)(type,returnData);
|
|
SetSelection(returnData);
|
|
}
|
|
}
|
|
if(game->KEY_RIGHT.Pressed()){
|
|
SetMouseNavigation(false);
|
|
if(std::holds_alternative<std::string>(nav.right)&&std::get<std::string>(nav.right).length()>0)SetSelection(std::string_view(std::get<std::string>(nav.right)));
|
|
else
|
|
if(std::holds_alternative<MenuDataFunc>(nav.right)){
|
|
Data returnData;
|
|
std::get<MenuDataFunc>(nav.right)(type,returnData);
|
|
SetSelection(returnData);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if(game->KEY_UP.Released()||game->KEY_RIGHT.Released()||game->KEY_LEFT.Released()||game->KEY_DOWN.Released()||
|
|
game->KEY_BACK.Released()||game->KEY_CONFIRM.Released()||game->KEY_START.Released()||game->KEY_SELECT.Released()||
|
|
game->KEY_SCROLLDOWN.Released()||game->KEY_SCROLLUP.Released()||game->KEY_SCROLL.Analog()!=0.f){
|
|
SetMouseNavigation(game->GetMouse(Mouse::LEFT).bReleased||game->GetMouse(Mouse::RIGHT).bReleased||game->GetMouse(Mouse::MIDDLE).bReleased); //If a click occurs we use mouse controls.
|
|
buttonHoldTime=0;
|
|
}
|
|
if(&*prevSelection.lock()!=&*selection.lock()){
|
|
if(!selection.expired()&&(selection.lock()->disabled||selection.lock()->grayedOut)){
|
|
bool handled=false;
|
|
if(!UsingMouseNavigation()){
|
|
//Let's transfer some information about our selection being off the screen. Our intention with keyboard controls is that the screen will scroll to the correct location instead.
|
|
//If we return false, then we handled it ourselves, no need to go back to the previous selection.
|
|
if(HandleOutsideDisabledButtonSelection(selection)){
|
|
handled=true;
|
|
}
|
|
}
|
|
if(!handled){
|
|
// If the new selection of a button on this frame is disabled for some reason and we didn't handle it, we need to go back to what we had selected before.
|
|
SetSelection(prevSelection);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void Menu::DrawScaledWindowBorder(AiL*game,vf2d menuPos,vf2d size,Pixel renderColor){
|
|
vf2d patchSize={"Interface.9PatchSize"_f[0],"Interface.9PatchSize"_f[1]};
|
|
|
|
//Upper-Left
|
|
game->DrawPartialDecal(menuPos-patchSize,patchSize,GetPatchPart(0,0).Decal(),{patchSize.x*0,patchSize.y*0},patchSize,renderColor);
|
|
//Upper-Right
|
|
game->DrawPartialDecal(menuPos+vf2d{size.x,-patchSize.y},patchSize,GetPatchPart(2,0).Decal(),{patchSize.x*2,patchSize.y*0},patchSize,renderColor);
|
|
//Bottom-Left
|
|
game->DrawPartialDecal(menuPos+vf2d{-patchSize.x,size.y},patchSize,GetPatchPart(0,2).Decal(),{patchSize.x*0,patchSize.y*2},patchSize,renderColor);
|
|
//Bottom-Right
|
|
game->DrawPartialDecal(menuPos+vf2d{size.x,size.y},patchSize,GetPatchPart(2,2).Decal(),{patchSize.x*2,patchSize.y*2},patchSize,renderColor);
|
|
//Top
|
|
game->DrawPartialDecal(menuPos+vf2d{0,-patchSize.y},vf2d{size.x,patchSize.y},GetPatchPart(1,0).Decal(),{patchSize.x*1,patchSize.y*0},patchSize,renderColor);
|
|
//Left
|
|
game->DrawPartialDecal(menuPos+vf2d{-patchSize.x,0},vf2d{patchSize.x,size.y},GetPatchPart(0,1).Decal(),{patchSize.x*0,patchSize.y*1},patchSize,renderColor);
|
|
//Right
|
|
game->DrawPartialDecal(menuPos+vf2d{size.x,0},vf2d{patchSize.x,size.y},GetPatchPart(2,1).Decal(),{patchSize.x*2,patchSize.y*1},patchSize,renderColor);
|
|
//Bottom
|
|
game->DrawPartialDecal(menuPos+vf2d{0,size.y},vf2d{size.x,patchSize.y},GetPatchPart(1,2).Decal(),{patchSize.x*1,patchSize.y*2},patchSize,renderColor);
|
|
}
|
|
|
|
void Menu::DrawTiledWindowBorder(AiL*game,vf2d menuPos,vf2d size,Pixel renderColor){
|
|
vf2d patchSize={"Interface.9PatchSize"_f[0],"Interface.9PatchSize"_f[1]};
|
|
|
|
//Upper-Left
|
|
game->DrawPartialDecal(menuPos-patchSize,patchSize,GetPatchPart(0,0).Decal(),{0,0},patchSize,renderColor);
|
|
//Upper-Right
|
|
game->DrawPartialDecal(menuPos+vf2d{size.x,-patchSize.y},patchSize,GetPatchPart(2,0).Decal(),{0,0},patchSize,renderColor);
|
|
//Bottom-Left
|
|
game->DrawPartialDecal(menuPos+vf2d{-patchSize.x,size.y},patchSize,GetPatchPart(0,2).Decal(),{0,0},patchSize,renderColor);
|
|
//Bottom-Right
|
|
game->DrawPartialDecal(menuPos+vf2d{size.x,size.y},patchSize,GetPatchPart(2,2).Decal(),{0,0},patchSize,renderColor);
|
|
//Top
|
|
game->DrawPartialDecal(menuPos+vf2d{0,-patchSize.y},vf2d{size.x,patchSize.y},GetPatchPart(1,0).Decal(),{0,0},vf2d{size.x,patchSize.y},renderColor);
|
|
//Left
|
|
game->DrawPartialDecal(menuPos+vf2d{-patchSize.x,0},vf2d{patchSize.x,size.y},GetPatchPart(0,1).Decal(),{0,0},vf2d{patchSize.x,size.y},renderColor);
|
|
//Right
|
|
game->DrawPartialDecal(menuPos+vf2d{size.x,0},vf2d{patchSize.x,size.y},GetPatchPart(2,1).Decal(),{0,0},vf2d{patchSize.x,size.y},renderColor);
|
|
//Bottom
|
|
game->DrawPartialDecal(menuPos+vf2d{0,size.y},vf2d{size.x,patchSize.y},GetPatchPart(1,2).Decal(),{0,0},vf2d{size.x,patchSize.y},renderColor);
|
|
}
|
|
|
|
void Menu::DrawScaledWindowBackground(AiL*game,vf2d menuPos,vf2d size,Pixel renderColor){
|
|
vf2d patchSize={"Interface.9PatchSize"_f[0],"Interface.9PatchSize"_f[1]};
|
|
|
|
//Center
|
|
if(GetCurrentTheme().HasBackground()){
|
|
Decal*back=GetCurrentTheme().GetBackground();
|
|
game->DrawPartialDecal(menuPos,size,back,{0,0},back->sprite->Size(),renderColor);
|
|
}else{
|
|
game->DrawPartialDecal(menuPos,size,GetPatchPart(1,1).Decal(),{patchSize.x*1,patchSize.y*1},patchSize,renderColor);
|
|
}
|
|
}
|
|
|
|
void Menu::DrawTiledWindowBackground(AiL*game,vf2d menuPos,vf2d size,Pixel renderColor){
|
|
vf2d patchSize={"Interface.9PatchSize"_f[0],"Interface.9PatchSize"_f[1]};
|
|
|
|
//Center
|
|
if(GetCurrentTheme().HasBackground()){
|
|
Decal*back=GetCurrentTheme().GetBackground();
|
|
game->DrawPartialDecal(menuPos,size,back,{0,0},size,renderColor);
|
|
}else{
|
|
game->DrawPartialDecal(menuPos,size,GetPatchPart(1,1).Decal(),{0,0},patchSize,renderColor);
|
|
}
|
|
}
|
|
|
|
Renderable&Menu::GetPatchPart(int x,int y){
|
|
return GFX[themeSelection+"_"+std::to_string(x)+std::to_string(y)+".png"];
|
|
}
|
|
|
|
Theme&Menu::GetCurrentTheme(){
|
|
return themes[themeSelection];
|
|
}
|
|
|
|
Pixel Menu::GetRenderColor(){
|
|
bool focused=Menu::stack.back()==this;
|
|
Pixel col=WHITE;
|
|
if(!focused){
|
|
col=WHITE*"ThemeGlobal.MenuUnfocusedColorMult"_F;
|
|
}
|
|
return col;
|
|
}
|
|
|
|
bool Menu::HandleOutsideDisabledButtonSelection(std::weak_ptr<MenuComponent>disabledButton){
|
|
if(!disabledButton.expired()){
|
|
return disabledButton.lock()->parentComponent.lock()->HandleOutsideDisabledButtonSelection(disabledButton);
|
|
}else{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
bool Menu::UsingMouseNavigation(){
|
|
return MOUSE_NAVIGATION;
|
|
};
|
|
void Menu::SetMouseNavigation(bool mouseNavigation){
|
|
if(MOUSE_NAVIGATION&&!mouseNavigation){
|
|
//When mouse navigation was enabled and now needs to be disabled, we store the mouse position.
|
|
lastActiveMousePos=game->GetMousePos();
|
|
if(!keyboardSelection.expired()){
|
|
SetSelection(keyboardSelection);
|
|
}
|
|
}
|
|
MOUSE_NAVIGATION=mouseNavigation;
|
|
};
|
|
|
|
void Menu::InventorySlotsUpdated(ITCategory cat){
|
|
//Update the inventory with a new inventory slot, since there's one additional item to interact with now.
|
|
for(std::weak_ptr<MenuComponent>component:inventoryListeners.at(cat)){
|
|
std::weak_ptr<InventoryScrollableWindowComponent>comp=DYNAMIC_POINTER_CAST<InventoryScrollableWindowComponent>(component.lock()); //HACK ALERT! We're assuming that these must be these classes otherwise they have no reason to even be using these listeners. Make sure that the lowest base class that requires these implements these functions!!!
|
|
comp.lock()->OnInventorySlotsUpdate(cat);
|
|
}
|
|
}
|
|
|
|
void Menu::MerchantInventorySlotsUpdated(ITCategory cat){
|
|
//Update the inventory with a new inventory slot, since there's one additional item to interact with now.
|
|
for(std::weak_ptr<MenuComponent>component:merchantInventoryListeners.at(cat)){
|
|
std::weak_ptr<InventoryScrollableWindowComponent>comp=DYNAMIC_POINTER_CAST<InventoryScrollableWindowComponent>(component.lock()); //HACK ALERT! We're assuming that these must be these classes otherwise they have no reason to even be using these listeners. Make sure that the lowest base class that requires these implements these functions!!!
|
|
comp.lock()->OnInventorySlotsUpdate(cat);
|
|
}
|
|
}
|
|
|
|
void Menu::AddInventoryListener(std::weak_ptr<MenuComponent>component,ITCategory category){
|
|
if(inventoryListeners.count(category)){
|
|
std::vector<std::weak_ptr<MenuComponent>>&listenerList=inventoryListeners.at(category);
|
|
if(std::find_if(listenerList.begin(),listenerList.end(),[&](auto&ptr){return &*ptr.lock()==&*component.lock();})!=listenerList.end()){
|
|
ERR("WARNING! Component "<<component.lock()->name<<" has already been added to the "<<category<<" listener list! There should not be any duplicates!!")
|
|
}
|
|
listenerList.push_back(component);
|
|
}else{
|
|
ERR("WARNING! Inventory category "<<category<<" does not exist!")
|
|
}
|
|
}
|
|
|
|
void Menu::InitializeMenuListenerCategory(const std::string&category){
|
|
inventoryListeners[category];
|
|
merchantInventoryListeners[category];
|
|
}
|
|
|
|
void Menu::AddMerchantInventoryListener(std::weak_ptr<MenuComponent>component,ITCategory category){
|
|
if(merchantInventoryListeners.count(category)){
|
|
std::vector<std::weak_ptr<MenuComponent>>&listenerList=merchantInventoryListeners.at(category);
|
|
if(std::find_if(listenerList.begin(),listenerList.end(),[&](auto&ptr){return &*ptr.lock()==&*component.lock();})!=listenerList.end()){
|
|
ERR("WARNING! Component "<<component.lock()->name<<" has already been added to the "<<category<<" merchant listener list! There should not be any duplicates!!")
|
|
}
|
|
listenerList.push_back(component);
|
|
}else{
|
|
ERR("WARNING! Inventory category "<<category<<" does not exist!")
|
|
}
|
|
}
|
|
|
|
void Menu::AddEquipStatListener(std::weak_ptr<MenuComponent>component){
|
|
if(std::find_if(equipStatListeners.begin(),equipStatListeners.end(),[&](auto&ptr){return &*ptr.lock()==&*component.lock();})!=equipStatListeners.end()){
|
|
ERR("WARNING! Component "<<component.lock()->name<<" has already been added to the Equip Stat listener list! There should not be any duplicates!!")
|
|
}
|
|
equipStatListeners.push_back(component);
|
|
}
|
|
|
|
vf2d Menu::center(){
|
|
return size/2;
|
|
}
|
|
|
|
void Menu::CloseMenu(){
|
|
game->TextEntryEnable(false);
|
|
if(stack.size()>0){
|
|
stack.pop_back();
|
|
}else{
|
|
ERR("WARNING! Trying to close out no menu?? Why are we doing this?")
|
|
}
|
|
}
|
|
|
|
std::pair<MenuType,std::string>Menu::GetMemoryLeakReportInfo(){
|
|
return {lastMenuTypeCreated,lastRegisteredComponent};
|
|
}
|
|
|
|
void Menu::CloseAllMenus(){
|
|
if(stack.size()>0){
|
|
stack.clear();
|
|
}else{
|
|
ERR("WARNING! Trying to close out no menu?? Why are we doing this?")
|
|
}
|
|
}
|
|
|
|
bool Menu::IsMenuOpen(){
|
|
return stack.size()>0;
|
|
}
|
|
|
|
void Menu::CleanupAllMenus(){
|
|
for(auto&[key,value]:Menu::menus){
|
|
Menu*menu=value;
|
|
for(auto&[name,component]:menu->components){
|
|
component->Cleanup();
|
|
}
|
|
menu->components.Reset();
|
|
menu->Cleanup();
|
|
delete menu;
|
|
}
|
|
Menu::menus.clear();
|
|
}
|
|
|
|
void Menu::Cleanup(){}
|
|
|
|
void Menu::DrawThemedWindow(vf2d menuPos,vf2d size,Pixel renderColor){
|
|
if(GetCurrentTheme().IsScaled()){
|
|
DrawScaledWindowBackground(game,menuPos,size,renderColor);
|
|
DrawScaledWindowBorder(game,menuPos,size,renderColor);
|
|
}else{
|
|
DrawTiledWindowBackground(game,menuPos,size,renderColor);
|
|
DrawTiledWindowBorder(game,menuPos,size,renderColor);
|
|
}
|
|
}
|
|
|
|
|
|
void Menu::RecalculateComponentCount(){
|
|
componentCount=components.size();
|
|
}
|
|
|
|
const MenuType Menu::GetType()const{
|
|
return type;
|
|
}
|
|
|
|
void Menu::LockInListeners(){
|
|
inventoryListeners.SetInitialized();
|
|
merchantInventoryListeners.SetInitialized();
|
|
}
|
|
|
|
void Menu::AddChapterListener(std::weak_ptr<MenuComponent>component){
|
|
if(std::find_if(chapterListeners.begin(),chapterListeners.end(),[&](auto&ptr){return &*ptr.lock()==&*component.lock();})!=chapterListeners.end()){
|
|
ERR("WARNING! Component "<<component.lock()->name<<" has already been added to the Chapter listener list! There should not be any duplicates!!")
|
|
}
|
|
chapterListeners.push_back(component);
|
|
}
|
|
|
|
|
|
MenuFuncData::MenuFuncData(Menu&menu,AiL*const game,std::weak_ptr<MenuComponent>component,std::weak_ptr<ScrollableWindowComponent>parentComponent)
|
|
:menu(menu),game(game),component(component),parentComponent(parentComponent){}
|
|
|
|
ToggleFuncData::ToggleFuncData(Menu&menu,AiL*const game,std::weak_ptr<MenuComponent>component,std::weak_ptr<ScrollableWindowComponent>parentComponent,bool checked)
|
|
:MenuFuncData(menu,game,component,parentComponent),checked(checked){}
|
|
|
|
void Menu::SetupKeyboardNavigation(MenuDataFunc onOpen,MenuInputGroups inputGroups,ButtonNavigationGroups navigationGroups){
|
|
this->onOpenFunc=onOpen;
|
|
this->inputGroups=inputGroups;
|
|
helpDisplay.Initialize(inputGroups);
|
|
this->navigationGroups=navigationGroups;
|
|
}
|
|
|
|
const std::weak_ptr<MenuComponent>Menu::GetSelection()const{
|
|
return selection;
|
|
}
|
|
|
|
const std::weak_ptr<MenuComponent>Menu::GetKeySelection()const{
|
|
return keyboardSelection;
|
|
}
|
|
|
|
void Menu::SetSelection(std::weak_ptr<MenuComponent>button,const bool scroll,const bool reset){
|
|
selection=button;
|
|
if(navigationGroups.count(button.lock()->GetName())||
|
|
!button.lock()->parentComponent.expired()&&navigationGroups.count(button.lock()->parentComponent.lock()->GetName())){
|
|
keyboardSelection=button;
|
|
}
|
|
|
|
if(scroll&&!UsingMouseNavigation()&&!button.lock()->parentComponent.expired()){
|
|
auto scrollWindow=button.lock()->parentComponent.lock();
|
|
scrollWindow->HandleOutsideDisabledButtonSelection(Menu::menus[button.lock()->parentMenu]->components[button.lock()->GetName()]);
|
|
scrollWindow->selectionIndex=scrollWindow->GetComponentIndex(selection);
|
|
}
|
|
|
|
if(!selection.lock()->parentComponent.expired()&&reset){
|
|
auto scrollWindow=selection.lock()->parentComponent.lock();
|
|
scrollWindow->targetScrollOffset.y=0.f;
|
|
scrollWindow->selectionIndex=0.f;
|
|
}
|
|
}
|
|
|
|
void Menu::SetSelection(std::string_view button,const bool scroll,const bool reset){
|
|
selection=Component<MenuComponent>(type,std::string(button));
|
|
if(navigationGroups.count(std::string(button))||
|
|
!selection.lock()->parentComponent.expired()&&navigationGroups.count(selection.lock()->parentComponent.lock()->GetName())){
|
|
keyboardSelection=selection;
|
|
}
|
|
|
|
if(scroll&&!UsingMouseNavigation()&&!selection.lock()->parentComponent.expired()){
|
|
auto scrollWindow=selection.lock()->parentComponent.lock();
|
|
scrollWindow->HandleOutsideDisabledButtonSelection(Menu::menus[selection.lock()->parentMenu]->components[selection.lock()->GetName()]);
|
|
scrollWindow->selectionIndex=scrollWindow->GetComponentIndex(selection);
|
|
}
|
|
|
|
if(!selection.lock()->parentComponent.expired()&&reset){
|
|
auto scrollWindow=selection.lock()->parentComponent.lock();
|
|
scrollWindow->targetScrollOffset.y=0.f;
|
|
scrollWindow->selectionIndex=0.f;
|
|
}
|
|
}
|
|
|
|
void Menu::SetSelection(std::variant<std::string,std::weak_ptr<MenuComponent>>button,const bool reset){
|
|
if(std::holds_alternative<std::string>(button)){
|
|
SetSelection(std::string_view(std::get<std::string>(button)),true,reset);
|
|
}else
|
|
if(std::holds_alternative<std::weak_ptr<MenuComponent>>(button)){
|
|
SetSelection(std::get<std::weak_ptr<MenuComponent>>(button),true,reset);
|
|
}else{
|
|
ERR("WARNING! Specified menu opening function does not hold neither a string nor a pointer to a component to use!");
|
|
}
|
|
} |