arena.cpp

/********************************************************************************
 *  FARSA Experiments Library                                                   *
 *  Copyright (C) 2007-2012                                                     *
 *  Stefano Nolfi <stefano.nolfi@istc.cnr.it>                                   *
 *  Onofrio Gigliotta <onofrio.gigliotta@istc.cnr.it>                           *
 *  Gianluca Massera <emmegian@yahoo.it>                                        *
 *  Tomassino Ferrauto <tomassino.ferrauto@istc.cnr.it>                         *
 *                                                                              *
 *  This program 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 2 of the License, or           *
 *  (at your option) any later version.                                         *
 *                                                                              *
 *  This program 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 this program; if not, write to the Free Software                 *
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA  *
 ********************************************************************************/

#include "arena.h"
#include "configurationhelper.h"
#include "phybox.h"
#include "logger.h"

namespace farsa {

// This anonymous namespace contains some constants used throughout the code
#ifdef __GNUC__
    #warning QUESTE COSTANTI DEVONO PROBABILMENTE DIVENTARE DEI PARAMETRI
#endif
namespace {
    const real defaultHeight = 0.3f;

    const real planeThickness = 0.1;

    const real smallCylinderRadius = 0.03;

    const real bigCylinderRadius = 0.06;

    const real targetAreasHeight = 0.001;

    const real targetAreasProtrusion = 0.0005;
}

Arena::Arena(ConfigurationParameters& params, QString prefix) :
    ParameterSettableInConstructor(params, prefix),
    ConcurrentResourcesUser(),
    m_z(ConfigurationHelper::getDouble(params, prefix + "z", 0.0)),
    m_plane(createPlane(params, prefix, m_z)),
    m_objects2DList(QVector<PhyObject2DWrapper*>() << m_plane),
    m_world(NULL)
{
    // The list of resources we observe here
    usableResources(QStringList() << "world");
}

Arena::~Arena()
{
    // Removing all wrappers
    for (int i = 0; i < m_objects2DList.size(); i++) {
        delete m_objects2DList[i];
    }
}

void Arena::save(ConfigurationParameters&, QString)
{
    Logger::error("NOT IMPLEMENTED (Arena::save)");
    abort();
}

void Arena::describe(QString type)
{
    // The parent class is ParameterSettableInConstructor, no need to call
    // its describe function (which does nothing)

    Descriptor d = addTypeDescription(type, "The class modelling an arena in which robots can live");
    d.describeReal("z").def(0.0).help("The z coordinate of the plane in the world frame of reference", "This is the z coordinate of the upper part of the plane in the world frame of reference");
    d.describeReal("planeWidth").def(2.5).limits(0.01, +Infinity).help("The width of the arena");
    d.describeReal("planeHeight").def(0.0).limits(0.01, +Infinity).help("The height of the arena");
}

void Arena::addRobots(QStringList robots)
{
#ifdef __GNUC__
    #warning IMPLEMENTARE QUESTA!!!
#endif
    // Qui ricordarsi di aggiungere i robots alle risorse che si osservano
}

Box2DWrapper* Arena::getPlane()
{
    return m_plane;
}

Box2DWrapper* Arena::createWall(QColor color, wVector start, wVector end, real thickness, real height)
{
    ResourcesLocker locker(this);

    // Changing parameters
    start.z = m_z;
    end.z = m_z;

    // Creating the box, then we have to change its position and make it static
    Box2DWrapper* b = createBox(color, (end - start).norm(), thickness, height, Box2DWrapper::Wall);

    // Moving the wall and setting the texture. We have to compute the rotation around the Z axis of the
    // wall and the position of its center to build its transformation matrix
    const real angle = atan2(end.y - start.y, end.x - start.x);
    const wVector centerPosition = start + (end - start).scale(0.5);
    wMatrix mtr = wMatrix::roll(angle);
    mtr.w_pos = centerPosition + wVector(0.0, 0.0, b->phyObject()->matrix().w_pos.z);
    b->phyObject()->setMatrix(mtr);
    b->setTexture("tile2");

    return b;
}

Cylinder2DWrapper* Arena::createSmallCylinder(QColor color, real height)
{
    return createCylinder(color, smallCylinderRadius, height, Cylinder2DWrapper::SmallCylinder);
}

Cylinder2DWrapper* Arena::createBigCylinder(QColor color, real height)
{
    return createCylinder(color, bigCylinderRadius, height, Cylinder2DWrapper::BigCylinder);
}

Cylinder2DWrapper* Arena::createCircularTargetArea(real radius, QColor color)
{
    ResourcesLocker locker(this);

    // Creating the cylinder, then we only have to change its z position and set the material to nonCollidable
    Cylinder2DWrapper* c = createCylinder(color, radius, targetAreasHeight, Cylinder2DWrapper::CircularTargetArea);

    wMatrix mtr = c->phyObject()->matrix();
    mtr.w_pos = wVector(0.0, 0.0, m_z - (targetAreasHeight / 2.0) + targetAreasProtrusion);
    c->phyObject()->setMatrix(mtr);
    c->phyObject()->setMaterial("nonCollidable");

    return c;
}

Box2DWrapper* Arena::createRectangularTargetArea(real width, real depth, QColor color)
{
    ResourcesLocker locker(this);

    // Creating the box, then we only have to change its z position and set the material to nonCollidable
    Box2DWrapper* b = createBox(color, width, depth, targetAreasHeight, Box2DWrapper::RectangularTargetArea);

    wMatrix mtr = b->phyObject()->matrix();
    mtr.w_pos = wVector(0.0, 0.0, m_z - (targetAreasHeight / 2.0) + targetAreasProtrusion);
    b->phyObject()->setMatrix(mtr);
    b->phyObject()->setMaterial("nonCollidable");

    return b;
}

Cylinder2DWrapper* Arena::createCylinder(QColor color, real radius, real height, Cylinder2DWrapper::Type type)
{
    ResourcesLocker locker(this);

    // Changing parameters
    if (height < 0.0) {
        height = defaultHeight;
    }

    PhyCylinder* cylinder = new PhyCylinder(radius, height, m_world, "cylinder");
    wMatrix mtr = wMatrix::yaw(PI_GRECO / 2.0);
    mtr.w_pos = wVector(0.0, 0.0, m_z + (height / 2.0));
    cylinder->setMatrix(mtr);
    cylinder->setUseColorTextureOfOwner(false);
    cylinder->setColor(color);
    cylinder->setTexture("");

    // Creating the wrapper
    Cylinder2DWrapper* wrapper = new Cylinder2DWrapper(cylinder, type);

    // Appending the wrapper to the list
    m_objects2DList.append(wrapper);

    return wrapper;
}

Box2DWrapper* Arena::createBox(QColor color, real width, real depth, real height, Box2DWrapper::Type type)
{
    ResourcesLocker locker(this);

    // Changing parameters
    if (height < 0.0) {
        height = defaultHeight;
    }

    PhyBox* box = new PhyBox(width, depth, height, m_world, "box");

    // Moving the box so that it lies on the plane
    wMatrix mtr = wMatrix::identity();
    mtr.w_pos = wVector(0.0, 0.0, m_z + (height / 2.0));
    box->setMatrix(mtr);
    box->setUseColorTextureOfOwner(false);
    box->setColor(color);
    box->setTexture("");

    // Creating the wrapper
    Box2DWrapper* wrapper = new Box2DWrapper(box, type);

    // Appending the wrapper to the list
    m_objects2DList.append(wrapper);

    return wrapper;
}

void Arena::resourceChanged(QString resourceName, ResourceChangeType changeType)
{
    if (resourceName == "world") {
        switch (changeType) {
            case Created:
            case Modified:
                m_world = getResource<World>();
                break;
            case Deleted:
                m_world = NULL;
                break;
        }
    } else {
        Logger::info("Unknown resource " + resourceName + " for Arena");
    }
}

Box2DWrapper* Arena::createPlane(ConfigurationParameters& params, QString prefix, real z)
{
    // First of all getting the dimensions of the plane
    const real planeWidth = ConfigurationHelper::getDouble(params, prefix + "planeWidth", 2.5);
    const real planeHeight = ConfigurationHelper::getDouble(params, prefix + "planeHeight", 2.5);

    // Also getting the world from the ResourcesUser associated with param
    SimpleResourcesUser* r = params.getResourcesUserForResource("world");
    if (r == NULL) {
        ConfigurationHelper::throwUserMissingResourceError("world", "We need a world to create the arena!");
    }
    World* world = r->getResource<World>("world");

    PhyBox* plane = new PhyBox(planeWidth, planeHeight, planeThickness, world, "plane");
    plane->setPosition(wVector(0.0, 0.0, z - (planeThickness / 2.0)));
    plane->setStatic(true);
    plane->setColor(Qt::white);
    plane->setTexture("tile2");

    // Also resizing world to comfortably fit the arena
    world->setSize(wVector(-planeWidth, -planeHeight, -planeThickness), wVector(planeWidth, planeHeight, +6.0));

    // Creating the wrapper and returning it
    return new Box2DWrapper(plane, Box2DWrapper::Plane);
}

} // end namespace farsa