/*!

 */
void
FieldPainter::draw( QPainter & painter )
{
    if ( Options::instance().minimumMode() )
    {
        painter.fillRect( painter.window(),
                          Qt::black );
        return;
    }

    if ( Options::instance().antiAliasing() )
    {
        painter.setRenderHint( QPainter::Antialiasing, false );
    }

    drawBackGround( painter );
    drawLines( painter );
    drawPenaltyAreaLines( painter );
    drawGoalAreaLines( painter );
    drawGoals( painter );
    if ( Options::instance().showFlag() )
    {
        drawFlags( painter );
    }
    if ( Options::instance().gridStep() > 0.0 )
    {
        drawGrid( painter );
    }

    if ( Options::instance().antiAliasing() )
    {
        painter.setRenderHint( QPainter::Antialiasing );
    }
}
Example #2
0
void TileMap::draw(BITMAP* dest, int scrollX, int scrollY, unsigned int layer)
{
    if (!mShowForegroundLayer && layer == FOREGROUND_LAYER)
    {
        return;
    }

    if (!mShowBackgroundLayer && layer == BACKGROUND_LAYER)
    {
        return;
    }

    if (!mShowEntities && layer == ENTITY_LAYER)
    {
        return;
    }

    int tileMapX = scrollX / 16;

    if (tileMapX < 0)
    {
        tileMapX = 0;
    }

    int tileMapY = scrollY / 16;

    // We ignore the first line as it's not a part of the tilemap.
    if (tileMapY < 0)
    {
        tileMapY = 0;
    }

    int tileMapEndX = scrollX / 16 + dest->w / 16 + 1;

    if (tileMapEndX > getWidth())
    {
        tileMapEndX = getWidth();
    }

    int tileMapEndY = scrollY / 16 + dest->h / 16 + 1;

    if (tileMapEndY > getHeight())
    {
        tileMapEndY = getHeight();
    }

    int y;
    for (y = tileMapY; y < tileMapEndY; y++)
    {
        int x;
        for (x = tileMapX; x< tileMapEndX; x++)
        {
            if (layer == ENTITY_LAYER)
            {
                int g = getTileEntity(x, y);

                if (g != 0)
                {
                    drawEntity(dest,
                               x * 16 - scrollX,
                               y * 16 - scrollY,
                               g);
                }
            }
            else
            {
                int r = getTile(x, y);

                int b = getTileFlags(x, y);

                bool drawInLayer = (layer == FOREGROUND_LAYER && !(b & BACKGROUND)
                                    || (layer == BACKGROUND_LAYER && (b & BACKGROUND)));

                if (r != 0 && drawInLayer)
                {
                    drawTile(dest,
                             x * 16 - scrollX,
                             y * 16 - scrollY,
                             r);
                }

                if (mShowSolidity)
                {
                    drawFlags(dest,
                              x * 16 - scrollX,
                              y * 16 - scrollY,
                              b);
                }
            }
        }
    }
}