MinecraftLegacyMinigames/Minecraft.Client/Common/UI/UIScene_MiniGamesMenu.cpp

#include "stdafx.h"
#include "UI.h"
#include "UIScene_MiniGamesMenu.h"

#include "..\..\MinecraftServer.h"
#include "..\Network\SessionInfo.h"
//#include <TexturePack.h>
//#include <TexturePackRepository.h>

bool LoadPngFile(const wchar_t* path, PBYTE& data, DWORD& size) {
	HANDLE h = CreateFileW(path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
	if (h == INVALID_HANDLE_VALUE) return false;
	size = GetFileSize(h, NULL);
	data = new BYTE[size];
	DWORD read = 0;
	ReadFile(h, data, size, &read, NULL);
	CloseHandle(h);
	return read == size;
}

#define JOIN_LOAD_ONLINE_TIMER_ID 0
#define JOIN_LOAD_ONLINE_TIMER_TIME 100

UIScene_MiniGamesMenu::UIScene_MiniGamesMenu(int iPad, void* initData, UILayer* parentLayer) : UIScene(iPad, parentLayer)
{
	initialiseMovie();
	app.SetLiveLinkRequired(true);

	m_buttonListSaves.init(eControl_SavesList);
	m_buttonListGames.init(eControl_GamesList);

	m_labelSavesListTitle.init(IDS_MINIGAMES);           // ← change string ID if you have a better one
	/*m_labelJoinListTitle.init(IDS_JOIN_GAME);
	m_labelNoGames.init(IDS_NO_GAMES_FOUND);
	m_labelNoGames.setVisible(false);*/

	m_controlSavesTimer.setVisible(false);   // no save loading
	m_controlJoinTimer.setVisible(true);

	m_bIgnoreInput = false;
	m_bInParty = false;
	m_bShowingPartyGamesOnly = false;
	m_currentSessions = NULL;
	m_bMultiplayerAllowed = ProfileManager.IsSignedInLive(m_iPad) && ProfileManager.AllowedToPlayMultiplayer(m_iPad);

	Initialise();
	UpdateGamesList();

	g_NetworkManager.SetSessionsUpdatedCallback(&UpdateGamesListCallback, this);
	m_initData = new JoinMenuInitData();
	MinecraftServer::resetFlags();
}

UIScene_MiniGamesMenu::~UIScene_MiniGamesMenu()
{
	g_NetworkManager.SetSessionsUpdatedCallback(NULL, NULL);
	app.SetLiveLinkRequired(false);

	if (m_currentSessions)
	{
		for (auto& it : *m_currentSessions) delete it;
		delete m_currentSessions;
	}
	if (m_initData) delete m_initData;
}

void UIScene_MiniGamesMenu::updateTooltips()
{
	int iY = -1, iLB = -1;

	if (DoesGamesListHaveFocus() && m_buttonListGames.getItemCount() > 0)
		iY = IDS_TOOLTIPS_VIEW_GAMERCARD;

	if (m_bInParty)
		iLB = m_bShowingPartyGamesOnly ? IDS_TOOLTIPS_ALL_GAMES : IDS_TOOLTIPS_PARTY_GAMES;

	ui.SetTooltips(DEFAULT_XUI_MENU_USER, IDS_TOOLTIPS_SELECT, IDS_TOOLTIPS_BACK, -1, iY, -1, -1, iLB, -1);
}

void UIScene_MiniGamesMenu::updateComponents()
{
	m_parentLayer->showComponent(m_iPad, eUIComponent_Panorama, true);
	m_parentLayer->showComponent(m_iPad, eUIComponent_Logo, true);
}

void UIScene_MiniGamesMenu::handleDestroy()
{
#if defined(__PS3__) || defined(__ORBIS__) || defined(_DURANGO)
	InputManager.DestroyKeyboard();
#endif
}

void UIScene_MiniGamesMenu::handleGainFocus(bool navBack)
{
	UIScene::handleGainFocus(navBack);
	updateTooltips();
	addTimer(JOIN_LOAD_ONLINE_TIMER_ID, JOIN_LOAD_ONLINE_TIMER_TIME);

	if (navBack)
	{
		m_bMultiplayerAllowed = ProfileManager.IsSignedInLive(m_iPad) && ProfileManager.AllowedToPlayMultiplayer(m_iPad);
		m_bIgnoreInput = false;
	}
}

void UIScene_MiniGamesMenu::handleLoseFocus()
{
	killTimer(JOIN_LOAD_ONLINE_TIMER_ID);
}

wstring UIScene_MiniGamesMenu::getMoviePath()
{
	return L"DLCOffersMenu";   // ← change to L"LoadOrJoinMenu" if you want to reuse the old Iggy file
}

void UIScene_MiniGamesMenu::tick()
{
	UIScene::tick();
	// only online list logic remains
}

void UIScene_MiniGamesMenu::Initialise()
{
	m_iDefaultButtonsC = 0;
	AddDefaultButtons();
	m_bIgnoreInput = false;
}

void UIScene_MiniGamesMenu::AddDefaultButtons()
{
	m_iDefaultButtonsC = 0;
	m_generators.clear();

	//Minecraft* pMinecraft = Minecraft::GetInstance();
	//TexturePack* tp = pMinecraft->skins->getTexturePackByIndex(0);

	//DWORD dwImageBytes;
	//PBYTE pbImageData = tp->getPackIcon(dwImageBytes);

	//registerSubstitutionTexture(L"iconGYAT", pbImageData, dwImageBytes);
	//

	//// Create New Mini Game (exactly like the old "Create New World")
	//m_buttonListSaves.addItem(L"Battle", L"iconGYAT");
	//m_iDefaultButtonsC++;
	//m_buttonListSaves.addItem(L"Tumble", L"iconGYAT");
	//m_iDefaultButtonsC++;
	//m_buttonListSaves.addItem(L"Glide", L"iconGYAT");
	//m_iDefaultButtonsC++;

	PBYTE data = nullptr; DWORD size = 0;
	if (LoadPngFile(L"Battle.png", data, size)) {
		registerSubstitutionTexture(L"mini_battle", data, size);
		m_buttonListSaves.addItem(L"Battle", L"mini_battle");
		m_iDefaultButtonsC++;
		delete[] data;
	}

	if (LoadPngFile(L"Tumble.png", data, size)) {
		registerSubstitutionTexture(L"mini_tumble", data, size);
		m_buttonListSaves.addItem(L"Tumble", L"mini_tumble");
		m_iDefaultButtonsC++;
		delete[] data;
	}

	if (LoadPngFile(L"Glide.png", data, size)) {
		registerSubstitutionTexture(L"mini_glide", data, size);
		m_buttonListSaves.addItem(L"Glide", L"mini_glide");
		m_iDefaultButtonsC++;
		delete[] data;
	}

	// Pre-made mini-game templates (same system Legacy Console used for mash-ups)
	for (LevelGenerationOptions* levelGen : *app.getLevelGenerators())
	{
		//if (levelGen->isMiniGame()) // you can add this flag or filter however you like
		//{
		//	m_buttonListSaves.addItem(levelGen->getWorldName());
		//	m_generators.push_back(levelGen);
		//	m_iDefaultButtonsC++;
		//}
	}
}

void UIScene_MiniGamesMenu::UpdateGamesList()
{
	/*if (m_currentSessions)
	{
		for (auto& it : *m_currentSessions) delete it;
		delete m_currentSessions;
	}
	m_currentSessions = g_NetworkManager.GetCurrentSessions();

	m_buttonListGames.clearList();
	if (m_currentSessions && !m_currentSessions->empty())
	{
		m_controlJoinTimer.setVisible(false);
		m_labelNoGames.setVisible(false);
		for (auto* pInfo : *m_currentSessions)
			m_buttonListGames.addItem(pInfo->sessionName, L"");
	}
	else
	{
		m_controlJoinTimer.setVisible(true);
		m_labelNoGames.setVisible(true);
	}*/
}

void UIScene_MiniGamesMenu::UpdateGamesListCallback(LPVOID pParam)
{
	if (pParam) ((UIScene_MiniGamesMenu*)pParam)->UpdateGamesList();
}

void UIScene_MiniGamesMenu::CheckAndJoinGame(int gameIndex)
{
	if (gameIndex < 0 || !m_currentSessions || gameIndex >= (int)m_currentSessions->size()) return;
	//ui.NavigateToScene(m_iPad, eUIScene_JoiningGame, m_currentSessions->at(gameIndex)); // adjust scene if needed
}

void UIScene_MiniGamesMenu::LoadLevelGen(LevelGenerationOptions* levelGen)
{
	// same logic you already had in the original class
	// (just call whatever you used before for mash-ups / templates)
}

void UIScene_MiniGamesMenu::handlePress(F64 controlId, F64 childId)
{
	if (controlId == eControl_SavesList)
	{
		if (childId == CREATE_BUTTON_INDEX)
		{
			// Create new mini game world (you can navigate to the create-world scene with mini-game preset)
			//ui.NavigateToScene(m_iPad, eUIScene_CreateWorld, /* mini-game init data */ nullptr);
		}
		else if (childId < m_iDefaultButtonsC)
		{
			LevelGenerationOptions* levelGen = m_generators.at(childId - 1);
			LoadLevelGen(levelGen);
		}
	}
	else if (controlId == eControl_GamesList)
	{
		CheckAndJoinGame((int)childId);
	}
}

void UIScene_MiniGamesMenu::handleInput(int iPad, int key, bool repeat, bool pressed, bool released, bool& handled)
{
	if (m_bIgnoreInput) return;

	ui.AnimateKeyPress(m_iPad, key, repeat, pressed, released);

	switch (key)
	{
	case ACTION_MENU_CANCEL:
		if (pressed) { navigateBack(); handled = true; }
		break;

	case ACTION_MENU_OK:
	case ACTION_MENU_UP:
	case ACTION_MENU_DOWN:
	case ACTION_MENU_PAGEUP:
	case ACTION_MENU_PAGEDOWN:
		sendInputToMovie(key, repeat, pressed, released);
		handled = true;
		break;

	case ACTION_MENU_LEFT:
	case ACTION_MENU_RIGHT:
		sendInputToMovie(key, repeat, pressed, released);
		break;

	case ACTION_MENU_Y: // optional: view invites (kept because it was in legacy)
		if (pressed && iPad == ProfileManager.GetPrimaryPad())
			m_eAction = eAction_ViewInvites;
		break;
	}
}

void UIScene_MiniGamesMenu::handleFocusChange(F64 controlId, F64 childId)
{
	updateTooltips();
}

void UIScene_MiniGamesMenu::handleTimerComplete(int id)
{
	// No timers needed for Mini Games menu
}

void UIScene_MiniGamesMenu::handleInitFocus(F64 controlId, F64 childId)
{
	updateTooltips();
}

bool UIScene_MiniGamesMenu::DoesSavesListHaveFocus()
{
	return getControlFocus() == eControl_SavesList;
}

bool UIScene_MiniGamesMenu::DoesGamesListHaveFocus()
{
	return getControlFocus() == eControl_GamesList;
}