Бегущий в матрице

// Класс ЖУК =============================================
class CBug
{
    QPoint position;
    int orientation;
 
public:
    CBug()
    {
        position.setX(0);
        position.setY(0);
        orientation = RIGHT;
    }
 
    ~CBug();   
 
    void setPos(int x, int y)
    {
        position.setX(x);
        position.setY(y);
    }
 
    void setPos(QPoint point)
    {
        position = point;
    }
 
    QPoint pos()
    {
        return position;
    }
 
    void setOrientation(int orient)
    {
        if(orient > 3) orientation = RIGHT;
        else orientation = orient;
    }
 
    QPoint turnLeft()
    {
        switch(orientation)
        {
          case LEFT:
            {
                position.setY(position.y() + 1);
                orientation = BOTTOM;
                break;
            }
          case RIGHT:
            {
                position.setY(position.y() - 1);
                orientation = TOP;
                break;
            }
          case TOP:
            {
                position.setX(position.x() - 1);
                orientation = LEFT;
                break;
            }
          case BOTTOM:
            {
                position.setX(position.x() + 1);
                orientation = RIGHT;
                break;
            }
        }
 
        return position;
    }
 
    QPoint turnRight()
    {
        switch(orientation)
        {
          case RIGHT:
            {
                position.setY(position.y() + 1);
                orientation = BOTTOM;
                break;
            }
          case LEFT:
            {
                position.setY(position.y() - 1);
                orientation = TOP;
                break;
            }
          case BOTTOM:
            {
                position.setX(position.x() - 1);
                orientation = LEFT;
                break;
            }
          case TOP:
            {
                position.setX(position.x() + 1);
                orientation = RIGHT;
                break;
            }
        }
 
        return position;
    }
};
 
// Конец класса ЖУК =============================================

// Запуск жука
void runBug(QList<QBitArray*> *layer)
{
    if(!layer) return;
 
    CBug *bug = new CBug();
 
    int y = 0;
    int x = 0;
    QPoint startPoint;
 
 
    bool move = true;
    bool startPointFound = false;
 
    QVector<QPointF> points;
    QVector<QPointF> result;
 
// Поиск начальной точки
    while(move)
    {
        if(y >= layer->count()) move = false;
        else
        {
            if(layer->at(y)->testBit(x))
            {
                startPoint.setX(x);
                startPoint.setY(y);
                startPointFound = true;
                move = false;
                points.append(startPoint);
            }
            x++;
            if(x >= layer->at(y)->count())
            {
                x = 0;
                y++;
            }
        }
    }
 
 
    if(!startPointFound) return;
 
    x = startPoint.x();
    y = startPoint.y();
 
    move = true;
 
    bug->setPos(x, y);
    bug->turnRight();
 
    while(move)
    {
        x = bug->pos().x();
        y = bug->pos().y();
 
        if(y >= 0 && y < layer->count())
        {
            if(x >= 0 && x < layer->at(y)->count())
            {
                if(layer->at(y)->testBit(x))
                {
                    points.append(bug->pos());
                    bug->turnRight();
                }
                else
                {
                    bug->turnLeft();
                }
            }
            else move = false;
        }
        else move = false;
 
        if(bug->pos() == startPoint) move = false;
    }
 
    result = LineOptimized(points, 1 );
 
   delete bug;
}