hud.cpp

/* xoreos - A reimplementation of BioWare's Aurora engine
 *
 * xoreos is the legal property of its developers, whose names
 * can be found in the AUTHORS file distributed with this source
 * distribution.
 *
 * xoreos is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 3
 * of the License, or (at your option) any later version.
 *
 * xoreos is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with xoreos. If not, see <http://www.gnu.org/licenses/>.
 */

/** @file
 *  The ingame HUD.
 */

#include <set>

#include "src/common/strutil.h"

#include "src/aurora/resman.h"

#include "src/graphics/windowman.h"
#include "src/graphics/graphics.h"

#include "src/engines/kotor/gui/ingame/hud.h"
#include "src/engines/aurora/kotorjadegui/label.h"
#include "src/engines/aurora/kotorjadegui/progressbar.h"

namespace Engines {

namespace KotOR {

enum Position {
	kPositionUpperLeft,
	kPositionUpperRight,
	kPositionLowerLeft,
	kPositionLowerRight,
	kPositionUpperMid,
	kPositionLowerMid,
	kPositionNotSpecified
};

struct KnownWidget {
	const char *name;
	bool visible;
	Position position;
};

static const KnownWidget kKnownWidgets[] = {
	{ "LBL_MAPVIEW", true, kPositionUpperLeft },
	{ "LBL_MAPBORDER", true, kPositionUpperLeft },
	{ "LBL_ARROW", true, kPositionUpperLeft },
	{ "LBL_PLOTXP", false, kPositionUpperLeft },
	{ "LBL_STEALTHXP", false, kPositionUpperLeft },
	{ "LBL_CASH", false, kPositionUpperLeft },
	{ "LBL_JOURNAL", false, kPositionUpperLeft },
	{ "LBL_LIGHTSHIFT", false, kPositionUpperLeft },
	{ "LBL_DARKSHIFT", false, kPositionUpperLeft },
	{ "LBL_ITEMRCVD", false, kPositionUpperLeft },
	{ "LBL_ITEMLOST", false, kPositionUpperLeft },

	{ "LBL_MENUBG", true, kPositionUpperRight },
	{ "BTN_MSG", true, kPositionUpperRight },
	{ "BTN_ABI", true, kPositionUpperRight },
	{ "BTN_JOU", true, kPositionUpperRight },
	{ "BTN_INV", true, kPositionUpperRight },
	{ "BTN_CHAR", true, kPositionUpperRight },
	{ "BTN_EQU", true, kPositionUpperRight },
	{ "BTN_MAP", true, kPositionUpperRight },
	{ "BTN_OPT", true, kPositionUpperRight },

	{ "LBL_MOULDING1", true, kPositionLowerLeft },
	{ "TB_SOLO", true, kPositionLowerLeft },
	{ "TB_STEALTH", true, kPositionLowerLeft },
	{ "TB_PAUSE", true, kPositionLowerLeft },
	{ "LBL_CHAR1", false, kPositionLowerLeft },
	{ "LBL_CHAR2", false, kPositionLowerLeft },
	{ "LBL_CHAR3", false, kPositionLowerLeft },
	{ "LBL_DEBILATATED1", false, kPositionLowerLeft },
	{ "LBL_DEBILATATED2", false, kPositionLowerLeft },
	{ "LBL_DEBILATATED3", false, kPositionLowerLeft },
	{ "LBL_DISABLE1", false, kPositionLowerLeft },
	{ "LBL_DISABLE2", false, kPositionLowerLeft },
	{ "LBL_DISABLE3", false, kPositionLowerLeft },
	{ "LBL_CMBTEFCTRED1", false, kPositionLowerLeft },
	{ "LBL_CMBTEFCTRED2", false, kPositionLowerLeft },
	{ "LBL_CMBTEFCTRED3", false, kPositionLowerLeft },
	{ "LBL_CMBTEFCTINC1", false, kPositionLowerLeft },
	{ "LBL_CMBTEFCTINC2", false, kPositionLowerLeft },
	{ "LBL_CMBTEFCTINC3", false, kPositionLowerLeft },
	{ "LBL_BACK1", false, kPositionLowerLeft },
	{ "LBL_BACK2", false, kPositionLowerLeft },
	{ "LBL_BACK3", false, kPositionLowerLeft },
	{ "BTN_CHAR1", false, kPositionLowerLeft },
	{ "BTN_CHAR2", false, kPositionLowerLeft },
	{ "BTN_CHAR3", false, kPositionLowerLeft },
	{ "LBL_LVLUPBG1", false, kPositionLowerLeft },
	{ "LBL_LVLUPBG2", false, kPositionLowerLeft },
	{ "LBL_LVLUPBG3", false, kPositionLowerLeft },
	{ "LBL_LEVELUP1", false, kPositionLowerLeft },
	{ "LBL_LEVELUP2", false, kPositionLowerLeft },
	{ "LBL_LEVELUP3", false, kPositionLowerLeft },
	{ "PB_VIT1", false, kPositionLowerLeft },
	{ "PB_VIT2", false, kPositionLowerLeft },
	{ "PB_VIT3", false, kPositionLowerLeft },
	{ "PB_FORCE1", false, kPositionLowerLeft },
	{ "PB_FORCE2", false, kPositionLowerLeft },
	{ "PB_FORCE3", false, kPositionLowerLeft },

	{ "LBL_MOULDING3", true, kPositionLowerRight },
	{ "BTN_ACTIONDOWN0", true, kPositionLowerRight },
	{ "BTN_ACTIONDOWN1", true, kPositionLowerRight },
	{ "BTN_ACTIONDOWN2", true, kPositionLowerRight },
	{ "BTN_ACTIONDOWN3", true, kPositionLowerRight },
	{ "BTN_ACTIONUP0", true, kPositionLowerRight },
	{ "BTN_ACTIONUP1", true, kPositionLowerRight },
	{ "BTN_ACTIONUP2", true, kPositionLowerRight },
	{ "BTN_ACTIONUP3", true, kPositionLowerRight },
	{ "BTN_ACTION0", true, kPositionLowerRight },
	{ "BTN_ACTION1", true, kPositionLowerRight },
	{ "BTN_ACTION2", true, kPositionLowerRight },
	{ "BTN_ACTION3", true, kPositionLowerRight },
	{ "LBL_ACTION0", true, kPositionLowerRight },
	{ "LBL_ACTION1", true, kPositionLowerRight },
	{ "LBL_ACTION2", true, kPositionLowerRight },
	{ "LBL_ACTION3", true, kPositionLowerRight },
	{ "LBL_ACTIONDESC", false, kPositionLowerRight },
	{ "LBL_ACTIONDESCBG", false, kPositionLowerRight },

	{ "LBL_CMBTMSGBG", false, kPositionUpperMid },
	{ "LBL_CMBTMODEMSG", false, kPositionUpperMid },

	{ "LBL_COMBATBG1", false, kPositionLowerMid },
	{ "LBL_COMBATBG2", false, kPositionLowerMid },
	{ "LBL_COMBATBG3", false, kPositionLowerMid },
	{ "LBL_QUEUE0", false, kPositionLowerMid },
	{ "LBL_QUEUE1", false, kPositionLowerMid },
	{ "LBL_QUEUE2", false, kPositionLowerMid },
	{ "LBL_QUEUE3", false, kPositionLowerMid },
	{ "BTN_CLEARALL", false, kPositionLowerMid },
	{ "BTN_CLEARONE", false, kPositionLowerMid },
	{ "BTN_CLEARONE2", false, kPositionLowerMid },

	{ "PB_HEALTH", false, kPositionNotSpecified },
	{ "LBL_HEALTHBG", false, kPositionNotSpecified },
	{ "LBL_NAMEBG", false, kPositionNotSpecified },
	{ "LBL_NAME", false, kPositionNotSpecified },
	{ "BTN_TARGET0", false, kPositionNotSpecified },
	{ "BTN_TARGET1", false, kPositionNotSpecified },
	{ "BTN_TARGET2", false, kPositionNotSpecified },
	{ "BTN_TARGETUP0", false, kPositionNotSpecified },
	{ "BTN_TARGETUP1", false, kPositionNotSpecified },
	{ "BTN_TARGETUP2", false, kPositionNotSpecified },
	{ "BTN_TARGETDOWN0", false, kPositionNotSpecified },
	{ "BTN_TARGETDOWN1", false, kPositionNotSpecified },
	{ "BTN_TARGETDOWN2", false, kPositionNotSpecified },

	// TODO: Add xbox ui widgets.
};

struct Resolution {
	int width;
	int height;

	const char *gui;

	bool operator<(const Resolution &x) const {
		if (width == x.width)
			return height < x.height;

		return width < x.width;
	}
};

static const Resolution kResolution[] = {
	{  800,  600, "mipc28x6"   },
	{  800,  600, "mi8x6"      },
	{ 1024,  768, "mipc210x7"  },
	{ 1280,  960, "mipc212x9"  },
	{ 1280, 1024, "mipc212x10" },
	{ 1600, 1200, "mipc216x12" },
};

HUD::HUD(Module &module, Engines::Console *console)
		: GUI(console),
		  _module(&module),
		  _menu(module, console) {

	std::set<Resolution> availableRes;

	for (size_t i = 0; i < ARRAYSIZE(kResolution); i++)
		if (ResMan.hasResource(kResolution[i].gui, Aurora::kFileTypeGUI))
			availableRes.insert(kResolution[i]);

	const int wWidth  = WindowMan.getWindowWidth();
	const int wHeight = WindowMan.getWindowHeight();

	const Resolution *foundRes = 0;
	for (std::set<Resolution>::const_iterator it = availableRes.begin(); it != availableRes.end(); ++it)
		if (it->width == wWidth && it->height == wHeight)
			foundRes = &*it;

	bool scale = false;
	if (!foundRes) {
		if (ResMan.hasResource("mipc28x6", Aurora::kFileTypeGUI))
			foundRes = &kResolution[0];
		else if (ResMan.hasResource("mi8x6", Aurora::kFileTypeGUI))
			foundRes = &kResolution[1];
		else
			throw Common::Exception("No gui with 800x600 resolution found.");
		scale = true;
	}

	load(foundRes->gui);

	// Make all the widgets invisible and scale them if needed.
	for (size_t i = 0; i < ARRAYSIZE(kKnownWidgets); i++) {
		Widget *widget = getWidget(kKnownWidgets[i].name);
		if (!widget)
			continue;

		widget->setInvisible(!kKnownWidgets[i].visible);

		float x, y, z;
		if (scale) {
			switch (kKnownWidgets[i].position) {
				case kPositionUpperLeft:
					widget->getPosition(x, y, z);
					widget->setPosition(-wWidth/2 + (400 + x), wHeight/2 - (300 - y), z);
					break;
				case kPositionUpperRight:
					widget->getPosition(x, y, z);
					widget->setPosition(wWidth/2 - (400 - x), wHeight/2 - (300 - y), z);
					break;
				case kPositionUpperMid:
					widget->getPosition(x, y, z);
					widget->setPosition(x, wHeight/2 - (300 - y), z);
					break;
				case kPositionLowerLeft:
					widget->getPosition(x, y, z);
					widget->setPosition(-wWidth/2 + (400 + x), -wHeight/2 + (300 + y), z);
					break;
				case kPositionLowerRight:
					widget->getPosition(x, y, z);
					widget->setPosition(wWidth/2 - (400 - x), -wHeight/2 + (300 + y), z);
					break;
				case kPositionLowerMid:
					widget->getPosition(x, y, z);
					widget->setPosition(x, -wHeight/2 + (300 + y), z);
					break;
				default:
					break;
			}
		}
	}
}

void HUD::setReturnStrref(uint32 id) {
	_menu.setReturnStrref(id);
}

void HUD::setReturnQueryStrref(uint32 id) {
	_menu.setReturnQueryStrref(id);
}

void HUD::setReturnEnabled(bool enabled) {
	_menu.setReturnEnabled(enabled);
}

void HUD::setMinimap(const Common::UString &map, int northAxis,
                     float worldPt1X, float worldPt1Y, float worldPt2X, float worldPt2Y,
                     float mapPt1X, float mapPt1Y, float mapPt2X, float mapPt2Y) {

	WidgetLabel *mapView = getLabel("LBL_MAPVIEW");
	if (!mapView) {
		warning("No such GUI element \"LBL_MAPVIEW\"");
		return;
	}

	GfxMan.lockFrame();

	_minimap.reset(new Minimap(map, northAxis, mapPt1X, mapPt1Y, mapPt2X, mapPt2Y, worldPt1X, worldPt1Y, worldPt2X, worldPt2Y));
	mapView->setSubScene(_minimap.get());

	GfxMan.unlockFrame();
}

void HUD::setPosition(float x, float y) {
	if (_minimap)
		_minimap->setPosition(x, y);
}

void HUD::showContainer(Inventory &inv) {
	_container.reset(new ContainerMenu());
	_container->fillFromInventory(inv);

	if (sub(*_container, kStartCodeNone, true, false) == 1) {
		Inventory &partyInventory = _module->getPC()->getInventory();

		const std::map<Common::UString, InventoryItem> &items = inv.getItems();
		for (std::map<Common::UString, InventoryItem>::const_iterator i = items.begin();
				i != items.end(); ++i) {
			partyInventory.addItem(i->first, i->second.count);
		}

		inv.removeAllItems();
	}
}

void HUD::setPortrait(uint8 n, bool visible, const Common::UString &portrait) {
	WidgetLabel *labelBack = getLabel(Common::UString("LBL_BACK") + Common::composeString(n));
	if (labelBack)
		labelBack->setInvisible(!visible);

	WidgetLabel *labelChar = getLabel(Common::UString("LBL_CHAR") + Common::composeString(n));
	if (labelChar) {
		labelChar->setInvisible(!visible);
		labelChar->setFill(portrait);
	}

	WidgetProgressbar *vitals = getProgressbar(Common::UString("PB_VIT") + Common::composeString(n));
	if (vitals)
		vitals->setInvisible(!visible);
}

void HUD::setPartyLeader(Creature *creature) {
	setPortrait(1, creature != 0, creature ? creature->getPortrait() : "");
}

void HUD::setPartyMember1(Creature *creature) {
	setPortrait(2, creature != 0, creature ? creature->getPortrait() : "");
}

void HUD::setPartyMember2(Creature *creature) {
	setPortrait(3, creature != 0, creature ? creature->getPortrait() : "");
}

void HUD::initWidget(Engines::Widget &widget) {
	// Don't know what these two are doing, but they spawn over the complete screen blocking the 3d picking.
	if (widget.getTag() == "LBL_MAP")
		widget.setInvisible(true);
	if (widget.getTag() == "LBL_ARROW_MARGIN")
		widget.setInvisible(true);

	// TGuiPanel needs to be disabled in order to ensure, it does not block 3d picking.
	if (widget.getTag() == "TGuiPanel")
		widget.setInvisible(true);

	// First disable all portraits
	if (widget.getTag().contains("LBL_CHAR"))
		widget.setInvisible(true);
	if (widget.getTag().contains("BTN_CHAR") && widget.getTag().size() == 9)
		widget.setInvisible(true);
	if (widget.getTag().contains("LBL_BACK"))
		widget.setInvisible(true);
	if (widget.getTag().contains("PB_VIT"))
		widget.setInvisible(true);
	if (widget.getTag().contains("PB_FORCE"))
		widget.setInvisible(true);
}

void HUD::callbackActive(Widget &widget) {
	_menu.showMenu(widget.getTag());
	sub(_menu);
}

} // End of namespace KotOR

} // End of namespace Engines