aiplayer.cpp

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

///
/// \brief Computes the score of the next move.
///
void
AIPlayer::computeNextMove (void)
{
    switch ( getWhichPairToCheck () )
    {
        case CheckingCurrentFallingPair:
            checkCurrentFallingPair ();
            break;

        case CheckingNextFallingPair:
            checkNextFallingPair ();
            break;

        case CheckingFollowingFallingPair:
            checkFollowingFallingPair ();
            break;

        default:
            setPairToCheck (CheckingCurrentFallingPair);
            break;
    }
}

///
/// \brief Gets the found best move.
///
/// \return The best move found.
///
inline AIPlayer::Move
AIPlayer::getBestMove (void) const
{
    return m_BestMove;
}

///
/// \brief Gets the score of the best move.
///
/// \return The score of the best move.
///
inline int32_t
AIPlayer::getBestScore (void) const
{
    return m_BestScore;
}

///
/// \brief Tells if the player has the final move computed.
///
/// \return \a true if the player has the move computed, \a false otherwise.
///
inline bool
AIPlayer::hasFinalMove (void) const
{
    return m_HaveFinalMove;
}

///
/// \brief Tells if the pair is already at the final position.
///
/// \return \a true if the pair is at its final position, \a false otherwise.
///
inline bool
AIPlayer::hasPairAtFinalPosition (void) const
{
    return m_FallingPairAtPosition;
}

///
/// \brief Initializes an state to a left rotation.
///
/// \param state The state to initialize.
/// \param gridState The initial grid state to use to compute the score.
/// \param parentScore The score of the parent state.
///
void
AIPlayer::initializeState (State &state, const GridStatus &gridState,
                           int32_t parentScore) const
{
    state.move.rotation = RotationLeft;
    state.move.main.x = 0;
    state.move.satellite.x = -1;
    state.currentX = 0;
    state.endX = Grid::k_GridWidth - 1;

    state.gridState = gridState;
    GridStatus::PositionResult result;
    state.gridState.checkPositions (state.move.main, state.move.satellite,
                                    result);
    state.score = parentScore + computeScore (result);
}

///
/// \brief Tells if the player is still for a pair to fall into the grid.
///
/// \return \a true if the player is waiting, \a false otherwise.
///
inline bool
AIPlayer::isWaitingNextPair (void) const
{
    return m_WaitingNextPair;
}

void
AIPlayer::joyMotion (uint8_t joystick, uint8_t axis, int16_t value)
{
    // Computer players don't have joystick. Nothing to do.
}

void
AIPlayer::joyDown (uint8_t joystick, uint8_t button)
{
    // Computer players don't have joystick. Nothing to do.
}

void
AIPlayer::joyUp (uint8_t joystick, uint8_t button)
{
    // Computer players don't have joystick. Nothing to do.
}

#if !defined (IS_GP2X_HOST)|| defined (__SYMBIAN32__)
void
AIPlayer::keyDown (uint32_t key)
{
    // Computer players don't have keyboard. Nothing to do.
}

void
AIPlayer::keyUp (uint32_t key)
{
    // Computer players don't have keyboard. Nothing to do.
}
#endif // !IS_GP2X_HOST

void
AIPlayer::loadOptions (void)
{
    // Nothing to do.
}

///
/// \brief Moves Grid's falling pair to the left.
///
void
AIPlayer::moveLeft (void)
{
    if ( canMove () )
    {
        getGrid ()->moveLeft ();
        updateTimeOfNextMove ();
    }
}

///
/// \brief Moves the falling pair an step closer to its final position.
///
void
AIPlayer::movePairToPosition (void)
{
    Move currentPosition;
    currentPosition.main = getGrid ()->getFallingMainAmoeba ();
    currentPosition.satellite = getGrid ()->getFallingSatelliteAmoeba ();

    if ( shouldSatelliteBeVisible () && currentPosition.satellite.y >= Grid::k_FirstVisibleHeight ||
         !shouldSatelliteBeVisible () && currentPosition.main.y >= Grid::k_FirstVisibleHeight )
    {
        if ( RotationLeft == getBestMove ().rotation &&
             currentPosition.main.x <= currentPosition.satellite.x )
        {
            rotateCounterClockwise ();
        }
        else if ( RotationRight == getBestMove ().rotation &&
                  currentPosition.main.x >= currentPosition.satellite.x )
        {
            rotateClockwise ();
        }
        else if ( RotationTop == getBestMove ().rotation &&
                  currentPosition.main.y <= currentPosition.satellite.y ||
                  RotationBottom == getBestMove ().rotation &&
                  currentPosition.main.y >= currentPosition.satellite.y )
        {
            rotateCounterClockwise ();
        }
        else
        {
            if ( getBestMove ().main.x == currentPosition.main.x &&
                 getBestMove ().satellite.x == currentPosition.satellite.x )
            {
                pairIsAtPosition ();
            }
            else if ( getBestMove ().main.x < currentPosition.main.x )
            {
                moveLeft ();
            }
            else
            {
                moveRight ();
            }
        }
    }
}

///
/// \brief Moves Grid's falling pair to the right.
///
void
AIPlayer::moveRight (void)
{
    if ( canMove () )
    {
        getGrid ()->moveRight ();
        updateTimeOfNextMove ();
    }
}

///
/// \brief Tells the player that the pair is already at its position.
///
inline void
AIPlayer::pairIsAtPosition (void)
{
    m_FallingPairAtPosition = true;
}

///
/// \brief Rotates Grid's falling pair clockwise.
///
void
AIPlayer::rotateClockwise (void)
{
    if ( canMove () )
    {
        getGrid ()->rotateClockwise ();
        updateTimeOfNextMove ();
    }
}

///
/// \brief Rotates Grid's falling pair counter clockwise.
///
void
AIPlayer::rotateCounterClockwise (void)
{
    if ( canMove () )
    {
        getGrid ()->rotateCounterClockwise ();
        updateTimeOfNextMove ();
    }
}

///
/// \brief Sets the best move and its score.
///
/// \param bestMove The best move to set.
/// \param bestScore The score of \p bestMove.
///
inline void
AIPlayer::setBestMove (const Move &bestMove, int32_t bestScore)
{
    m_BestMove = bestMove;
    m_BestScore = bestScore;
}

///
/// \brief Tells to the player that it has the final move.
///
inline void
AIPlayer::setHasFinalMove (void)
{
    m_HaveFinalMove = true;
}

///
/// \brief Sets the pair to check its moves.
///
/// \param pairToCheck The pair to check its moves.
///
inline void
AIPlayer::setPairToCheck (Checking pairToCheck)
{
    m_PairToCheck = pairToCheck;
}

///
/// \brief Sets the player into waiting the next falling pair mode.
///
inline void
AIPlayer::setToWaitingNextPair (void)
{
    m_WaitingNextPair = true;
}

void
AIPlayer::update (uint32_t elapsedTime)
{
    IPlayer::update (elapsedTime);
    if ( isWaitingNextPair () )
    {
        checkIfPairIsAvailable ();
    }
    else if ( !hasFinalMove () )
    {
        computeNextMove ();
    }
    else if ( !hasPairAtFinalPosition () && canMove () )
    {
        movePairToPosition ();
    }
    else if ( hasPairAtFinalPosition () && canMove () )
    {
        if ( shouldThePairFall () )
        {
            getGrid ()->setMaxFallingSpeed ();
        }
        setToWaitingNextPair ();
    }
}

///
/// \brief Updates the time of the next move.
///
void
AIPlayer::updateTimeOfNextMove (void)
{
    m_TimeOfNextMove = FrameManager::getCurrentTime () +
                       m_TimeToWaitForNextMove -
                       ((rand () % (m_TimeDeviation << 1)) -
                       m_TimeDeviation);
}

///
/// \brief Tells if the state is at the last position.
///
/// \return \a true if the state is at the last position, \a false otherwise.
///
bool
AIPlayer::State::isAtLastPosition (void) const
{
    return RotationBottom == move.rotation && currentX >= endX;
}