arena.cc

Go to the documentation of this file.

/*
 * Copyright (C) 2008 Kamil Dudka <xdudka00@stud.fit.vutbr.cz>
 *
 * This file is part of rob08
 *
 * rob08 is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * any later version.
 *
 * rob08 is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with rob08.  If not, see <http://www.gnu.org/licenses/>.
 */

#include "config.h"
#include "arena.h"

#include "core.h"
#include "coresync.h"
#include "physics.h"
#include "robIO.h"
#include "trilobot.h"

#ifndef BUILDING_DOX
#   include <assert.h>
#   include <QPainter>
#   include <QTimer>
#endif

using std::string;
using namespace StreamDecorator;

static const int        dtRepaint = 50;     // 50 ms repaint period

static const qreal      botPathGranulatiry = 0.1;

static const qreal      botPenWidth = 2.0;
static const qreal      objPenWidth = 1.0;
static const qreal      envPenWidth = 3.0;

// /////////////////////////////////////////////////////////////////////////////
// Arena implementation
struct Arena::Private {
    Arena       *arena;
    CoreSync    *cs;
    QTimer      timer;
    unsigned    ticks;
    QSizeF      envSize;
    qreal       botSize;
    qreal       zoomRatio;
    Position    botPosition;
    QPointF     botLastPosition;
    BotPath     botPath;
    CoreInfo    coreInfo;
    bool        drawSurface;

    void        render(QPainter &, LockedCore &);
    void        renderBot(QPainter &, LockedCore &);
    QPointF     cToA(Point);
    QPointF     botPosF();
    QPoint      botPosPx();
    void        drawCircle(QPainter &, const IObject &);
};
Arena::Arena(CoreSync *cs, QWidget *parent):
    QWidget(parent),
    d(new Private)
{
    QWidget::setBackgroundRole(QPalette::Light);

    // initialize members
    d->arena        = this;
    d->cs           = cs;
    d->ticks        = 0;
    d->drawSurface  = false;

    // lock core (till end of block)
    LockedCore core(cs);

    // set correct widget size
    const Point &rightTop = core->GetEnviroment().RightTop();
    d->envSize.setWidth(rightTop.x);
    d->envSize.setHeight(rightTop.y);
    assert(d->envSize.isValid());
    this->zoom(1.0);

    // read bot position and size
    d->botPosition = core->GetTrilobot().Position();
    d->botLastPosition = d->botPosF();
    d->botPath.addPos(d->botLastPosition);
    d->botSize = core->GetTrilobot().Size();
    assert(0.0 < d->botSize);
    readCoreInfo(core, d->coreInfo);

    // initialize timer
    QTimer &timer = d->timer;
    connect(&timer, SIGNAL(timeout()), this, SLOT(animate()));
    timer.start(dtRepaint);
}
Arena::~Arena() {
    d->timer.stop();
    delete d;
}
QSize Arena::envSize() const {
    QSize size(
            static_cast<int>(d->envSize.width()),
            static_cast<int>(d->envSize.height()));
    assert(size.isValid());
    return size;
}
int Arena::botSize() const {
    return static_cast<int>(d->botSize * d->zoomRatio);
}
const CoreInfo& Arena::coreInfo() const {
    return d->coreInfo;
}
void Arena::animate() {
    d->ticks ++;
    this->repaint();
}
void Arena::zoom(qreal ratio) {
    assert(0.0 < ratio);
    d->zoomRatio = ratio;

    // compute real size
    QSizeF size(d->envSize);
    size += QSizeF(envPenWidth*2.0, envPenWidth*2.0);
    size *= ratio;

    // compute environment size in pixels
    QSize pxSize(
            static_cast<int>(size.width()),
            static_cast<int>(size.height())
            );
    assert(pxSize.isValid());
    this->setFixedSize(pxSize);

    // scrool to view
    emit preferredPosChanged(d->botPosPx());
}
void Arena::setShrinkPathEnabled(bool enabled) {
    d->botPath.setShrinkEnabled(enabled);
    //this->repaint();
}
void Arena::setDrawSurfaceEnabled(bool enabled) {
    d->drawSurface = enabled;
    //this->repaint();
}
void Arena::paintEvent(QPaintEvent *) {
    // lock core (till end of block)
    LockedCore core(d->cs);
    d->botPosition = core->GetTrilobot().Position();
    readCoreInfo(core, d->coreInfo);

    // initialize Qt painting system
    QPainter painter;
    painter.begin(this);
    if (d->zoomRatio < 3.0)
        painter.setRenderHints(QPainter::Antialiasing|QPainter::SmoothPixmapTransform);
    else
        painter.setRenderHint(QPainter::Antialiasing);

    // apply zoom ratio
    QMatrix matrix;
    matrix.translate(0, this->size().height());
    matrix.scale(d->zoomRatio, -d->zoomRatio);
    painter.setMatrix(matrix);

    // render
    d->render(painter, core);

    // deinitialize Qt painting system
    painter.end();

    if (d->botLastPosition != d->botPosF()) {
        d->botLastPosition = d->botPosF();

        // break repaint recursion using event loop
        QTimer::singleShot(0, this, SLOT(botPosChanged()));
    }
}
void Arena::botPosChanged() {
    d->botPath.addPos(d->botLastPosition);
    emit coreInfoChanged();
    emit preferredPosChanged(d->botPosPx());
}
void Arena::Private::render(QPainter &painter, LockedCore &core) {
    // draw environment margin
    const qreal envOffset = envPenWidth/2.0;
    QRectF envRect(envOffset, envOffset,
            envSize.width() + envPenWidth,
            envSize.height() + envPenWidth);
    QPen envPen(QBrush(Qt::black), envPenWidth, Qt::SolidLine, Qt::SquareCap, Qt::MiterJoin);
    painter.setPen(envPen);
    painter.drawRect(envRect);

    // move inner objects relative to margin
    QMatrix matrix;
    matrix.translate(envPenWidth, envPenWidth);
    painter.setMatrix(matrix, true);

    // draw objects
    const IObjectContainer &objs = core->GetEnviroment().Objects();
    for(unsigned i=0; i<objs.size(); i++)
        drawCircle(painter, *(objs[i]));

    // draw bot path
    botPath.drawPath(painter);

    // initialize bot matrix
    QMatrix botMatrix;
    QPointF botPos(cToA(botPosition));
    botMatrix.translate(botPos.x(), botPos.y());
    botMatrix.rotate(- botPosition.angle);

    // draw Trilobot
    QMatrix mSaved(painter.matrix());
    painter.setMatrix(botMatrix, true);
    renderBot(painter, core);
    painter.setMatrix(mSaved);
}
void Arena::Private::renderBot(QPainter &painter, LockedCore &core) {
    Trilobot &bot = core->GetTrilobot();
    const qreal size = bot.Size() - botPenWidth/2.0;

    // set gradient
    const QColor fgColor("#444");
    const QColor bgColor("#CCC");
    QRadialGradient gradient(QPointF(), bot.Size());
    gradient.setColorAt(0, bgColor);
    gradient.setColorAt(1, fgColor);

    // blink
    QBrush brush(gradient);
    if (!(ticks%16))
        brush = QBrush(Qt::green);
    QPen botPen(brush, botPenWidth, Qt::SolidLine, Qt::RoundCap);

    // draw bot
    painter.setPen(botPen);
    painter.setBrush(QBrush());
    painter.drawEllipse(QPointF(), size, size);
    painter.drawLine(QPointF(0, 0), QPointF(0, size));
}
QPointF Arena::Private::cToA(Point p) {
    return QPointF(p.x, p.y);
}
void Arena::Private::drawCircle(QPainter &painter, const IObject &cObj) {
    // don't tell kubson anything and everything will be good
    IObject &obj = const_cast<IObject &>(cObj);
    const qreal size = obj.Size() - objPenWidth/2.0;
    const QPointF center = cToA(obj.Position());

    // initialize matrix
    QMatrix matrix;
    matrix.translate(center.x(), center.y());
    matrix.scale(size, size);

    // set pen/brush
    const QColor color("#C00");
    QBrush brush;
    if (drawSurface) {
        brush = QBrush(color, Qt::HorPattern);
        QMatrix brushMatrix(matrix.inverted());
        brushMatrix.scale(0.5, 0.5);
        brush.setMatrix(brushMatrix);
    }
    painter.setPen(QPen(color, objPenWidth/size));

    // draw circle
    QMatrix mSaved(painter.matrix());
    matrix.rotate(-45);
    painter.setMatrix(matrix, true);
    painter.setBrush(QBrush(Qt::white));
    painter.drawEllipse(QPointF(), 1.0, 1.0);
    if (drawSurface) {
        painter.setBrush(brush);
        painter.drawEllipse(QPointF(), 1.0, 1.0);
    }
    painter.setMatrix(mSaved);
}
QPointF Arena::Private::botPosF() {
    return cToA(botPosition);
}
QPoint Arena::Private::botPosPx() {
    QMatrix matrix;
    matrix.translate(0, arena->size().height());
    matrix.scale(zoomRatio, -zoomRatio);
    matrix.translate(envPenWidth, envPenWidth);

    QPointF pos(matrix.map(botLastPosition));
    return QPoint(
        static_cast<int>(pos.x()),
        static_cast<int>(pos.y()));
}

// /////////////////////////////////////////////////////////////////////////////
// BotPath implementation
struct BotPath::Private {
    bool            first;
    bool            shrinkEnabled;
    QPointF         last;
    QPainterPath    path;
    QPainterPath    fullPath;

    bool            farFromLast(QPointF);
    void            shrink();
};
BotPath::BotPath():
    d(new Private)
{
    d->first = true;
    d->shrinkEnabled = true;
}
BotPath::~BotPath() {
    delete d;
}
void BotPath::addPos(QPointF pos) {
    if (d->first) {
        d->first = false;
        d->last = pos;
        d->path.moveTo(pos);
        d->fullPath.moveTo(pos);
        return;
    }
    if (d->farFromLast(pos)) {
        d->last = pos;
        d->path.lineTo(pos);
        d->fullPath.lineTo(pos);
        if (256 <= d->path.elementCount())
            d->shrink();
    }
}
void BotPath::drawPath(QPainter &painter) {
    QPen pen(Qt::black, 0.5, Qt::DotLine);
    painter.setPen(pen);
    painter.setBrush(QBrush());
    painter.drawPath(d->shrinkEnabled
            ? d->path
            : d->fullPath
            );
}
void BotPath::setShrinkEnabled(bool enabled) {
    d->shrinkEnabled = enabled;
}
bool BotPath::Private::farFromLast(QPointF pos) {
    const qreal dx = last.x() - pos.x();
    const qreal dy = last.y() - pos.y();
    const qreal squareOfDist = dx*dx + dy*dy;
    return botPathGranulatiry < squareOfDist;
}
void BotPath::Private::shrink() {
#if DEBUG_SHRINK_PATH
    std::cerr << "BotPath: "
        << Color(C_YELLOW) << "shrinking path" 
        << Color(C_NO_COLOR) << ": " << path.elementCount() << " -> "
        << std::flush;
#endif
    QPainterPath shrinked;
    shrinked.moveTo(path.elementAt(4));

    const unsigned size = path.elementCount();
    for (unsigned i = 5; i < size; i++) {
        QPointF current(path.elementAt(i));
        if (!(i % 64))
            continue;
        shrinked.lineTo(current);
    }

    path = shrinked;
#if DEBUG_SHRINK_PATH
    std::cerr << path.elementCount() << std::endl;
#endif
}

---