void GameBoardScreen::HandleInput()

in ID@XboxSDK/GameSave/UWP/GameLogic/GameBoardScreen.cpp [452:723]


void GameBoardScreen::HandleInput(const DirectX::InputState & input)
{
    // Handle menu input
    MenuScreen::HandleInput(input);

    // Handle non-menu game board input if there's an active board
    auto gameSaveManager = Game->GameSaveManager;

    if (gameSaveManager->HasActiveBoard)
    {
        std::lock_guard<std::mutex> lock(gameSaveManager->ActiveBoardGameSave->m_mutex);

        int controllingPlayer = GetControllingPlayer();
        auto activeBoard = gameSaveManager->ActiveBoard;
        auto activeBoardNum = gameSaveManager->ActiveBoardNumber;
        auto& gameBoard = gameSaveManager->ActiveBoard;
        auto& currentTile = gameBoard.GetGameTile(m_cursorPosition);
        auto letterPressed = input.GetLetterPressed();
        auto numberPressed = input.GetNumberPressed();
        XMINT2 mouseClick = XMINT2();

        if (!m_menuActive && letterPressed > 0)
        {
            if (!currentTile.m_placed || (currentTile.m_letter != letterPressed))
            {
                currentTile.m_placed = true;
                currentTile.m_letter = letterPressed;
                gameSaveManager->MarkActiveBoardDirty();
            }
        }
        else if (numberPressed > 0 && numberPressed <= c_saveSlotCount)
        {
            if (numberPressed < activeBoardNum)
            {
                gameSaveManager->ActiveBoardNumber = numberPressed;
                m_firstSlotToDisplay = std::min(numberPressed, m_firstSlotToDisplay);
            }
            else if (numberPressed > activeBoardNum)
            {
                gameSaveManager->ActiveBoardNumber = numberPressed;
                m_firstSlotToDisplay = std::max(m_firstSlotToDisplay, numberPressed - 2);
            }
        }
        else if (input.IsMouseSelect(mouseClick))
        {
            auto localMouseClick = DX::ConvertWindowPixelToLocalCoord(Manager()->GetWindowBounds(), mouseClick);
            auto localMouseClickF = XMFLOAT2(float(localMouseClick.x), float(localMouseClick.y));
            if (DX::IsPointInsideRectangle(localMouseClick, c_letterTileRegion))
            {
                for (uint32_t j = 0; j < activeBoard.m_boardHeight; ++j)
                {
                    for (uint32_t i = 0; i < activeBoard.m_boardWidth; ++i)
                    {
                        XMFLOAT2 tileCenter = XMFLOAT2(c_letterTileFirstTile_Center.x + (c_letterTile_CenterOffset.x * i), c_letterTileFirstTile_Center.y + (c_letterTile_CenterOffset.y * j));
                        if (DX::IsPointInsideCircle(localMouseClickF, tileCenter, c_letterTileRadius))
                        {
                            m_cursorPosition.x = i;
                            m_cursorPosition.y = j;
                            m_menuActive = false;
                            return;
                        }
                    }
                }
            }
            else if (DX::IsPointInsideCircle(localMouseClickF, c_saveSlotFirstNumber_CircleCenter, c_saveSlotNumber_Radius))
            {
                gameSaveManager->ActiveBoardNumber = m_firstSlotToDisplay;
            }
            else if (DX::IsPointInsideCircle(localMouseClickF, c_saveSlotSecondNumber_CircleCenter, c_saveSlotNumber_Radius))
            {
                gameSaveManager->ActiveBoardNumber = m_firstSlotToDisplay + 1;
            }
            else if (DX::IsPointInsideCircle(localMouseClickF, c_saveSlotThirdNumber_CircleCenter, c_saveSlotNumber_Radius))
            {
                gameSaveManager->ActiveBoardNumber = m_firstSlotToDisplay + 2;
            }
        }
        else if (!m_menuActive &&
            (input.IsNewButtonPress(GamepadButtons::X, controllingPlayer)
            || input.IsNewKeyPress(Keyboard::Keys::Space)
            || input.IsNewKeyPress(Keyboard::Keys::Delete)))
        {
            if (currentTile.m_placed)
            {
                gameSaveManager->MarkActiveBoardDirty();
            }
            currentTile.m_letter = 0;
            currentTile.m_placed = false;
        }
        else if (!m_menuActive && input.IsTileScrollUp(controllingPlayer))
        {
            if (m_tileScrollUpDelay <= 0)
            {
                // advance tile value
                if (!currentTile.m_placed)
                {
                    currentTile.m_placed = true;
                    currentTile.m_letter = L'A';
                }
                else
                {
                    if (currentTile.m_letter >= L'A'
                        && currentTile.m_letter < L'Z')
                    {
                        currentTile.m_letter++;
                    }
                    else
                    {
                        currentTile.m_letter = L'A';
                    }
                }

                gameSaveManager->MarkActiveBoardDirty();
                m_tileScrollUpDelay = c_letterTileScrollDelay_Seconds;
            }
        }
        else if (!m_menuActive && input.IsTileScrollDown(controllingPlayer))
        {
            if (m_tileScrollDownDelay <= 0)
            {
                // decrease tile value
                if (!currentTile.m_placed)
                {
                    currentTile.m_placed = true;
                    currentTile.m_letter = L'Z';
                }
                else
                {
                    if (currentTile.m_letter > L'A'
                        && currentTile.m_letter <= L'Z')
                    {
                        currentTile.m_letter--;
                    }
                    else
                    {
                        currentTile.m_letter = L'Z';
                    }
                }

                gameSaveManager->MarkActiveBoardDirty();
                m_tileScrollDownDelay = c_letterTileScrollDelay_Seconds;
            }
        }
        else if (input.IsLogScrollUp())
        {
            size_t maxDisplayLines = static_cast<size_t>(c_debugLog_Region.Height / m_logFontHeight);
            auto logIndexSize = Log::g_displayLog.size();
            if (m_logLineBegin == 0)
            {
                if (logIndexSize > maxDisplayLines)
                {
                    // stop auto-scroll at current top line
                    m_logLineBegin = logIndexSize - maxDisplayLines;
                }
            }
            else
            {
                if (m_logScrollUpDelay <= 0)
                {
                    // scroll up
                    m_logLineBegin = std::max(m_logLineBegin - 1, size_t(1));
                    m_logScrollUpDelay = c_debugLogScrollDelay_Seconds;
                }
            }
        }
        else if (input.IsLogScrollDown())
        {
            if (m_logLineBegin > 0)
            {
                size_t maxDisplayLines = static_cast<size_t>(c_debugLog_Region.Height / m_logFontHeight);
                auto logIndexSize = Log::g_displayLog.size();

                if ((m_logLineBegin + 1) > (logIndexSize - maxDisplayLines))
                {
                    // turn auto-scroll back on
                    m_logLineBegin = 0;
                }

                if (m_logScrollDownDelay <= 0)
                {
                    // scroll down
                    m_logLineBegin++;
                    m_logScrollDownDelay = c_debugLogScrollDelay_Seconds;
                }
            }
        }
        else if (input.IsNewKeyPress(Keyboard::Keys::Home))
        {
            size_t maxDisplayLines = static_cast<size_t>(c_debugLog_Region.Height / m_logFontHeight);
            auto logIndexSize = Log::g_displayLog.size();
            if (logIndexSize > maxDisplayLines)
            {
                m_logLineBegin = 1;
            }
            else
            {
                m_logLineBegin = 0;
            }
        }
        else if (input.IsNewKeyPress(Keyboard::Keys::End))
        {
            m_logLineBegin = 0;
        }
        else if (input.IsNewButtonPress(GamepadButtons::LeftShoulder, controllingPlayer) && activeBoardNum > 1)
        {
            auto newActiveBoardNum = activeBoardNum - 1;
            gameSaveManager->ActiveBoardNumber = newActiveBoardNum;
            m_firstSlotToDisplay = std::min(newActiveBoardNum, m_firstSlotToDisplay);
        }
        else if (input.IsNewButtonPress(GamepadButtons::RightShoulder, controllingPlayer) && activeBoardNum < c_saveSlotCount)
        {
            auto newActiveBoardNum = activeBoardNum + 1;
            gameSaveManager->ActiveBoardNumber = newActiveBoardNum;
            m_firstSlotToDisplay = std::max(m_firstSlotToDisplay, newActiveBoardNum - 2);
        }
        else if (input.IsCursorLeft(controllingPlayer, nullptr))
        {
            if (m_menuActive)
            {
                m_menuActive = false;
                m_cursorPosition.x = gameBoard.m_boardWidth - 1;
            }
            else if (m_cursorPosition.x > 0)
            {
                m_cursorPosition.x--;
            }
            else
            {
                m_menuActive = true;
            }
        }
        else if (input.IsCursorRight(controllingPlayer, nullptr))
        {
            if (m_menuActive)
            {
                m_menuActive = false;
                m_cursorPosition.x = 0;
            }
            else if (m_cursorPosition.x < gameBoard.m_boardWidth - 1)
            {
                m_cursorPosition.x++;
            }
            else
            {
                m_menuActive = true;
            }

        }
        else if (!m_menuActive && input.IsCursorUp(controllingPlayer, nullptr))
        {
            if (m_cursorPosition.y > 0)
            {
                m_cursorPosition.y--;
            }
            else
            {
                m_cursorPosition.y = gameBoard.m_boardHeight - 1;
            }
        }
        else if (!m_menuActive && input.IsCursorDown(controllingPlayer, nullptr))
        {
            if (m_cursorPosition.y < gameBoard.m_boardHeight - 1)
            {
                m_cursorPosition.y++;
            }
            else
            {
                m_cursorPosition.y = 0;
            }
        }
    } // HasActiveBoard
}