tournamentsetupstate.cpp

来自「Source code (C++) of the Amoebax game fo」· C++ 代码 · 共 781 行 · 第 1/2 页

              currentCharacter++,
                x += static_cast<uint16_t> (k_FaceSpan * originalScale) )
        {
            faces->blit ((currentCharacter % k_FacesPerRow) * faceWidth,
                         (currentCharacter / k_FacesPerRow) * faceHeight,
                         faceWidth, faceHeight, x,
                         static_cast<uint16_t> (k_MaleFacesRowY *
                                                originalScale),
                         m_Background->toSDLSurface());
        }
        for ( uint16_t currentCharacter = 1,
                       x = static_cast<uint16_t> (k_FaceStartX * originalScale);
              currentCharacter < 7 ;
              currentCharacter++,
                x += static_cast<uint16_t> (k_FaceSpan * originalScale) )
        {
            faces->blit ((currentCharacter % k_FacesPerRow) * faceWidth,
                         faceHeight, faceWidth, faceHeight, x,
                         static_cast<uint16_t> (k_ComputerFacesRowY *
                                                originalScale),
                         m_Background->toSDLSurface());
        }
    }
    {
        std::auto_ptr<Surface> title (
                Surface::fromFile (File::getGraphicsFilePath ("humanplayers.png")));
        title->blit (static_cast<uint16_t> (k_FaceStartX * originalScale),
                     static_cast<uint16_t> (k_HumanCharactersLabelY *
                                            originalScale),
                     m_Background->toSDLSurface ());
    }
    {
        std::auto_ptr<Surface> title (
                Surface::fromFile (File::getGraphicsFilePath ("computerplayers.png")));
        title->blit (static_cast<uint16_t> (k_FaceStartX * originalScale),
                     static_cast<uint16_t> (k_ComputerCharactersLabelY *
                                            originalScale),
                     m_Background->toSDLSurface ());
    }
    {
        std::auto_ptr<Surface> title (
                Surface::fromFile (File::getGraphicsFilePath ("tournament.png")));
        title->blit (m_Background->getWidth () / 2 -
                     title->getWidth () / 2, 0, m_Background->toSDLSurface ());
    }
    m_Background->resize (screenScale);

    for ( uint32_t currentCharacter = 0 ; currentCharacter < k_NumCharacters ;
          ++currentCharacter )
    {
        m_Characters[currentCharacter].image.reset (
                Surface::fromFile (File::getGraphicsFilePath (
                        m_Characters[currentCharacter].name + ".png")));
        m_Characters[currentCharacter].image->resize (screenScale);
    }

    m_Selection.reset (
            Surface::fromFile (File::getGraphicsFilePath ("faceSelection.png")));
    m_Selection->resize (screenScale);

    m_Font.reset (
            Font::fromFile (File::getFontFilePath ("fontMenu")));
}

void
TournamentSetupState::redrawBackground (SDL_Rect *region, SDL_Surface *screen)
{
    m_Background->blit (region->x, region->y, region->w, region->h,
                        region->x, region->y, screen);
}

void
TournamentSetupState::render (SDL_Surface *screen)
{
    const float screenScale = System::getInstance ().getScreenScaleFactor ();

    if ( !allCharactersSelected () )
    {
        std::ostringstream selectPlayerString;
        selectPlayerString << "Select Player ";
        selectPlayerString << getCurrentPlayer() + 1;
        m_Font->write (selectPlayerString.str(),
                       static_cast<uint16_t> (k_SelectPlayerX * screenScale),
                       static_cast<uint16_t> (k_SelectPlayerY * screenScale),
                       screen);
    }

    // Render the currently selected character's image and name.
    uint16_t x =
        static_cast<uint16_t> (k_CharacterImageX * screenScale -
                               getSelectedCharacter ().image->getWidth () / 2);
    uint16_t y =
        static_cast<uint16_t> (k_CharacterImageY * screenScale -
                               getSelectedCharacter ().image->getHeight () / 2);
    getSelectedCharacter ().image->blit (x, y, screen);
    uint16_t textWidth = m_Font->getTextWidth (getSelectedCharacter ().name);
    m_Font->write (getSelectedCharacter ().name,
                   static_cast<uint16_t> (k_CharacterImageX * screenScale -
                                          textWidth / 2),
                   y + getSelectedCharacter ().image->getHeight (), screen);


    // Render the already selected characters.
    for ( std::vector<SelectedCharacter>::const_iterator currentCharacter = m_SelectedCharacters.begin () ;
          currentCharacter != m_SelectedCharacters.end () ;
          ++currentCharacter )
    {
        x = static_cast<uint16_t> (getXPositionOfCol (currentCharacter->col) *
                                   screenScale);
        y = static_cast<uint16_t> (getYPositionOfRow (currentCharacter->row) *
                                   screenScale);

        m_Selection->blit (m_Selection->getWidth () - m_Selection->getHeight (),
                           0,
                           m_Selection->getHeight (), m_Selection->getHeight (),
                           x, y, screen);
    }
    // Render the character selection on the character grid.
    if ( !allCharactersSelected () )
    {
        x = static_cast<uint16_t> (getXPositionOfCol (getSelectedCol ()) *
                                   screenScale);
        y = static_cast<uint16_t> (getYPositionOfRow (getSelectedRow ()) *
                                   screenScale);
        m_Selection->blit (m_Selection->getHeight () * getCurrentPlayer (), 0,
                           m_Selection->getHeight (), m_Selection->getHeight (),
                           x, y, screen);
    }
}

///
/// \brief Selects the currently selected character as the player's character.
///
void
TournamentSetupState::selectCharacter (void)
{
    // If all characters are selected, then we just move
    // forward to the next state.
    if ( allCharactersSelected () )
    {
        setTimeToWait (0);
        return;
    }

    SelectedCharacter selectedCharacter;
    selectedCharacter.col = getSelectedCol ();
    selectedCharacter.index = getSelectedCharacterIndex ();
    selectedCharacter.row = getSelectedRow ();
    m_SelectedCharacters.push_back (selectedCharacter);

    setNextPlayer ();
    if ( allCharactersSelected () )
    {
        setTimeToWait (k_TimeToWait);
    }
    else
    {
        selectFirstCharacter ();
    }
}

///
/// \brief Sets the first available character as the selected.
///
void
TournamentSetupState::selectFirstCharacter (void)
{
    if ( allCharactersSelected () )
    {
        return;
    }

    setSelectedCol (0);
    setSelectedRow (0);
    if ( !isSelectedPositionValid () )
    {
        selectNextCol ();
    }
}

///
/// \brief Selects the next available column.
///
/// If the next row is behind the last one, the first column
/// of the next row is selected.
///
void
TournamentSetupState::selectNextCol (void)
{
    if ( allCharactersSelected () )
    {
        return;
    }

    if ( (getSelectedRow () != k_ComputerFacesRow &&
          getSelectedCol () < (k_HumanCharactersColumns - 1)) ||
         (getSelectedRow () == k_ComputerFacesRow &&
          getSelectedCol () < (k_ComputerCharactersColumns - 1)) )
    {
        setSelectedCol (getSelectedCol () + 1);
    }
    else
    {
        selectNextRow ();
        setSelectedCol (0);
    }
    if ( !isSelectedPositionValid () )
    {
        selectNextCol ();
    }
}

///
/// \brief Selects the next available row.
///
/// If the next row is after the last one, the first row is selected.
///
void
TournamentSetupState::selectNextRow (void)
{
    if ( allCharactersSelected () )
    {
        return;
    }

    setSelectedRow ((getSelectedRow () + 1) % k_NumCharactersRows);
    if ( getSelectedRow () != k_ComputerFacesRow &&
         getSelectedCol () > (k_HumanCharactersColumns - 1) )
    {
        setSelectedCol (k_HumanCharactersColumns - 1);
    }
    if ( !isSelectedPositionValid () )
    {
        selectNextCol ();
    }
}

///
/// \brief Selects the previous available column.
///
/// If the previous column is before the first one, the last column
/// of the previous column is selected.
///
void
TournamentSetupState::selectPreviousCol (void)
{
    if ( allCharactersSelected () )
    {
        return;
    }

    if ( getSelectedCol () > 0 )
    {
        setSelectedCol (getSelectedCol () - 1);
    }
    else
    {
        if ( getSelectedRow () == k_FemaleFacesRow )
        {
            setSelectedCol (k_ComputerCharactersColumns - 1);
        }
        else
        {
            setSelectedCol (k_HumanCharactersColumns - 1);
        }
        selectPreviousRow ();
    }
    if ( !isSelectedPositionValid () )
    {
        selectPreviousCol ();
    }
}

///
/// \brief Selectes the previous row.
///
/// If the previous row is before the first, the last column is selected.
///
void
TournamentSetupState::selectPreviousRow (void)
{
    if ( allCharactersSelected () )
    {
        return;
    }

    if ( getSelectedRow () > 0 )
    {
        setSelectedRow (getSelectedRow () - 1);
        // Since the computer characters row is the last one, we
        // can be sure that the row we are now is a human characters row.
        if ( getSelectedCol () > (k_HumanCharactersColumns - 1) )
        {
            setSelectedCol (k_HumanCharactersColumns - 1);
        }
    }
    else
    {
        setSelectedRow (k_ComputerFacesRow);
    }
    if ( !isSelectedPositionValid () )
    {
        selectNextCol ();
    }
}

///
/// \brief Increments the current player.
///
inline void
TournamentSetupState::setNextPlayer (void)
{
    ++m_CurrentPlayer;
}

///
/// \brief Decrements the current player.
///
inline void
TournamentSetupState::setPreviousPlayer (void)
{
    --m_CurrentPlayer;
}

///
/// \brief Sets the currently selected column.
///
/// \param col The column to set as selected.
///
inline void
TournamentSetupState::setSelectedCol (uint8_t col)
{
    m_SelectedCol = col;
}

///
/// \brief Sets the currently selected row.
///
/// \param row The row to set as selected.
///
inline void
TournamentSetupState::setSelectedRow (uint8_t row)
{
    m_SelectedRow = row;
}

///
/// \brief Sets the time to wait before changing to the tournament state.
///
/// \param timeToWait The time to wait in milliseconds.
///
inline void
TournamentSetupState::setTimeToWait (int32_t timeToWait)
{
    m_TimeToWait = timeToWait;
}

void
TournamentSetupState::update (uint32_t elapsedTime)
{
    if ( allCharactersSelected () )
    {
        setTimeToWait (getTimeToWait () - elapsedTime);
        if ( getTimeToWait () <= 0 )
        {
            std::vector <TournamentState::Player> tournamentPlayers;
            for (std::vector <SelectedCharacter>::const_iterator currentPlayer = m_SelectedCharacters.begin() ;
                 currentPlayer != m_SelectedCharacters.end() ; ++currentPlayer)
            {
                TournamentState::Player player;
                player.characterIndex = currentPlayer->index;
                player.name = m_Characters[currentPlayer->index].name;
                player.isComputerPlayer = k_ComputerFacesRow == currentPlayer->row;
                player.computerPlayerLevel = currentPlayer->col;
                tournamentPlayers.push_back (player);
            }
            System::getInstance ().removeActiveState (false);
            System::getInstance ().setActiveState (
                    new TournamentState (tournamentPlayers));
        }
    }

}

void
TournamentSetupState::videoModeChanged (void)
{
    loadGraphicResources ();
}