evert/osb
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
986db9cfc5
osb/source/frontend/StarMainInterface.cpp

1597 lines
65 KiB
C++
Raw Normal View History

everything everywhere all at once
2023-06-20 04:33:09 +00:00
#include "StarMainInterface.hpp"
#include "StarJsonExtra.hpp"
#include "StarLogging.hpp"
#include "StarLexicalCast.hpp"
#include "StarContainerInterface.hpp"
#include "StarCraftingInterface.hpp"
#include "StarMerchantInterface.hpp"
#include "StarRoot.hpp"
#include "StarUniverseClient.hpp"
#include "StarCodexInterface.hpp"
#include "StarSongbookInterface.hpp"
#include "StarQuestInterface.hpp"
#include "StarQuestManager.hpp"
#include "StarPopupInterface.hpp"
#include "StarConfirmationDialog.hpp"
#include "StarJoinRequestDialog.hpp"
#include "StarImageMetadataDatabase.hpp"
#include "StarGuiReader.hpp"
#include "StarPaneManager.hpp"
#include "StarClientCommandProcessor.hpp"
#include "StarChat.hpp"
#include "StarOptionsMenu.hpp"
#include "StarActionBar.hpp"
#include "StarWireInterface.hpp"
#include "StarTeamBar.hpp"
#include "StarStatusPane.hpp"
Start of Interface callbacks, starting with a bindCanvas function for the whole screen
2023-07-04 09:27:16 +00:00
#include "StarCanvasWidget.hpp"
everything everywhere all at once
2023-06-20 04:33:09 +00:00
#include "StarLabelWidget.hpp"
#include "StarItemSlotWidget.hpp"
#include "StarPlayer.hpp"
#include "StarPlayerLog.hpp"
#include "StarMonster.hpp"
#include "StarItemDrop.hpp"
#include "StarAssets.hpp"
#include "StarPlayerInventory.hpp"
#include "StarCelestialDatabase.hpp"
#include "StarItem.hpp"
#include "StarAiInterface.hpp"
#include "StarDrawable.hpp"
#include "StarFireableItem.hpp"
#include "StarClientContext.hpp"
#include "StarToolUserEntity.hpp"
#include "StarTeleportDialog.hpp"
#include "StarCinematic.hpp"
#include "StarNameplatePainter.hpp"
#include "StarQuestIndicatorPainter.hpp"
#include "StarScriptPane.hpp"
#include "StarContainerEntity.hpp"
#include "StarWarpTargetEntity.hpp"
#include "StarPlayerUniverseMap.hpp"
#include "StarWorldTemplate.hpp"
#include "StarRadioMessagePopup.hpp"
#include "StarAiTypes.hpp"
#include "StarActiveItem.hpp"
#include "StarInspectionTool.hpp"
#include "StarQuestTracker.hpp"
#include "StarContainerInteractor.hpp"
#include "StarChatBubbleManager.hpp"
#include "StarNpc.hpp"
namespace Star {
GuiMessage::GuiMessage() : message(), cooldown(), springState() {}
Initial voice HUD indicator setup
2023-07-17 12:20:39 +00:00
GuiMessage::GuiMessage(String const& message, float cooldown, float spring)
: message(message), cooldown(cooldown), springState(spring) {}
everything everywhere all at once
2023-06-20 04:33:09 +00:00
Fixed some uninitialized members May have caused undefined behavior in few cases, as most of the fixed members were used before being initialized.
2024-02-19 22:29:39 +00:00
MainInterface::MainInterface(UniverseClientPtr client, WorldPainterPtr painter, CinematicPtr cinematicOverlay)
: m_guiContext(GuiContext::singletonPtr())
, m_config(MainInterfaceConfig::loadFromAssets())
, m_client(std::move(client))
, m_worldPainter(std::move(painter))
, m_cinematicOverlay(std::move(cinematicOverlay))
, m_containerInteractor(make_shared<ContainerInteractor>())
{
everything everywhere all at once
2023-06-20 04:33:09 +00:00
GuiReader itemSlotReader;
m_cursorItem = convert<ItemSlotWidget>(itemSlotReader.makeSingle("cursorItemSlot", m_config->cursorItemSlot));
m_planetNameTimer = GameTimer(m_config->planetNameTime);
m_debugSpatialClearTimer = GameTimer(m_config->debugSpatialClearTime);
m_debugMapClearTimer = GameTimer(m_config->debugMapClearTime);
m_stickyTargetingTimer = GameTimer(m_config->monsterHealthBarTime);
m_inventoryWindow = make_shared<InventoryPane>(this, m_client->mainPlayer(), m_containerInteractor);
m_paneManager.registerPane(MainInterfacePanes::Inventory, PaneLayer::Window, m_inventoryWindow, [this](PanePtr const&) {
fix crash when disconnecting with inventory open additionally, fix humanoid identity being constantly sent by the server even when unchanged
2023-06-22 03:29:42 +00:00
if (auto player = m_client->mainPlayer())
player->clearSwap();
everything everywhere all at once
2023-06-20 04:33:09 +00:00
if (m_containerPane) {
m_containerPane->dismiss();
m_containerPane = {};
m_containerInteractor->closeContainer();
}
for (EntityId id : m_interactionScriptPanes.keys()) {
if (m_paneManager.isDisplayed(m_interactionScriptPanes[id]) && as<ScriptPane>(m_interactionScriptPanes[id])->openWithInventory())
m_interactionScriptPanes[id]->dismiss();
}
});
m_overflowMessage = make_shared<GuiMessage>("", 0);
m_plainCraftingWindow = make_shared<CraftingPane>(m_client->worldClient(), m_client->mainPlayer(), JsonObject{{"filter", JsonArray{"plain"}}}, m_client->mainPlayer()->entityId());
m_paneManager.registerPane(MainInterfacePanes::CraftingPlain, PaneLayer::Window, m_plainCraftingWindow);
m_paneManager.registerPane(MainInterfacePanes::EscapeDialog, PaneLayer::ModalWindow, createEscapeDialog());
auto songbookInterface = make_shared<SongbookInterface>(m_client->mainPlayer());
m_paneManager.registerPane(MainInterfacePanes::Songbook, PaneLayer::Window, songbookInterface);
m_questLogInterface = make_shared<QuestLogInterface>(m_client->questManager(), m_client->mainPlayer(), m_cinematicOverlay, m_client);
m_paneManager.registerPane(MainInterfacePanes::QuestLog, PaneLayer::Window, m_questLogInterface);
auto aiInterface = make_shared<AiInterface>(m_client, m_cinematicOverlay, &m_paneManager);
m_paneManager.registerPane(MainInterfacePanes::Ai, PaneLayer::Window, aiInterface);
m_codexInterface = make_shared<CodexInterface>(m_client->mainPlayer());
m_paneManager.registerPane(MainInterfacePanes::Codex, PaneLayer::Window, m_codexInterface);
m_optionsMenu = make_shared<OptionsMenu>(&m_paneManager);
m_paneManager.registerPane(MainInterfacePanes::Options, PaneLayer::ModalWindow, m_optionsMenu);
m_popupInterface = make_shared<PopupInterface>();
m_paneManager.registerPane(MainInterfacePanes::Popup, PaneLayer::Window, m_popupInterface);
m_confirmationDialog = make_shared<ConfirmationDialog>();
m_paneManager.registerPane(MainInterfacePanes::Confirmation, PaneLayer::ModalWindow, m_confirmationDialog);
m_joinRequestDialog = make_shared<JoinRequestDialog>();
m_paneManager.registerPane(MainInterfacePanes::JoinRequest, PaneLayer::ModalWindow, m_joinRequestDialog);
m_actionBar = make_shared<ActionBar>(&m_paneManager, m_client->mainPlayer());
m_paneManager.registerPane(MainInterfacePanes::ActionBar, PaneLayer::Hud, m_actionBar);
m_questTracker = make_shared<QuestTrackerPane>();
m_paneManager.registerPane(MainInterfacePanes::QuestTracker, PaneLayer::Hud, m_questTracker);
m_mmUpgrade = make_shared<ScriptPane>(m_client, "/interface/scripted/mmupgrade/mmupgradegui.config");
m_paneManager.registerPane(MainInterfacePanes::MmUpgrade, PaneLayer::Window, m_mmUpgrade);
m_collections = make_shared<ScriptPane>(m_client, "/interface/scripted/collections/collectionsgui.config");
m_paneManager.registerPane(MainInterfacePanes::Collections, PaneLayer::Window, m_collections);
m_chat = make_shared<Chat>(m_client);
m_paneManager.registerPane(MainInterfacePanes::Chat, PaneLayer::Hud, m_chat);
m_clientCommandProcessor = make_shared<ClientCommandProcessor>(m_client, m_cinematicOverlay, &m_paneManager, m_config->macroCommands);
m_radioMessagePopup = make_shared<RadioMessagePopup>();
m_paneManager.registerPane(MainInterfacePanes::RadioMessagePopup, PaneLayer::Hud, m_radioMessagePopup);
m_wireInterface = make_shared<WirePane>(m_client->worldClient(), m_client->mainPlayer(), m_worldPainter);
m_paneManager.registerPane(MainInterfacePanes::WireInterface, PaneLayer::World, m_wireInterface);
m_client->mainPlayer()->setWireConnector(m_wireInterface.get());
auto teamBar = make_shared<TeamBar>(this, m_client);
m_paneManager.registerPane(MainInterfacePanes::TeamBar, PaneLayer::Hud, teamBar);
auto statusPane = make_shared<StatusPane>(&m_paneManager, m_client);
m_paneManager.registerPane(MainInterfacePanes::StatusPane, PaneLayer::Hud, statusPane);
auto planetName = make_shared<Pane>();
m_planetText = make_shared<LabelWidget>();
Lua chat callbacks + better font styling golly gee whiz!! i hope i didn't fuck something up
2024-04-21 20:07:59 +00:00
m_planetText->setTextStyle(m_config->planetNameTextStyle);
everything everywhere all at once
2023-06-20 04:33:09 +00:00
m_planetText->setAnchor(HorizontalAnchor::HMidAnchor, VerticalAnchor::VMidAnchor);
planetName->disableScissoring();
planetName->setPosition(m_config->planetNameOffset);
planetName->setAnchor(PaneAnchor::Center);
planetName->addChild("planetText", m_planetText);
m_paneManager.registerPane(MainInterfacePanes::PlanetText, PaneLayer::Hud, planetName);
m_nameplatePainter = make_shared<NameplatePainter>();
Fixed some uninitialized members May have caused undefined behavior in few cases, as most of the fixed members were used before being initialized.
2024-02-19 22:29:39 +00:00
m_questIndicatorPainter = make_shared<QuestIndicatorPainter>(m_client);
everything everywhere all at once
2023-06-20 04:33:09 +00:00
m_chatBubbleManager = make_shared<ChatBubbleManager>();
m_paneManager.displayRegisteredPane(MainInterfacePanes::ActionBar);
m_paneManager.displayRegisteredPane(MainInterfacePanes::Chat);
m_paneManager.displayRegisteredPane(MainInterfacePanes::TeamBar);
m_paneManager.displayRegisteredPane(MainInterfacePanes::StatusPane);
}
MainInterface::~MainInterface() {
m_paneManager.dismissAllPanes();
}
MainInterface::RunningState MainInterface::currentState() const {
return m_state;
}
MainInterfacePaneManager* MainInterface::paneManager() {
return &m_paneManager;
}
bool MainInterface::escapeDialogOpen() const {
return m_paneManager.registeredPaneIsDisplayed(MainInterfacePanes::EscapeDialog) || m_paneManager.registeredPaneIsDisplayed(MainInterfacePanes::Options);
}
void MainInterface::openCraftingWindow(Json const& config, EntityId sourceEntityId) {
if (m_craftingWindow && m_paneManager.isDisplayed(m_craftingWindow)) {
m_paneManager.dismissPane(m_craftingWindow);
fix: crafting interfaces not working with new middle-click opening
2024-03-27 17:46:07 +00:00
if (sourceEntityId != NullEntityId && m_craftingWindow->sourceEntityId() == sourceEntityId) {
everything everywhere all at once
2023-06-20 04:33:09 +00:00
m_craftingWindow.reset();
return;
}
}
m_craftingWindow = make_shared<CraftingPane>(m_client->worldClient(), m_client->mainPlayer(), config, sourceEntityId);
m_paneManager.displayPane(PaneLayer::Window, m_craftingWindow, [this](PanePtr const&) {
fix crash when disconnecting with inventory open additionally, fix humanoid identity being constantly sent by the server even when unchanged
2023-06-22 03:29:42 +00:00
if (auto player = m_client->mainPlayer())
player->clearSwap();
everything everywhere all at once
2023-06-20 04:33:09 +00:00
});
}
void MainInterface::openMerchantWindow(Json const& config, EntityId sourceEntityId) {
if (m_merchantWindow && m_paneManager.isDisplayed(m_merchantWindow)) {
m_paneManager.dismissPane(m_merchantWindow);
fix: crafting interfaces not working with new middle-click opening
2024-03-27 17:46:07 +00:00
if (sourceEntityId != NullEntityId && m_merchantWindow->sourceEntityId() == sourceEntityId) {
everything everywhere all at once
2023-06-20 04:33:09 +00:00
m_merchantWindow.reset();
return;
}
}
feat: middle click objects in the inventory to open their interface makes carrying around shop objects easier might need to restrict the allowed interaction types more, as some may break due to the source entity being the player
2024-03-27 05:00:13 +00:00
bool openWithInventory = config.getBool("openWithInventory", true);
slightly smarter inventory close behavior with panes that open with the inventory
2024-05-23 02:12:07 +00:00
bool closeWithInventory = config.getBool("closeWithInventory", !m_paneManager.registeredPaneIsDisplayed(MainInterfacePanes::Inventory));
everything everywhere all at once
2023-06-20 04:33:09 +00:00
m_merchantWindow = make_shared<MerchantPane>(m_client->worldClient(), m_client->mainPlayer(), config, sourceEntityId);
slightly smarter inventory close behavior with panes that open with the inventory
2024-05-23 02:12:07 +00:00
m_paneManager.displayPane(PaneLayer::Window, m_merchantWindow, [this, closeWithInventory](PanePtr const&) {
if (closeWithInventory)
m_paneManager.dismissRegisteredPane(MainInterfacePanes::Inventory);
});
feat: middle click objects in the inventory to open their interface makes carrying around shop objects easier might need to restrict the allowed interaction types more, as some may break due to the source entity being the player
2024-03-27 05:00:13 +00:00
if (openWithInventory)
m_paneManager.displayRegisteredPane(MainInterfacePanes::Inventory);
everything everywhere all at once
2023-06-20 04:33:09 +00:00
m_paneManager.bringPaneAdjacent(m_paneManager.registeredPane(MainInterfacePanes::Inventory),
m_merchantWindow, Root::singleton().assets()->json("/interface.config:bringAdjacentWindowGap").toFloat());
}
void MainInterface::togglePlainCraftingWindow() {
m_paneManager.toggleRegisteredPane(MainInterfacePanes::CraftingPlain);
if (m_craftingWindow && m_craftingWindow->isDisplayed()
&& m_craftingWindow != m_paneManager.registeredPane(MainInterfacePanes::CraftingPlain))
m_paneManager.dismissPane(m_craftingWindow);
m_craftingWindow = m_plainCraftingWindow;
}
bool MainInterface::windowsOpen() const {
return (bool)m_paneManager.topPane({PaneLayer::Window});
}
MerchantPanePtr MainInterface::activeMerchantPane() const {
if (m_paneManager.isDisplayed(m_merchantWindow))
return m_merchantWindow;
else
return {};
}
bool MainInterface::handleInputEvent(InputEvent const& event) {
auto player = m_client->mainPlayer();
auto inv = player->inventory();
auto& root = Root::singleton();
if (auto mouseMove = event.ptr<MouseMoveEvent>())
m_cursorScreenPos = mouseMove->mousePosition;
if (m_paneManager.sendInputEvent(event)) {
if (!event.is<MouseButtonUpEvent>() && !event.is<KeyUpEvent>())
return true;
}
if (event.is<KeyDownEvent>()) {
if (m_chat->hasFocus()) {
if (m_guiContext->actions(event).contains(InterfaceAction::ChatSendLine)) {
doChat(m_chat->currentChat(), true);
m_chat->clearCurrentChat();
m_chat->stopChat();
return true;
}
} else if (!m_paneManager.keyboardCapturedPane()) {
Maybe<InventorySlot> swapSlot;
for (auto action : m_guiContext->actions(event)) {
switch (action) {
default:
break;
case InterfaceAction::GuiShifting:
m_guiContext->setShiftHeld(true);
break;
case InterfaceAction::ChatBegin:
m_chat->startChat();
break;
case InterfaceAction::InterfaceHideHud:
m_disableHud = !m_disableHud;
break;
case InterfaceAction::InterfaceRepeatCommand:
if (!m_lastCommand.empty())
doChat(m_lastCommand, false);
break;
case InterfaceAction::InterfaceToggleFullscreen:
m_optionsMenu->toggleFullscreen();
break;
case InterfaceAction::InterfaceReload:
root.reload();
root.fullyLoad();
break;
case InterfaceAction::ChatBeginCommand:
m_chat->startCommand();
break;
case InterfaceAction::InterfaceEscapeMenu:
m_paneManager.toggleRegisteredPane(MainInterfacePanes::EscapeDialog);
break;
case InterfaceAction::InterfaceInventory:
m_paneManager.toggleRegisteredPane(MainInterfacePanes::Inventory);
break;
case InterfaceAction::InterfaceCodex:
m_paneManager.toggleRegisteredPane(MainInterfacePanes::Codex);
break;
case InterfaceAction::InterfaceQuest:
m_paneManager.toggleRegisteredPane(MainInterfacePanes::QuestLog);
break;
case InterfaceAction::InterfaceCrafting:
togglePlainCraftingWindow();
break;
}
}
}
return false;
} else if (auto keyUp = event.ptr<KeyUpEvent>()) {
if (m_guiContext->actionsForKey(keyUp->key).contains(InterfaceAction::GuiShifting))
m_guiContext->setShiftHeld(false);
return false;
} else if (auto mouseDown = event.ptr<MouseButtonDownEvent>()) {
move oddly placed player input code
2024-02-22 06:38:47 +00:00
auto mouseButton = mouseDown->mouseButton;
if (mouseButton >= MouseButton::Left && mouseButton <= MouseButton::Right
&& overlayClick(mouseDown->mousePosition, mouseDown->mouseButton)) {
return true;
} else {
if (mouseButton == MouseButton::Left)
player->beginPrimaryFire();
if (mouseButton == MouseButton::Right)
player->beginAltFire();
if (mouseButton == MouseButton::Middle)
player->beginTrigger();
}
everything everywhere all at once
2023-06-20 04:33:09 +00:00
} else if (auto mouseUp = event.ptr<MouseButtonUpEvent>()) {
if (mouseUp->mouseButton == MouseButton::Left)
player->endPrimaryFire();
if (mouseUp->mouseButton == MouseButton::Right)
player->endAltFire();
if (mouseUp->mouseButton == MouseButton::Middle)
player->endTrigger();
}
move oddly placed player input code
2024-02-22 06:38:47 +00:00
bool captured = false;
Initial voice HUD indicator setup
2023-07-17 12:20:39 +00:00
for (auto& pair : m_canvases)
move oddly placed player input code
2024-02-22 06:38:47 +00:00
captured |= pair.second->sendEvent(event);
Initial voice HUD indicator setup
2023-07-17 12:20:39 +00:00
move oddly placed player input code
2024-02-22 06:38:47 +00:00
return captured;
everything everywhere all at once
2023-06-20 04:33:09 +00:00
}
bool MainInterface::inputFocus() const {
return (bool)m_paneManager.keyboardCapturedPane();
}
bool MainInterface::textInputActive() const {
return m_paneManager.keyboardCapturedForTextInput();
}
void MainInterface::handleInteractAction(InteractAction interactAction) {
auto assets = Root::singleton().assets();
auto world = m_client->worldClient();
if (interactAction.type == InteractActionType::OpenContainer) {
// If we're currently displaying this container, close it.
if (m_containerPane && m_containerInteractor->openContainerId() == interactAction.entityId) {
m_paneManager.dismissPane(m_containerPane);
return;
}
// If we're currently displaying another container, close it before we open.
if (m_containerPane)
m_paneManager.dismissPane(m_containerPane);
auto containerEntity = world->get<ContainerEntity>(interactAction.entityId);
if (!containerEntity)
return;
m_containerInteractor->openContainer(containerEntity);
slightly smarter inventory close behavior with panes that open with the inventory
2024-05-23 02:12:07 +00:00
bool closeWithInventory = !m_paneManager.registeredPaneIsDisplayed(MainInterfacePanes::Inventory);
everything everywhere all at once
2023-06-20 04:33:09 +00:00
m_paneManager.displayRegisteredPane(MainInterfacePanes::Inventory);
m_containerPane = make_shared<ContainerPane>(world, m_client->mainPlayer(), m_containerInteractor);
slightly smarter inventory close behavior with panes that open with the inventory
2024-05-23 02:12:07 +00:00
m_paneManager.displayPane(PaneLayer::Window, m_containerPane, [this, closeWithInventory](PanePtr const&) {
if (closeWithInventory)
m_paneManager.dismissRegisteredPane(MainInterfacePanes::Inventory);
else {
m_containerInteractor->closeContainer();
m_containerPane = {};
}
resolved most of the compiler warnings/errors under gcc also update xxhash and tinyformat
2023-06-26 18:48:27 +00:00
});
everything everywhere all at once
2023-06-20 04:33:09 +00:00
m_paneManager.bringPaneAdjacent(m_paneManager.registeredPane(MainInterfacePanes::Inventory),
m_containerPane, Root::singleton().assets()->json("/interface.config:bringAdjacentWindowGap").toFloat());
} else if (interactAction.type == InteractActionType::SitDown) {
m_client->mainPlayer()->lounge(interactAction.entityId, interactAction.data.toUInt());
} else if (interactAction.type == InteractActionType::OpenCraftingInterface) {
fix: crafting interfaces not working with new middle-click opening
2024-03-27 17:46:07 +00:00
if (interactAction.entityId != NullEntityId && !world->entity(interactAction.entityId))
everything everywhere all at once
2023-06-20 04:33:09 +00:00
return;
openCraftingWindow(interactAction.data, interactAction.entityId);
} else if (interactAction.type == InteractActionType::OpenSongbookInterface) {
m_paneManager.displayRegisteredPane(MainInterfacePanes::Songbook);
} else if (interactAction.type == InteractActionType::OpenNpcCraftingInterface) {
fix: crafting interfaces not working with new middle-click opening
2024-03-27 17:46:07 +00:00
if (interactAction.entityId != NullEntityId && !world->entity(interactAction.entityId))
everything everywhere all at once
2023-06-20 04:33:09 +00:00
return;
fix: crafting interfaces not working with new middle-click opening
2024-03-27 17:46:07 +00:00
// wait, this is literally the exact same as OpenCraftingInterface. what the fuck? lol
everything everywhere all at once
2023-06-20 04:33:09 +00:00
openCraftingWindow(interactAction.data, interactAction.entityId);
} else if (interactAction.type == InteractActionType::OpenMerchantInterface) {
fix: crafting interfaces not working with new middle-click opening
2024-03-27 17:46:07 +00:00
if (interactAction.entityId != NullEntityId && !world->entity(interactAction.entityId))
everything everywhere all at once
2023-06-20 04:33:09 +00:00
return;
openMerchantWindow(interactAction.data, interactAction.entityId);
} else if (interactAction.type == InteractActionType::OpenAiInterface) {
as<AiInterface>(m_paneManager.registeredPane(MainInterfacePanes::Ai))->setSourceEntityId(interactAction.entityId);
m_paneManager.displayRegisteredPane(MainInterfacePanes::Ai);
} else if (interactAction.type == InteractActionType::OpenTeleportDialog) {
if (m_teleportDialog)
m_teleportDialog->dismiss();
if (!m_client->canTeleport())
return;
auto currentLocation = TeleportBookmark();
auto config = assets->fetchJson(interactAction.data);
if (config.getBool("canBookmark", false)) {
if (auto entity = world->entity(interactAction.entityId)) {
if (auto uniqueEntityId = entity->uniqueId()) {
auto worldTemplate = m_client->worldClient()->currentTemplate();
String icon, planetName;
if (m_client->playerWorld().is<ClientShipWorldId>()) {
icon = "ship";
planetName = "Player Ship";
} else if (m_client->playerWorld().is<CelestialWorldId>()) {
icon = worldTemplate->worldParameters()->typeName;
planetName = worldTemplate->worldName();
} else if (m_client->playerWorld().is<InstanceWorldId>()) {
icon = worldTemplate->worldParameters()->typeName;
planetName = worldTemplate->worldName();
} else {
icon = "default";
planetName = "???";
}
currentLocation = TeleportBookmark {
{m_client->playerWorld(), SpawnTargetUniqueEntity(*uniqueEntityId)},
planetName,
config.getString("bookmarkName", ""),
icon
};
if (!m_client->mainPlayer()->universeMap()->teleportBookmarks().contains(currentLocation) || !config.getBool("canTeleport", true)) {
auto editBookmarkDialog = make_shared<EditBookmarkDialog>(m_client->mainPlayer()->universeMap());
editBookmarkDialog->setBookmark(currentLocation);
m_paneManager.displayPane(PaneLayer::ModalWindow, editBookmarkDialog);
return;
}
}
}
}
if (config.getBool("canTeleport", true)) {
m_teleportDialog = make_shared<TeleportDialog>(m_client, &m_paneManager, interactAction.data, interactAction.entityId, currentLocation);
m_paneManager.displayPane(PaneLayer::ModalWindow, m_teleportDialog);
}
} else if (interactAction.type == InteractActionType::ShowPopup) {
m_paneManager.displayRegisteredPane(MainInterfacePanes::Popup);
m_popupInterface->displayMessage(interactAction.data.getString("message"), interactAction.data.getString("title", ""), interactAction.data.getString("subtitle", ""), interactAction.data.optString("sound"));
} else if (interactAction.type == InteractActionType::ScriptPane) {
auto sourceEntity = interactAction.entityId;
// dismiss if there's already a scriptpane open for this source entity
if (sourceEntity != NullEntityId && m_interactionScriptPanes.contains(sourceEntity) && m_paneManager.isDisplayed(m_interactionScriptPanes[sourceEntity]))
m_paneManager.dismissPane(m_interactionScriptPanes[sourceEntity]);
ScriptPanePtr scriptPane = make_shared<ScriptPane>(m_client, interactAction.data, sourceEntity);
Reset script panes on character swap
2023-07-28 16:12:03 +00:00
displayScriptPane(scriptPane, sourceEntity);
everything everywhere all at once
2023-06-20 04:33:09 +00:00
} else if (interactAction.type == InteractActionType::Message) {
m_client->mainPlayer()->receiveMessage(connectionForEntity(interactAction.entityId),
interactAction.data.getString("messageType"), interactAction.data.getArray("messageArgs"));
}
}
fix late aimPosition
2024-03-15 05:26:12 +00:00
void MainInterface::preUpdate(float dt) {
auto player = m_client->mainPlayer();
if (!m_client->paused())
player->aim(cursorWorldPosition());
}
Support for changing the game's timescale Context-specific (like per-world) timescales can also be added later
2023-07-20 14:58:49 +00:00
void MainInterface::update(float dt) {
m_paneManager.update(dt);
m_cursor.update(dt);
everything everywhere all at once
2023-06-20 04:33:09 +00:00
m_questLogInterface->pollDialog(&m_paneManager);
if (!m_paneManager.topPane({PaneLayer::ModalWindow}) && m_codexInterface->showNewCodex())
m_paneManager.displayRegisteredPane(MainInterfacePanes::Codex);
auto player = m_client->mainPlayer();
auto cursorWorldPos = cursorWorldPosition();
if (player->wireToolInUse()) {
m_paneManager.displayRegisteredPane(MainInterfacePanes::WireInterface);
player->setWireConnector(m_wireInterface.get());
} else {
m_paneManager.dismissRegisteredPane(MainInterfacePanes::WireInterface);
}
// update inventory pane items, to know if item slots changed
m_inventoryWindow->updateItems();
// update mouseover target
EntityId newMouseOverTarget = NullEntityId;
Support for changing the game's timescale Context-specific (like per-world) timescales can also be added later
2023-07-20 14:58:49 +00:00
m_stickyTargetingTimer.tick(dt);
everything everywhere all at once
2023-06-20 04:33:09 +00:00
auto mouseoverEntities = m_client->worldClient()->query<DamageBarEntity>(RectF::withCenter(cursorWorldPos, Vec2F(1, 1)), [=](shared_ptr<DamageBarEntity> const& entity) {
return entity != player
&& entity->damageBar() == DamageBarType::Default
&& (entity->getTeam().type == TeamType::Enemy || entity->getTeam().type == TeamType::PVP)
&& m_client->worldClient()->lightLevel(entity->position()) > 0;
});
sortByComputedValue(mouseoverEntities, [&](DamageBarEntityPtr const& a) {
return m_client->worldClient()->geometry().diff(a->position(), cursorWorldPos).magnitude();
});
if (mouseoverEntities.size() > 0) {
newMouseOverTarget = mouseoverEntities[0]->entityId();
} else if (m_lastMouseoverTarget == NullEntityId && player->lastDamagedTarget() != NullEntityId && player->timeSinceLastGaveDamage() < m_stickyTargetingTimer.time / 2) {
if (auto targetEntity = as<DamageBarEntity>(m_client->worldClient()->entity(player->lastDamagedTarget()))) {
if (targetEntity->damageBar() == DamageBarType::Default && (targetEntity->getTeam().type == TeamType::Enemy || targetEntity->getTeam().type == TeamType::PVP)) {
newMouseOverTarget = targetEntity->entityId();
}
}
}
if (newMouseOverTarget != NullEntityId && newMouseOverTarget != m_lastMouseoverTarget) {
m_lastMouseoverTarget = newMouseOverTarget;
m_portraitScale = 0;
m_stickyTargetingTimer.reset();
}
if (m_stickyTargetingTimer.ready())
m_lastMouseoverTarget = NullEntityId;
// special damage bar entity
if (m_specialDamageBarTarget != NullEntityId) {
auto damageBarEntity = as<DamageBarEntity>(m_client->worldClient()->entity(m_specialDamageBarTarget));
if (damageBarEntity && damageBarEntity->damageBar() == DamageBarType::Special) {
float targetHealth = damageBarEntity->health() / damageBarEntity->maxHealth();
float fillSpeed = 1.0f / Root::singleton().assets()->json("/interface.config:specialDamageBar.fillTime").toFloat();
Support for changing the game's timescale Context-specific (like per-world) timescales can also be added later
2023-07-20 14:58:49 +00:00
if (abs(targetHealth - m_specialDamageBarValue) < fillSpeed * dt)
everything everywhere all at once
2023-06-20 04:33:09 +00:00
m_specialDamageBarValue = targetHealth;
else
Support for changing the game's timescale Context-specific (like per-world) timescales can also be added later
2023-07-20 14:58:49 +00:00
m_specialDamageBarValue += copysign(1.0f, targetHealth - m_specialDamageBarValue) * fillSpeed * dt;
everything everywhere all at once
2023-06-20 04:33:09 +00:00
} else {
m_specialDamageBarTarget = NullEntityId;
}
}
if (m_specialDamageBarTarget == NullEntityId)
m_specialDamageBarValue = 0.0f;
if (m_specialDamageBarTarget == NullEntityId && m_client->mainPlayer()->inWorld()) {
List<DamageBarEntityPtr> specialDamageTargets;
m_client->worldClient()->forAllEntities([&specialDamageTargets](EntityPtr const& entity) {
if (auto damageBarEntity = as<DamageBarEntity>(entity))
if (damageBarEntity->damageBar() == DamageBarType::Special)
specialDamageTargets.append(damageBarEntity);
});
sortByComputedValue(specialDamageTargets, [&](DamageBarEntityPtr entity) {
return m_client->worldClient()->geometry().diff(entity->position(), m_client->mainPlayer()->position());
});
if (specialDamageTargets.size() > 0)
m_specialDamageBarTarget = specialDamageTargets[0]->entityId();
}
for (auto const& message : m_client->mainPlayer()->pullQueuedMessages())
queueMessage(message);
auto chatHeight = (m_chat->active() && m_chat->visible() > 0.1) ? m_chat->size()[1] : 0;
m_radioMessagePopup->setChatHeight(chatHeight);
if (!m_cinematicOverlay || m_cinematicOverlay->completed()) {
if (m_client->mainPlayer()->interruptRadioMessage())
m_radioMessagePopup->interrupt();
if (!m_radioMessagePopup->messageActive()) {
if (auto radioMessage = m_client->mainPlayer()->pullPendingRadioMessage()) {
m_radioMessagePopup->setMessage(*radioMessage);
m_paneManager.displayRegisteredPane(MainInterfacePanes::RadioMessagePopup);
ChatReceivedMessage message = {
{MessageContext::RadioMessage},
ServerConnectionId,
Text::stripEscapeCodes(radioMessage->senderName),
Text::stripEscapeCodes(radioMessage->text),
Text::stripEscapeCodes(radioMessage->portraitImage.replace("<frame>", "0"))
};
m_chat->addMessages({message}, false);
} else {
m_paneManager.dismissRegisteredPane(MainInterfacePanes::RadioMessagePopup);
}
}
m_client->mainPlayer()->setInCinematic(false);
} else {
m_client->mainPlayer()->setInCinematic(true);
}
for (auto const& drop : m_client->mainPlayer()->pullQueuedItemDrops())
queueItemPickupText(drop);
m_chat->addMessages(m_client->pullChatMessages());
if (auto worldClient = m_client->worldClient()) {
if (worldClient->inWorld()) {
if (auto cinematic = m_client->mainPlayer()->pullPendingCinematic()) {
if (*cinematic)
m_cinematicOverlay->load(Root::singleton().assets()->fetchJson(cinematic.take()));
else
m_cinematicOverlay->stop();
}
}
}
if (!m_confirmationDialog->isDisplayed()) {
if (auto confirmation = m_client->mainPlayer()->pullPendingConfirmation()) {
m_paneManager.displayRegisteredPane(MainInterfacePanes::Confirmation);
m_confirmationDialog->displayConfirmation(confirmation->first, confirmation->second);
}
} else {
auto confirmationSource = m_confirmationDialog->sourceEntityId();
if (confirmationSource && !m_client->worldClient()->playerCanReachEntity(*confirmationSource))
m_confirmationDialog->dismiss();
}
if (!m_joinRequestDialog->isDisplayed()) {
if (auto req = m_queuedJoinRequests.maybeTakeLast()) {
m_paneManager.displayRegisteredPane(MainInterfacePanes::JoinRequest);
m_joinRequestDialog->displayRequest(req->first, [req](P2PJoinRequestReply reply) mutable {
req->second.fulfill(reply);
});
}
}
for (EntityId id : m_interactionScriptPanes.keys()) {
if (!m_paneManager.isDisplayed(m_interactionScriptPanes[id]))
m_interactionScriptPanes.remove(id);
}
if (!m_messages.contains(m_overflowMessage))
m_messageOverflow = 0;
unsigned maxMessages = m_messageOverflow == 0 ? m_config->maxMessageCount : m_config->maxMessageCount + 1; // exclude overflow message
if (m_messages.size() > maxMessages) {
if (m_messageOverflow == 0) {
m_messages.prepend(m_overflowMessage);
}
m_messageOverflow++;
Change pure string format calls to use fmt::to_string
2023-07-06 09:26:28 +00:00
m_overflowMessage->message = m_config->overflowMessageText.replace("<count>", toString(m_messageOverflow));
everything everywhere all at once
2023-06-20 04:33:09 +00:00
m_overflowMessage->cooldown = m_config->messageTime;
if (auto oldest = m_messages.sorted([](GuiMessagePtr a, GuiMessagePtr b) { return a->cooldown < b->cooldown; }).maybeFirst())
m_overflowMessage->cooldown = oldest.value()->cooldown;
if (auto bottom = m_messages.filtered([this](GuiMessagePtr m) { return m != m_overflowMessage; }).maybeFirst())
bottom.value()->cooldown = 0;
}
for (auto it = m_messages.begin(); it != m_messages.end();) {
auto& message = *it;
Support for changing the game's timescale Context-specific (like per-world) timescales can also be added later
2023-07-20 14:58:49 +00:00
message->cooldown -= dt;
everything everywhere all at once
2023-06-20 04:33:09 +00:00
if (message->cooldown < 0)
it = m_messages.erase(it);
else
it++;
}
for (auto it = m_itemDropMessages.begin(); it != m_itemDropMessages.end();) {
auto& message = *it;
if (message.second.second->cooldown < 0)
it = m_itemDropMessages.erase(it);
else
it++;
}
Improve planet name title They began showing during the warp cinematic and their fade-out timing was wrong.
2023-08-02 09:29:21 +00:00
bool playerInWorld = m_client->mainPlayer()->inWorld();
if (m_cinematicOverlay->completed()) {
if (m_planetNameTimer.tick(dt)) {
everything everywhere all at once
2023-06-20 04:33:09 +00:00
m_paneManager.dismissRegisteredPane(MainInterfacePanes::PlanetText);
Improve planet name title They began showing during the warp cinematic and their fade-out timing was wrong.
2023-08-02 09:29:21 +00:00
} else {
if (playerInWorld) {
String worldName;
if (auto worldTemplate = m_client->worldClient()->currentTemplate())
worldName = worldTemplate->worldName();
if (!worldName.empty()) {
m_planetText->setText(strf(m_config->planetNameFormatString.utf8Ptr(), worldName));
m_paneManager.displayRegisteredPane(MainInterfacePanes::PlanetText);
}
}
everything everywhere all at once
2023-06-20 04:33:09 +00:00
Improve planet name title They began showing during the warp cinematic and their fade-out timing was wrong.
2023-08-02 09:29:21 +00:00
Color textColor = Color::White; // probably need to make this jsonable
float fadeTimer = m_planetNameTimer.timer;
if (fadeTimer < m_config->planetNameFadeTime)
textColor.setAlphaF(fadeTimer / m_config->planetNameFadeTime);
everything everywhere all at once
2023-06-20 04:33:09 +00:00
Improve planet name title They began showing during the warp cinematic and their fade-out timing was wrong.
2023-08-02 09:29:21 +00:00
m_planetText->setColor(textColor);
}
} else if (!playerInWorld) {
everything everywhere all at once
2023-06-20 04:33:09 +00:00
m_planetNameTimer.reset();
Improve planet name title They began showing during the warp cinematic and their fade-out timing was wrong.
2023-08-02 09:29:21 +00:00
m_paneManager.dismissRegisteredPane(MainInterfacePanes::PlanetText);
everything everywhere all at once
2023-06-20 04:33:09 +00:00
}
Improve planet name title They began showing during the warp cinematic and their fade-out timing was wrong.
2023-08-02 09:29:21 +00:00
for (auto& containerResult : m_containerInteractor->pullContainerResults()) {
everything everywhere all at once
2023-06-20 04:33:09 +00:00
if (!m_containerPane || !m_containerPane->giveContainerResult(containerResult)) {
if (!m_inventoryWindow->giveContainerResult(containerResult)) {
for (auto item : containerResult) {
if (m_containerInteractor->containerOpen())
m_containerInteractor->addToContainer(m_client->mainPlayer()->pickupItems(item));
else
m_client->mainPlayer()->giveItem(item);
}
}
}
}
if (auto currentQuest = m_client->questManager()->currentQuest()) {
m_paneManager.displayRegisteredPane(MainInterfacePanes::QuestTracker);
m_questTracker->setQuest(*currentQuest);
} else {
m_paneManager.dismissRegisteredPane(MainInterfacePanes::QuestTracker);
}
updateCursor();
Support for changing the game's timescale Context-specific (like per-world) timescales can also be added later
2023-07-20 14:58:49 +00:00
m_nameplatePainter->update(dt, m_client->worldClient(), m_worldPainter->camera(), m_client->worldClient()->interactiveHighlightMode());
m_questIndicatorPainter->update(dt, m_client->worldClient(), m_worldPainter->camera());
everything everywhere all at once
2023-06-20 04:33:09 +00:00
add Nametag Directives
2023-06-23 10:24:40 +00:00
m_chatBubbleManager->setCamera(m_worldPainter->camera());
everything everywhere all at once
2023-06-20 04:33:09 +00:00
if (auto worldClient = m_client->worldClient()) {
auto chatActions = worldClient->pullPendingChatActions();
auto portraitActions = chatActions.filtered([](ChatAction action) { return action.is<PortraitChatAction>(); });
for (auto action : portraitActions) {
PortraitChatAction portraitAction = action.get<PortraitChatAction>();
String name;
if (auto npc = as<Npc>(worldClient->entity(portraitAction.entity)))
name = npc->name();
ChatReceivedMessage message = {
{ MessageContext::World },
ServerConnectionId,
Text::stripEscapeCodes(name),
Text::stripEscapeCodes(portraitAction.text),
Text::stripEscapeCodes(portraitAction.portrait.replace("<frame>", "0"))
};
m_chat->addMessages({message}, false);
}
m_chatBubbleManager->addChatActions(chatActions);
Support for changing the game's timescale Context-specific (like per-world) timescales can also be added later
2023-07-20 14:58:49 +00:00
m_chatBubbleManager->update(dt, worldClient);
everything everywhere all at once
2023-06-20 04:33:09 +00:00
}
if (auto container = m_client->worldClient()->get<ContainerEntity>(m_containerInteractor->openContainerId())) {
if (!m_client->worldClient()->playerCanReachEntity(container->entityId())
|| !container->isInteractive())
m_containerInteractor->closeContainer();
}
if (m_paneManager.topPane({PaneLayer::Window, PaneLayer::ModalWindow}))
m_client->mainPlayer()->setBusyState(PlayerBusyState::Menu);
else if (m_chat->hasFocus())
m_client->mainPlayer()->setBusyState(PlayerBusyState::Chatting);
else
m_client->mainPlayer()->setBusyState(PlayerBusyState::None);
Start of Interface callbacks, starting with a bindCanvas function for the whole screen
2023-07-04 09:27:16 +00:00
for (auto& pair : m_canvases) {
pair.second->setPosition(Vec2I());
interface.bindCanvas uses interface scale by default
2023-07-05 08:25:16 +00:00
if (pair.second->ignoreInterfaceScale())
pair.second->setSize(Vec2I(m_guiContext->windowSize()));
else
pair.second->setSize(Vec2I(m_guiContext->windowInterfaceSize()));
Support for changing the game's timescale Context-specific (like per-world) timescales can also be added later
2023-07-20 14:58:49 +00:00
pair.second->update(dt);
Start of Interface callbacks, starting with a bindCanvas function for the whole screen
2023-07-04 09:27:16 +00:00
}
everything everywhere all at once
2023-06-20 04:33:09 +00:00
}
void MainInterface::renderInWorldElements() {
if (m_disableHud)
return;
Lua chat callbacks + better font styling golly gee whiz!! i hope i didn't fuck something up
2024-04-21 20:07:59 +00:00
m_guiContext->clearTextStyle();
everything everywhere all at once
2023-06-20 04:33:09 +00:00
m_questIndicatorPainter->render();
m_nameplatePainter->render();
m_chatBubbleManager->render();
}
void MainInterface::render() {
if (m_disableHud)
return;
Lua chat callbacks + better font styling golly gee whiz!! i hope i didn't fuck something up
2024-04-21 20:07:59 +00:00
m_guiContext->clearTextStyle();
everything everywhere all at once
2023-06-20 04:33:09 +00:00
renderBreath();
renderMessages();
renderMonsterHealthBar();
renderSpecialDamageBar();
renderMainBar();
Don't do spatial logging on the server
2023-06-27 14:50:47 +00:00
renderDebug();
everything everywhere all at once
2023-06-20 04:33:09 +00:00
Start of Interface callbacks, starting with a bindCanvas function for the whole screen
2023-07-04 09:27:16 +00:00
RectI screenRect = RectI::withSize(Vec2I(), Vec2I(m_guiContext->windowSize()));
for (auto& pair : m_canvases)
pair.second->render(screenRect);
everything everywhere all at once
2023-06-20 04:33:09 +00:00
renderWindows();
renderCursor();
}
Vec2F MainInterface::cursorWorldPosition() const {
return m_worldPainter->camera().screenToWorld(Vec2F(m_cursorScreenPos));
}
bool MainInterface::isDebugDisplayed() {
return m_clientCommandProcessor->debugDisplayEnabled();
}
void MainInterface::doChat(String const& chat, bool addToHistory) {
if (chat.empty())
return;
if (chat.beginsWith("/")) {
m_lastCommand = chat;
for (auto const& result : m_clientCommandProcessor->handleCommand(chat))
m_chat->addLine(result);
} else {
m_client->sendChat(chat, m_chat->sendMode());
}
if (addToHistory)
m_chat->addHistory(chat);
}
Initial voice HUD indicator setup
2023-07-17 12:20:39 +00:00
void MainInterface::queueMessage(String const& message, Maybe<float> cooldown, float spring) {
auto guiMessage = make_shared<GuiMessage>(message, cooldown.value(m_config->messageTime), spring);
everything everywhere all at once
2023-06-20 04:33:09 +00:00
m_messages.append(guiMessage);
}
Initial voice HUD indicator setup
2023-07-17 12:20:39 +00:00
void MainInterface::queueMessage(String const& message) {
queueMessage(message, m_config->messageTime, 0.0f);
}
everything everywhere all at once
2023-06-20 04:33:09 +00:00
void MainInterface::queueJoinRequest(pair<String, RpcPromiseKeeper<P2PJoinRequestReply>> request)
{
m_queuedJoinRequests.push_back(request);
}
void MainInterface::queueItemPickupText(ItemPtr const& item) {
auto descriptor = item->descriptor();
if (m_itemDropMessages.contains(descriptor.singular())) {
auto countMessPair = m_itemDropMessages.get(descriptor.singular());
auto newCount = item->count() + countMessPair.first;
auto message = countMessPair.second;
The Formatting String Catastrophe
2023-06-27 10:23:44 +00:00
message->message = strf("{} - {}", item->friendlyName(), newCount);
everything everywhere all at once
2023-06-20 04:33:09 +00:00
message->cooldown = m_config->messageTime;
m_itemDropMessages[descriptor.singular()] = {newCount, message};
} else {
The Formatting String Catastrophe
2023-06-27 10:23:44 +00:00
auto message = make_shared<GuiMessage>(strf("{} - {}", item->friendlyName(), item->count()), m_config->messageTime);
everything everywhere all at once
2023-06-20 04:33:09 +00:00
m_messages.append(message);
m_itemDropMessages[descriptor.singular()] = {item->count(), message};
}
}
bool MainInterface::fixedCamera() const {
return m_clientCommandProcessor->fixedCameraEnabled();
}
feat: unicode emoji support + other stuff
2024-04-23 21:44:53 +00:00
bool MainInterface::hudVisible() const {
return !m_disableHud;
}
void MainInterface::setHudVisible(bool visible) {
m_disableHud = !visible;
}
everything everywhere all at once
2023-06-20 04:33:09 +00:00
void MainInterface::warpToOrbitedWorld(bool deploy) {
if (m_client->canBeamDown(deploy)) {
if (deploy)
m_client->warpPlayer(WarpAlias::OrbitedWorld, true, "deploy", true);
else
m_client->warpPlayer(WarpAlias::OrbitedWorld, true, "beam");
return;
}
m_guiContext->playAudio("/sfx/interface/clickon_error.ogg");
}
void MainInterface::warpToOwnShip() {
if (m_client->canBeamUp()) {
warpTo(WarpAlias::OwnShip);
} else {
m_guiContext->playAudio("/sfx/interface/clickon_error.ogg");
}
}
void MainInterface::warpTo(WarpAction const& warpAction) {
if (m_client->beamUpRule() == BeamUpRule::AnywhereWithWarning) {
if (m_confirmationDialog->isDisplayed())
m_confirmationDialog->dismiss();
m_paneManager.displayRegisteredPane(MainInterfacePanes::Confirmation);
m_confirmationDialog->displayConfirmation("/interface/windowconfig/beamupconfirmation.config", [this, warpAction] (Widget*) {
m_client->warpPlayer(warpAction, true, "beam");
}, [](Widget*) {});
} else {
m_client->warpPlayer(warpAction, true, "beam");
}
}
interface.bindCanvas uses interface scale by default
2023-07-05 08:25:16 +00:00
CanvasWidgetPtr MainInterface::fetchCanvas(String const& canvasName, bool ignoreInterfaceScale) {
Initial voice HUD indicator setup
2023-07-17 12:20:39 +00:00
CanvasWidgetPtr canvas;
Start of Interface callbacks, starting with a bindCanvas function for the whole screen
2023-07-04 09:27:16 +00:00
if (auto canvasPtr = m_canvases.ptr(canvasName))
Initial voice HUD indicator setup
2023-07-17 12:20:39 +00:00
canvas = *canvasPtr;
Start of Interface callbacks, starting with a bindCanvas function for the whole screen
2023-07-04 09:27:16 +00:00
else {
Initial voice HUD indicator setup
2023-07-17 12:20:39 +00:00
m_canvases.emplace(canvasName, canvas = make_shared<CanvasWidget>());
Start of Interface callbacks, starting with a bindCanvas function for the whole screen
2023-07-04 09:27:16 +00:00
canvas->setPosition(Vec2I());
interface.bindCanvas uses interface scale by default
2023-07-05 08:25:16 +00:00
if (ignoreInterfaceScale)
canvas->setSize(Vec2I(m_guiContext->windowSize()));
else
canvas->setSize(Vec2I(m_guiContext->windowInterfaceSize()));
Start of Interface callbacks, starting with a bindCanvas function for the whole screen
2023-07-04 09:27:16 +00:00
}
Initial voice HUD indicator setup
2023-07-17 12:20:39 +00:00
canvas->setIgnoreInterfaceScale(ignoreInterfaceScale);
return canvas;
Start of Interface callbacks, starting with a bindCanvas function for the whole screen
2023-07-04 09:27:16 +00:00
}
Lua chat callbacks + better font styling golly gee whiz!! i hope i didn't fuck something up
2024-04-21 20:07:59 +00:00
ClientCommandProcessorPtr MainInterface::commandProcessor() const {
return m_clientCommandProcessor;
}
Reset script panes on character swap
2023-07-28 16:12:03 +00:00
// For when the player swaps characters. We need to completely reload ScriptPanes,
// because a lot of ScriptPanes do not expect the character to suddenly change and may break or spill data over.
void MainInterface::takeScriptPanes(List<ScriptPaneInfo>& out) {
m_paneManager.dismissWhere([&](PanePtr const& pane) {
if (auto scriptPane = as<ScriptPane>(pane)) {
if (scriptPane->isDismissed())
return false;
auto sourceEntityId = scriptPane->sourceEntityId();
m_interactionScriptPanes.remove(sourceEntityId);
auto& info = out.emplaceAppend();
info.scriptPane = scriptPane;
info.config = scriptPane->rawConfig();
info.sourceEntityId = sourceEntityId;
info.visible = scriptPane->visibility();
info.position = scriptPane->relativePosition();
return true;
}
return false;
});
}
void MainInterface::reviveScriptPanes(List<ScriptPaneInfo>& panes) {
for (auto& info : panes) { // this is evil and stupid
info.scriptPane->~ScriptPane();
new(info.scriptPane.get()) ScriptPane(m_client, info.config, info.sourceEntityId);
info.scriptPane->setVisibility(info.visible);
displayScriptPane(info.scriptPane, info.sourceEntityId);
info.scriptPane->setPosition(info.position);
}
}
everything everywhere all at once
2023-06-20 04:33:09 +00:00
PanePtr MainInterface::createEscapeDialog() {
auto assets = Root::singleton().assets();
auto escapeDialog = make_shared<Pane>();
auto escapeDialogPtr = escapeDialog.get();
GuiReader escapeDialogReader;
escapeDialogReader.registerCallback("returnToGame", [escapeDialogPtr](Widget*) {
escapeDialogPtr->dismiss();
});
escapeDialogReader.registerCallback("showOptions", [escapeDialogPtr, this](Widget*) {
escapeDialogPtr->dismiss();
m_paneManager.displayRegisteredPane(MainInterfacePanes::Options);
});
escapeDialogReader.registerCallback("saveAndQuit", [escapeDialogPtr, this](Widget*) {
m_state = ReturnToTitle;
escapeDialogPtr->dismiss();
});
escapeDialogReader.construct(assets->json("/interface.config:escapeDialog"), escapeDialogPtr);
Update StarMainInterface.cpp
2023-10-30 21:53:18 +00:00
escapeDialog->fetchChild<LabelWidget>("lblversion")->setText(strf("OpenStarbound - {} ({})", StarVersionString, StarArchitectureString));
everything everywhere all at once
2023-06-20 04:33:09 +00:00
return escapeDialog;
}
float MainInterface::interfaceScale() const {
return m_guiContext->interfaceScale();
}
unsigned MainInterface::windowHeight() const {
return m_guiContext->windowHeight();
}
unsigned MainInterface::windowWidth() const {
return m_guiContext->windowWidth();
}
Vec2I MainInterface::mainBarPosition() const {
return Vec2I(windowWidth(), windowHeight()) - m_config->mainBarSize * interfaceScale();
}
void MainInterface::renderBreath() {
auto assets = Root::singleton().assets();
auto imgMetadata = Root::singleton().imageMetadataDatabase();
Vec2I breathBarSize = Vec2I(Vec2F(m_guiContext->textureSize("/interface/breath/empty.png")) * interfaceScale());
Vec2I breathOffset = jsonToVec2I(assets->json("/interface.config:breathPos"));
Vec2F breathBackgroundCenterPos(windowWidth() * 0.5f + breathOffset[0] * interfaceScale(), windowHeight() - breathOffset[1] * interfaceScale());
Vec2F breathBarPos = breathBackgroundCenterPos + Vec2F(jsonToVec2I(assets->json("/interface.config:breathBarPos")) * interfaceScale());
float breath = m_client->mainPlayer()->breath();
float breathMax = m_client->mainPlayer()->maxBreath();
size_t blocks = round((10 * breath) / breathMax);
if (blocks < 10) {
more!! more!!!!
2023-06-24 15:16:40 +00:00
String breathPath = "/interface/breath/breath.png";
m_guiContext->drawQuad(breathPath, RectF::withCenter(breathBackgroundCenterPos, Vec2F(imgMetadata->imageSize(breathPath)) * interfaceScale()));
everything everywhere all at once
2023-06-20 04:33:09 +00:00
for (size_t i = 0; i < 10; i++) {
if (i >= blocks) {
if (blocks == 0 && Time::monotonicMilliseconds() % 500 > 250)
m_guiContext->drawQuad("/interface/breath/warning.png", breathBarPos + Vec2F(breathBarSize[0] * i, 0), interfaceScale());
else
m_guiContext->drawQuad("/interface/breath/empty.png", breathBarPos + Vec2F(breathBarSize[0] * i, 0), interfaceScale());
} else {
m_guiContext->drawQuad("/interface/breath/breathbar.png", breathBarPos + Vec2F(breathBarSize[0] * i, 0), interfaceScale());
}
}
}
}
void MainInterface::renderMessages() {
move interface item messages when bottomActionBar is enabled
2023-07-31 05:43:04 +00:00
if (m_messages.empty())
return;
everything everywhere all at once
2023-06-20 04:33:09 +00:00
Vec2F totalOffset = {};
auto imgMetadata = Root::singleton().imageMetadataDatabase();
move interface item messages when bottomActionBar is enabled
2023-07-31 05:43:04 +00:00
unsigned bottomOffset = Root::singleton().configuration()->getPath("inventory.bottomActionBar").optBool().value(false) ? 32 : 0;
everything everywhere all at once
2023-06-20 04:33:09 +00:00
for (auto& message : m_messages) {
Vec2F hiddenOffset = Vec2F(m_config->messageHiddenOffset);
move interface item messages when bottomActionBar is enabled
2023-07-31 05:43:04 +00:00
Vec2F activeOffset = Vec2F(m_config->messageActiveOffset);
if (bottomOffset) {
activeOffset[1] += bottomOffset;
bottomOffset = 0;
}
Vec2F messageOffset = lerp(message->springState, Vec2F(), activeOffset - hiddenOffset);
everything everywhere all at once
2023-06-20 04:33:09 +00:00
totalOffset += messageOffset;
messageOffset = totalOffset + hiddenOffset;
Vec2F backgroundCenterPos = Vec2F(windowWidth() * 0.5f + messageOffset[0] * interfaceScale(), messageOffset[1] * interfaceScale());
Vec2F backgroundTextCenterPos = backgroundCenterPos + Vec2F(m_config->messageTextContainerOffset * interfaceScale());
Vec2F messageTextOffset = backgroundTextCenterPos + Vec2F(m_config->messageTextOffset * interfaceScale());
if (message->cooldown > m_config->messageHideTime)
message->springState = (message->springState * m_config->messageWindowSpring + 1.0f) / (m_config->messageWindowSpring + 1.0f);
else
message->springState = (message->springState * m_config->messageWindowSpring) / (m_config->messageWindowSpring + 1.0f);
m_guiContext->drawQuad(m_config->messageTextContainer,
RectF::withCenter(backgroundTextCenterPos, Vec2F(imgMetadata->imageSize(m_config->messageTextContainer) * interfaceScale())));
Lua chat callbacks + better font styling golly gee whiz!! i hope i didn't fuck something up
2024-04-21 20:07:59 +00:00
m_guiContext->setTextStyle(m_config->textStyle);
everything everywhere all at once
2023-06-20 04:33:09 +00:00
m_guiContext->renderText(message->message, {messageTextOffset, HorizontalAnchor::HMidAnchor, VerticalAnchor::VMidAnchor});
}
}
void MainInterface::renderMonsterHealthBar() {
auto assets = Root::singleton().assets();
auto imgMetadata = Root::singleton().imageMetadataDatabase();
if (m_lastMouseoverTarget != NullEntityId && !m_stickyTargetingTimer.ready()) {
auto world = m_client->worldClient();
auto entity = world->entity(m_lastMouseoverTarget);
auto showDamageEntity = as<DamageBarEntity>(entity);
if (!showDamageEntity) {
m_lastMouseoverTarget = NullEntityId;
return;
}
Vec2F backgroundCenterPos = Vec2F(windowWidth() / 2.0f, windowHeight());
auto container = assets->json("/interface.config:monsterHealth.container").toString();
auto offset = jsonToVec2F(assets->json("/interface.config:monsterHealth.offset")) * interfaceScale();
m_guiContext->drawQuad(container, RectF::withCenter(backgroundCenterPos + offset, Vec2F(imgMetadata->imageSize(container) * interfaceScale())));
auto nameTextOffset = jsonToVec2F(assets->json("/interface.config:monsterHealth.nameTextOffset")) * interfaceScale();
Lua chat callbacks + better font styling golly gee whiz!! i hope i didn't fuck something up
2024-04-21 20:07:59 +00:00
m_guiContext->setTextStyle(m_config->textStyle);
everything everywhere all at once
2023-06-20 04:33:09 +00:00
m_guiContext->renderText(showDamageEntity->name(), backgroundCenterPos + nameTextOffset);
auto empty = assets->json("/interface.config:monsterHealth.progressEmpty").toString();
auto filled = assets->json("/interface.config:monsterHealth.progressFilled").toString();
auto progressBarOffset = jsonToVec2F(assets->json("/interface.config:monsterHealth.progressBarOffset")) * interfaceScale();
auto chunks = assets->json("/interface.config:monsterHealth.progressChunks").toInt();
int blocks = round(showDamageEntity->health() / showDamageEntity->maxHealth() * chunks);
Vec2F barPos = backgroundCenterPos + progressBarOffset;
Vec2F barItemOffset = Vec2F(imgMetadata->imageSize(filled)) * interfaceScale();
barItemOffset[1] = 0;
m_guiContext->drawQuad(empty, RectF::withSize(backgroundCenterPos + barPos, Vec2F(imgMetadata->imageSize(empty) * interfaceScale())));
for (int i = 0; i < blocks; i++)
m_guiContext->drawQuad(filled, barPos + barItemOffset * i, interfaceScale());
auto portraitOffset = jsonToVec2F(assets->json("/interface.config:monsterHealth.portraitOffset")) * interfaceScale();
auto portraitScale = assets->json("/interface.config:monsterHealth.portraitScale").toFloat() * interfaceScale();
auto portraitScissorRect = jsonToRectF(assets->json("/interface.config:monsterHealth.portraitScissorRect")).scaled(interfaceScale());
auto rect = portraitScissorRect.translated(backgroundCenterPos + portraitOffset);
m_guiContext->setInterfaceScissorRect(RectI(RectF(rect).scaled(1.0f / interfaceScale())));
auto portraitMaxSize = jsonToVec2I(assets->json("/interface.config:monsterHealth.portraitMaxSize"));
List<Drawable> portrait = showDamageEntity->portrait(PortraitMode::Full);
auto bounds = Drawable::boundBoxAll(portrait, true);
if (m_portraitScale == 0)
m_portraitScale = max<int>(1, ceil(max(bounds.size().x() / portraitMaxSize.x(), bounds.size().y() / portraitMaxSize.y())));
Drawable::translateAll(portrait, {-bounds.xMin() - (bounds.width() * 0.5f), -bounds.yMin() }); // crop out whitespace, align bottom center
Drawable::scaleAll(portrait, 1.0f / m_portraitScale);
for (auto drawable : portrait)
Fixed a huge amount of Clang warnings On Linux and macOS, using Clang to compile OpenStarbound produces about 400 MB worth of warnings during the build, making the compiler output unreadable and slowing the build down considerably. 99% of the warnings were unqualified uses of std::move and std::forward, which are now all properly qualified. Fixed a few other minor warnings about non-virtual destructors and some uses of std::move preventing copy elision on temporary objects. Most remaining warnings are now unused parameters.
2024-02-19 15:55:19 +00:00
m_guiContext->drawDrawable(std::move(drawable), backgroundCenterPos + portraitOffset, portraitScale);
everything everywhere all at once
2023-06-20 04:33:09 +00:00
m_guiContext->resetInterfaceScissorRect();
}
}
void MainInterface::renderSpecialDamageBar() {
if (m_specialDamageBarTarget == NullEntityId)
return;
auto assets = Root::singleton().assets();
auto imgMetadata = Root::singleton().imageMetadataDatabase();
if (auto target = as<DamageBarEntity>(m_client->worldClient()->entity(m_specialDamageBarTarget))) {
Vec2F bottomCenter = Vec2F(windowWidth() / 2.0f, 0);
auto barConfig = assets->json("/interface.config:specialDamageBar");
auto background = barConfig.getString("background");
auto backgroundOffset = jsonToVec2F(barConfig.get("backgroundOffset")) * interfaceScale();
auto screenPos = RectF::withSize(bottomCenter + backgroundOffset, Vec2F(imgMetadata->imageSize(background) * interfaceScale()));
m_guiContext->drawQuad(background, screenPos);
auto fill = barConfig.getString("fill");
auto fillOffset = jsonToVec2F(barConfig.get("fillOffset")) * interfaceScale();
Vec2F size = Vec2F(barConfig.getInt("fillWidth") * m_specialDamageBarValue, imgMetadata->imageSize(fill).y());
m_guiContext->drawQuad(fill, RectF::withSize(bottomCenter + fillOffset, size * interfaceScale()));
auto nameOffset = jsonToVec2F(barConfig.get("nameOffset")) * interfaceScale();
oops - fix broken damage bar after text styling change
2024-04-23 04:11:26 +00:00
m_guiContext->setFontColor(jsonToColor(barConfig.get("nameColor")).toRgba());
everything everywhere all at once
2023-06-20 04:33:09 +00:00
m_guiContext->setFontSize(barConfig.getUInt("nameSize"));
oops - fix broken damage bar after text styling change
2024-04-23 04:11:26 +00:00
if (auto style = barConfig.get("nameStyle"))
m_guiContext->setTextStyle(style);
everything everywhere all at once
2023-06-20 04:33:09 +00:00
m_guiContext->renderText(target->name(), TextPositioning(bottomCenter + nameOffset, HorizontalAnchor::HMidAnchor, VerticalAnchor::BottomAnchor));
Lua chat callbacks + better font styling golly gee whiz!! i hope i didn't fuck something up
2024-04-21 20:07:59 +00:00
m_guiContext->clearTextStyle();
everything everywhere all at once
2023-06-20 04:33:09 +00:00
}
}
void MainInterface::renderMainBar() {
Vec2I barPos = mainBarPosition();
m_cursorTooltip = {};
auto assets = Root::singleton().assets();
Vec2I inventoryButtonPos = barPos + m_config->mainBarInventoryButtonOffset * interfaceScale();
if (m_paneManager.registeredPaneIsDisplayed(MainInterfacePanes::Inventory)) {
if (overButton(m_config->mainBarInventoryButtonPoly, m_cursorScreenPos)) {
m_guiContext->drawQuad(m_config->inventoryImageOpenHover, Vec2F(inventoryButtonPos), interfaceScale());
m_cursorTooltip = assets->json("/interface.config:cursorTooltip.inventoryText").toString();
} else {
m_guiContext->drawQuad(m_config->inventoryImageOpen, Vec2F(inventoryButtonPos), interfaceScale());
}
} else if (overButton(m_config->mainBarInventoryButtonPoly, m_cursorScreenPos)) {
if (m_inventoryWindow->containsNewItems())
m_guiContext->drawQuad(m_config->inventoryImageGlowHover, Vec2F(inventoryButtonPos), interfaceScale());
else
m_guiContext->drawQuad(m_config->inventoryImageHover, Vec2F(inventoryButtonPos), interfaceScale());
m_cursorTooltip = assets->json("/interface.config:cursorTooltip.inventoryText").toString();
} else {
if (m_inventoryWindow->containsNewItems())
m_guiContext->drawQuad(m_config->inventoryImageGlow, Vec2F(inventoryButtonPos), interfaceScale());
else
m_guiContext->drawQuad(m_config->inventoryImage, Vec2F(inventoryButtonPos), interfaceScale());
}
auto drawStateButton = [this](MainInterfacePanes paneType, Vec2I pos, PolyI poly,
String image, String hoverImage, String openImage, String hoverOpenImage, String toolTip) {
if (m_paneManager.registeredPaneIsDisplayed(paneType)) {
if (overButton(poly, m_cursorScreenPos)) {
m_guiContext->drawQuad(hoverOpenImage, Vec2F(pos), interfaceScale());
m_cursorTooltip = toolTip;
} else {
m_guiContext->drawQuad(openImage, Vec2F(pos), interfaceScale());
}
} else if (overButton(poly, m_cursorScreenPos)) {
m_guiContext->drawQuad(hoverImage, Vec2F(pos), interfaceScale());
m_cursorTooltip = toolTip;
} else {
m_guiContext->drawQuad(image, Vec2F(pos), interfaceScale());
}
};
Vec2I craftButtonPos = barPos + m_config->mainBarCraftButtonOffset * interfaceScale();
drawStateButton(MainInterfacePanes::CraftingPlain,
craftButtonPos,
m_config->mainBarCraftButtonPoly,
m_config->craftImage,
m_config->craftImageHover,
m_config->craftImageOpen,
m_config->craftImageOpenHover,
assets->json("/interface.config:cursorTooltip.craftingText").toString());
Vec2I codexButtonPos = barPos + m_config->mainBarCodexButtonOffset * interfaceScale();
drawStateButton(MainInterfacePanes::Codex,
codexButtonPos,
m_config->mainBarCodexButtonPoly,
m_config->codexImage,
m_config->codexImageHover,
m_config->codexImageOpen,
m_config->codexImageHoverOpen,
assets->json("/interface.config:cursorTooltip.codexText").toString());
Vec2I mmUpgradeButtonPos = barPos + m_config->mainBarMmUpgradeButtonOffset * interfaceScale();
if (m_client->mainPlayer()->inventory()->essentialItem(EssentialItem::BeamAxe)) {
drawStateButton(MainInterfacePanes::MmUpgrade,
mmUpgradeButtonPos,
m_config->mainBarMmUpgradeButtonPoly,
m_config->mmUpgradeImage,
m_config->mmUpgradeImageHover,
m_config->mmUpgradeImageOpen,
m_config->mmUpgradeImageHoverOpen,
assets->json("/interface.config:cursorTooltip.mmUpgradeText").toString());
} else {
drawStateButton(MainInterfacePanes::MmUpgrade,
mmUpgradeButtonPos,
m_config->mainBarMmUpgradeButtonPoly,
m_config->mmUpgradeImageDisabled,
m_config->mmUpgradeImageDisabled,
m_config->mmUpgradeImageDisabled,
m_config->mmUpgradeImageDisabled,
assets->json("/interface.config:cursorTooltip.disabledText").toString());
}
Vec2I collectionsButtonPos = barPos + m_config->mainBarCollectionsButtonOffset * interfaceScale();
drawStateButton(MainInterfacePanes::Collections,
collectionsButtonPos,
m_config->mainBarCollectionsButtonPoly,
m_config->collectionsImage,
m_config->collectionsImageHover,
m_config->collectionsImageOpen,
m_config->collectionsImageHoverOpen,
assets->json("/interface.config:cursorTooltip.collectionsText").toString());
// when the player can't deploy or beam, show the deploy button disabled
// when the player can beam up they can't deploy down, show beaming up button in deploy button's place
// when the player can only deploy, only show deploy button
// when the player can deploy or beam down, show both buttons
Vec2F deployButtonPos(barPos + m_config->mainBarDeployButtonOffset * interfaceScale());
if (m_client->canBeamUp()) {
if (overButton(m_config->mainBarDeployButtonPoly, m_cursorScreenPos)) {
m_guiContext->drawQuad(m_config->beamUpImageHover, deployButtonPos, interfaceScale());
m_cursorTooltip = assets->json("/interface.config:cursorTooltip.beamUpText").toString();
} else {
m_guiContext->drawQuad(m_config->beamUpImage, deployButtonPos, interfaceScale());
}
} else if (m_client->canBeamDown(true)) {
if (overButton(m_config->mainBarDeployButtonPoly, m_cursorScreenPos)) {
m_guiContext->drawQuad(m_config->deployImageHover, deployButtonPos, interfaceScale());
m_cursorTooltip = assets->json("/interface.config:cursorTooltip.deployText").toString();
} else {
m_guiContext->drawQuad(m_config->deployImage, deployButtonPos, interfaceScale());
}
} else {
m_guiContext->drawQuad(m_config->deployImageDisabled, deployButtonPos, interfaceScale());
}
Vec2F beamButtonPos(barPos + m_config->mainBarBeamButtonOffset * interfaceScale());
if (m_client->canBeamDown()) {
if (overButton(m_config->mainBarBeamButtonPoly, m_cursorScreenPos)) {
m_guiContext->drawQuad(m_config->beamDownImageHover, beamButtonPos, interfaceScale());
m_cursorTooltip = assets->json("/interface.config:cursorTooltip.beamDownText").toString();
} else {
m_guiContext->drawQuad(m_config->beamDownImage, beamButtonPos, interfaceScale());
}
}
Vec2I questLogButtonPos = barPos + m_config->mainBarQuestLogButtonOffset * interfaceScale();
drawStateButton(MainInterfacePanes::QuestLog,
questLogButtonPos,
m_config->mainBarQuestLogButtonPoly,
m_config->questLogImage,
m_config->questLogImageHover,
m_config->questLogImageOpen,
m_config->questLogImageHoverOpen,
assets->json("/interface.config:cursorTooltip.questsText").toString());
}
void MainInterface::renderWindows() {
m_paneManager.render();
}
void MainInterface::renderDebug() {
if (!isDebugDisplayed()) {
SpatialLogger::clear();
m_debugTextRect = RectF::null();
LogMap::clear();
Only do spatial logging when spatial log is observed
2023-08-30 18:55:36 +00:00
SpatialLogger::setObserved(false);
everything everywhere all at once
2023-06-20 04:33:09 +00:00
return;
}
Only do spatial logging when spatial log is observed
2023-08-30 18:55:36 +00:00
SpatialLogger::setObserved(true);
Add toggle for debug HUD
2023-07-03 18:42:16 +00:00
if (m_clientCommandProcessor->debugHudEnabled()) {
auto assets = Root::singleton().assets();
Lua chat callbacks + better font styling golly gee whiz!! i hope i didn't fuck something up
2024-04-21 20:07:59 +00:00
m_guiContext->setTextStyle(m_config->debugTextStyle);
Add toggle for debug HUD
2023-07-03 18:42:16 +00:00
m_guiContext->setLineSpacing(0.5f);
everything everywhere all at once
2023-06-20 04:33:09 +00:00
Add toggle for debug HUD
2023-07-03 18:42:16 +00:00
bool clearMap = m_debugMapClearTimer.wrapTick();
auto logMapValues = LogMap::getValues();
if (clearMap)
LogMap::clear();
everything everywhere all at once
2023-06-20 04:33:09 +00:00
Add toggle for debug HUD
2023-07-03 18:42:16 +00:00
List<String> formatted;
formatted.reserve(logMapValues.size());
Fix font glyph generation to work correctly with other fonts
2023-07-03 04:21:51 +00:00
Add toggle for debug HUD
2023-07-03 18:42:16 +00:00
int counter = 0;
for (auto const& pair : logMapValues) {
Lua chat callbacks + better font styling golly gee whiz!! i hope i didn't fuck something up
2024-04-21 20:07:59 +00:00
TextPositioning positioning = { Vec2F(m_config->debugOffset[0], windowHeight() - m_config->debugOffset[1] - m_config->textStyle.fontSize * interfaceScale() * counter++) };
Add toggle for debug HUD
2023-07-03 18:42:16 +00:00
String& text = formatted.emplace_back(strf("{}^lightgray;:^green,set; {}", pair.first, pair.second));
m_debugTextRect.combine(m_guiContext->determineTextSize(text, positioning).padded(m_config->debugBackgroundPad));
}
everything everywhere all at once
2023-06-20 04:33:09 +00:00
Add toggle for debug HUD
2023-07-03 18:42:16 +00:00
if (!m_debugTextRect.isNull()) {
RenderQuad& quad = m_guiContext->renderer()->immediatePrimitives()
.emplace_back(std::in_place_type_t<RenderQuad>(), m_debugTextRect, m_config->debugBackgroundColor.toRgba(), 0.0f).get<RenderQuad>();
everything everywhere all at once
2023-06-20 04:33:09 +00:00
Add toggle for debug HUD
2023-07-03 18:42:16 +00:00
quad.b.color[3] = quad.c.color[3] = 0;
};
Fix font glyph generation to work correctly with other fonts
2023-07-03 04:21:51 +00:00
Add toggle for debug HUD
2023-07-03 18:42:16 +00:00
m_debugTextRect = RectF::null();
everything everywhere all at once
2023-06-20 04:33:09 +00:00
fix debug logMap text stacking bug was introduced in cd23817bf1884fee4457ab3381320b0c8fc33f48
2024-02-29 08:22:22 +00:00
for (size_t index = 0; index != formatted.size(); ++index) {
Lua chat callbacks + better font styling golly gee whiz!! i hope i didn't fuck something up
2024-04-21 20:07:59 +00:00
TextPositioning positioning = { Vec2F(m_config->debugOffset[0], windowHeight() - m_config->debugOffset[1] - m_config->textStyle.fontSize * interfaceScale() * index) };
Fixed remaining compiler warnings Some warnings (e.g. in Opus and the tests) can't be fixed, only suppressed.
2024-02-28 17:11:55 +00:00
m_guiContext->renderText(formatted[index], positioning);
Add toggle for debug HUD
2023-07-03 18:42:16 +00:00
}
everything everywhere all at once
2023-06-20 04:33:09 +00:00
}
auto const& camera = m_worldPainter->camera();
bool clearSpatial = m_debugSpatialClearTimer.wrapTick();
for (auto const& line : SpatialLogger::getLines("world", clearSpatial)) {
Vec2F begin = camera.worldToScreen(line.begin);
Vec2F end = camera.worldGeometry().diff(line.end, line.begin) * camera.pixelRatio() * TilePixels + begin;
m_guiContext->drawLine(begin, end, line.color, 1);
}
for (auto const& line : SpatialLogger::getLines("screen", clearSpatial))
m_guiContext->drawLine(Vec2F(line.begin), Vec2F(line.end), line.color, 1);
for (auto const& point : SpatialLogger::getPoints("world", clearSpatial)) {
auto position = camera.worldToScreen(point.position);
m_guiContext->drawLine(position + Vec2F(-2, -2), position + Vec2F(-2, 2), point.color, 1);
m_guiContext->drawLine(position + Vec2F(-2, 2), position + Vec2F(2, 2), point.color, 1);
m_guiContext->drawLine(position + Vec2F(2, 2), position + Vec2F(2, -2), point.color, 1);
m_guiContext->drawLine(position + Vec2F(2, -2), position + Vec2F(-2, -2), point.color, 1);
}
for (auto const& point : SpatialLogger::getPoints("screen", clearSpatial)) {
auto position = point.position;
m_guiContext->drawLine(position + Vec2F(-2, -2), position + Vec2F(-2, 2), point.color, 1);
m_guiContext->drawLine(position + Vec2F(-2, 2), position + Vec2F(2, 2), point.color, 1);
m_guiContext->drawLine(position + Vec2F(2, 2), position + Vec2F(2, -2), point.color, 1);
m_guiContext->drawLine(position + Vec2F(2, -2), position + Vec2F(-2, -2), point.color, 1);
}
Lua chat callbacks + better font styling golly gee whiz!! i hope i didn't fuck something up
2024-04-21 20:07:59 +00:00
m_guiContext->setTextStyle(m_config->debugTextStyle);
The Fontpocalypse I hate it
2023-06-21 12:29:40 +00:00
everything everywhere all at once
2023-06-20 04:33:09 +00:00
for (auto const& logText : SpatialLogger::getText("world", clearSpatial)) {
m_guiContext->setFontColor(logText.color);
m_guiContext->renderText(logText.text.utf8Ptr(), camera.worldToScreen(logText.position));
}
for (auto const& logText : SpatialLogger::getText("screen", clearSpatial)) {
m_guiContext->setFontColor(logText.color);
m_guiContext->renderText(logText.text.utf8Ptr(), logText.position);
}
Lua chat callbacks + better font styling golly gee whiz!! i hope i didn't fuck something up
2024-04-21 20:07:59 +00:00
m_guiContext->clearTextStyle();
everything everywhere all at once
2023-06-20 04:33:09 +00:00
}
void MainInterface::updateCursor() {
Maybe<String> cursorOverride = m_actionBar->cursorOverride(m_cursorScreenPos);
if (!cursorOverride) {
if (auto pane = m_paneManager.getPaneAt(m_cursorScreenPos / interfaceScale())) {
cursorOverride = cursorOverride.orMaybe(pane->cursorOverride(m_cursorScreenPos / interfaceScale()));
} else {
auto player = m_client->mainPlayer();
if (auto anchorState = m_client->mainPlayer()->loungingIn()) {
if (auto loungeable = m_client->worldClient()->get<LoungeableEntity>(anchorState->entityId)) {
if (auto loungeAnchor = loungeable->loungeAnchor(anchorState->positionIndex))
cursorOverride = cursorOverride.orMaybe(loungeAnchor->cursorOverride);
}
}
if (!cursorOverride) {
for (auto item : {player->primaryHandItem(), player->altHandItem()}) {
if (auto activeItem = as<ActiveItem>(item)) {
if (auto cursor = activeItem->cursor()) {
cursorOverride = cursor;
break;
}
} else if (auto inspectionTool = as<InspectionTool>(item)) {
cursorOverride = String("/cursors/inspect.cursor");
break;
}
}
}
}
}
if (cursorOverride)
m_cursor.setCursor(cursorOverride.take());
else
m_cursor.resetCursor();
}
void MainInterface::renderCursor() {
// if we're currently playing a cinematic, we should not render the mouse.
if (m_cinematicOverlay && !m_cinematicOverlay->completed())
Hide the hardware cursor when in a cinematic
2023-06-23 09:01:22 +00:00
return m_guiContext->applicationController()->setCursorVisible(false);
everything everywhere all at once
2023-06-20 04:33:09 +00:00
Vec2I cursorPos = m_cursorScreenPos;
Vec2I cursorSize = m_cursor.size();
Vec2I cursorOffset = m_cursor.offset();
HD Cursor
2023-06-26 08:39:40 +00:00
unsigned int cursorScale = m_cursor.scale(interfaceScale());
Drawable cursorDrawable = m_cursor.drawable();
cursorPos[0] -= cursorOffset[0] * cursorScale;
cursorPos[1] -= (cursorSize[1] - cursorOffset[1]) * cursorScale;
if (!m_guiContext->trySetCursor(cursorDrawable, cursorOffset, cursorScale))
m_guiContext->drawDrawable(cursorDrawable, Vec2F(cursorPos), cursorScale);
everything everywhere all at once
2023-06-20 04:33:09 +00:00
if (m_cursorTooltip) {
auto assets = Root::singleton().assets();
auto imgDb = Root::singleton().imageMetadataDatabase();
Lua chat callbacks + better font styling golly gee whiz!! i hope i didn't fuck something up
2024-04-21 20:07:59 +00:00
auto config = assets->json("/interface.config:cursorTooltip");
auto backgroundImage = config.getString("background");
auto rawCursorOffset = jsonToVec2I(config.get("offset"));
everything everywhere all at once
2023-06-20 04:33:09 +00:00
Vec2I tooltipSize = Vec2I(imgDb->imageSize(backgroundImage)) * interfaceScale();
HD Cursor
2023-06-26 08:39:40 +00:00
Vec2I cursorOffset = (Vec2I{0, -m_cursor.size().y()} + rawCursorOffset) * cursorScale;
everything everywhere all at once
2023-06-20 04:33:09 +00:00
Vec2I tooltipOffset = m_cursorScreenPos + cursorOffset;
Lua chat callbacks + better font styling golly gee whiz!! i hope i didn't fuck something up
2024-04-21 20:07:59 +00:00
TextStyle textStyle = config.get("textStyle");
size_t fontSize = config.get("fontSize").toUInt();
Vec4B fontColor = jsonToColor(config.get("color")).toRgba();
everything everywhere all at once
2023-06-20 04:33:09 +00:00
m_guiContext->drawQuad(backgroundImage, Vec2F(tooltipOffset) + Vec2F(-tooltipSize.x(), 0), interfaceScale());
Lua chat callbacks + better font styling golly gee whiz!! i hope i didn't fuck something up
2024-04-21 20:07:59 +00:00
m_guiContext->setTextStyle(textStyle);
everything everywhere all at once
2023-06-20 04:33:09 +00:00
m_guiContext->setFontSize(fontSize);
m_guiContext->setFontColor(fontColor);
m_guiContext->renderText(*m_cursorTooltip,
TextPositioning(Vec2F(tooltipOffset) + Vec2F(-tooltipSize.x(), tooltipSize.y()) / 2,
HorizontalAnchor::HMidAnchor,
VerticalAnchor::VMidAnchor));
Lua chat callbacks + better font styling golly gee whiz!! i hope i didn't fuck something up
2024-04-21 20:07:59 +00:00
m_guiContext->clearTextStyle();
everything everywhere all at once
2023-06-20 04:33:09 +00:00
}
Improve AssetPath::split also fixed a bug with the cursor changes
2023-06-26 15:04:58 +00:00
m_cursorItem->setPosition(m_cursorScreenPos / interfaceScale() + m_config->inventoryItemMouseOffset);
everything everywhere all at once
2023-06-20 04:33:09 +00:00
if (auto swapItem = m_client->mainPlayer()->inventory()->swapSlotItem())
m_cursorItem->setItem(swapItem);
else
m_cursorItem->setItem({});
m_cursorItem->render(RectI::withSize({}, {(int)windowWidth(), (int)windowHeight()}));
m_guiContext->resetInterfaceScissorRect();
}
bool MainInterface::overButton(PolyI buttonPoly, Vec2I const& mousePos) const {
Vec2I barPos = mainBarPosition();
buttonPoly.translate(barPos);
buttonPoly.scale(interfaceScale(), barPos);
return buttonPoly.contains(mousePos);
}
Fixed remaining compiler warnings Some warnings (e.g. in Opus and the tests) can't be fixed, only suppressed.
2024-02-28 17:11:55 +00:00
bool MainInterface::overlayClick(Vec2I const& mousePos, MouseButton) {
everything everywhere all at once
2023-06-20 04:33:09 +00:00
PolyI mainBarPoly = m_config->mainBarPoly;
Vec2I barPos = mainBarPosition();
mainBarPoly.translate(barPos);
mainBarPoly.scale(interfaceScale(), barPos);
if (overButton(m_config->mainBarInventoryButtonPoly, mousePos)) {
m_paneManager.toggleRegisteredPane(MainInterfacePanes::Inventory);
Input Binding support
2023-07-02 07:19:54 +00:00
return true;
everything everywhere all at once
2023-06-20 04:33:09 +00:00
}
if (overButton(m_config->mainBarCraftButtonPoly, mousePos)) {
togglePlainCraftingWindow();
Input Binding support
2023-07-02 07:19:54 +00:00
return true;
everything everywhere all at once
2023-06-20 04:33:09 +00:00
}
if (overButton(m_config->mainBarCodexButtonPoly, mousePos)) {
m_paneManager.toggleRegisteredPane(MainInterfacePanes::Codex);
Input Binding support
2023-07-02 07:19:54 +00:00
return true;
everything everywhere all at once
2023-06-20 04:33:09 +00:00
}
if (overButton(m_config->mainBarDeployButtonPoly, mousePos)) {
if (m_client->canBeamDown(true))
warpToOrbitedWorld(true);
else if (m_client->canBeamUp())
warpToOwnShip();
Input Binding support
2023-07-02 07:19:54 +00:00
return true;
everything everywhere all at once
2023-06-20 04:33:09 +00:00
}
if (overButton(m_config->mainBarBeamButtonPoly, mousePos)) {
if (m_client->canBeamDown())
warpToOrbitedWorld();
Input Binding support
2023-07-02 07:19:54 +00:00
return true;
everything everywhere all at once
2023-06-20 04:33:09 +00:00
}
if (overButton(m_config->mainBarQuestLogButtonPoly, mousePos)) {
m_paneManager.toggleRegisteredPane(MainInterfacePanes::QuestLog);
Input Binding support
2023-07-02 07:19:54 +00:00
return true;
everything everywhere all at once
2023-06-20 04:33:09 +00:00
}
if (overButton(m_config->mainBarMmUpgradeButtonPoly, mousePos)) {
if (m_client->mainPlayer()->inventory()->essentialItem(EssentialItem::BeamAxe))
m_paneManager.toggleRegisteredPane(MainInterfacePanes::MmUpgrade);
Input Binding support
2023-07-02 07:19:54 +00:00
return true;
everything everywhere all at once
2023-06-20 04:33:09 +00:00
}
if (overButton(m_config->mainBarCollectionsButtonPoly, mousePos)) {
m_paneManager.toggleRegisteredPane(MainInterfacePanes::Collections);
Input Binding support
2023-07-02 07:19:54 +00:00
return true;
everything everywhere all at once
2023-06-20 04:33:09 +00:00
}
Input Binding support
2023-07-02 07:19:54 +00:00
return false;
everything everywhere all at once
2023-06-20 04:33:09 +00:00
}
Reset script panes on character swap
2023-07-28 16:12:03 +00:00
void MainInterface::displayScriptPane(ScriptPanePtr& scriptPane, EntityId sourceEntity) {
// keep any number of script panes open with null source entities
if (sourceEntity != NullEntityId)
m_interactionScriptPanes[sourceEntity] = scriptPane;
ScriptPanes can specify paneLayer and interactive
2023-07-29 14:41:38 +00:00
PaneLayer layer = PaneLayer::Window;
if (auto layerName = scriptPane->config().optString("paneLayer"))
layer = PaneLayerNames.getLeft(*layerName);
Reset script panes on character swap
2023-07-28 16:12:03 +00:00
if (scriptPane->openWithInventory()) {
slightly smarter inventory close behavior with panes that open with the inventory
2024-05-23 02:12:07 +00:00
bool closeWithInventory = scriptPane->closeWithInventory();
m_paneManager.displayPane(layer, scriptPane, [this, closeWithInventory](PanePtr const&) {
if (closeWithInventory)
m_paneManager.dismissRegisteredPane(MainInterfacePanes::Inventory);
Reset script panes on character swap
2023-07-28 16:12:03 +00:00
});
m_paneManager.displayRegisteredPane(MainInterfacePanes::Inventory);
m_paneManager.bringPaneAdjacent(m_paneManager.registeredPane(MainInterfacePanes::Inventory),
scriptPane, Root::singleton().assets()->json("/interface.config:bringAdjacentWindowGap").toFloat());
} else {
ScriptPanes can specify paneLayer and interactive
2023-07-29 14:41:38 +00:00
m_paneManager.displayPane(layer, scriptPane);
Reset script panes on character swap
2023-07-28 16:12:03 +00:00
}
}
everything everywhere all at once
2023-06-20 04:33:09 +00:00
}
Reference in New Issue Copy Permalink