~robot3d-team/robot3d/trunk

/*

 * arena component doing all the basic stuff

 *

 * @author Adrian Friebel

 */

 

#ifndef SIMULATIONARENACOMPONENT_H_

#define SIMULATIONARENACOMPONENT_H_

 

#include <srCore/export.h>

#include <srCore/robot/robotActorBase.h>

//#include "controller/controllers.h"

//#include "controller/controllerComponentBase.h"

#include <srCore/simulationRobotSelectionComponent.h>

#include <srCore/simulationUtils.h>

#include <srCore/xmlConfig.h>

 

#include <dtGame/gmcomponent.h>

 

#include <dtDAL/gameeventmanager.h>

 

/* TODO:        Implementing other components for offline/offboard learning, i.e. such as

 *                      - logging robot behaviours (see dtUtils::Log)

 *                      - Evaluating the (offboard) fitness

 *                      - ...

 *

 * These components can use this class for accessing all robots and controllers.

 *

 * To get access to this component use the following line:

 * SimulationArenaComponent *comp = static_cast<SimulationArenaComponent*>(GetGameManager()->GetComponentByName(SimulationArenaComponent::DEFAULT_NAME));

 *

 */

 

namespace srCore {

 

/**

 * class for handling the simulation

 */

class ROBOT_EXPORT SimulationArenaComponent : public dtGame::GMComponent

{

        public:

 

                static const std::string DEFAULT_NAME;

 

                SimulationArenaComponent(const std::string &name);

 

                //! loads a new scene during runtime  -  TODO: the map keeps the same

                void loadScene(std::string file);

 

                //! initlize the simulation

                void init();

 

                void ProcessMessage(const dtGame::Message &message);

 

                //! creates robot according to the description in the given scene file.

                void createRobotsFromSceneFile(const GetConfig &appConfig);

 

                //! Creates a new robot

                void createRobot(RobotInitData rid);

 

                //! Returns the number of robots that currently in the scene

                int getNumRobots() { return numRobots; };

 

                //! Returns the index of the currently selected robot

                int getRobFocIndex() {return robotFocusIndex; };

 

                //! Disconnects the robot from other robots, deletes and removes it from the scene

                void destroyRobot(srCore::RobotActorBase &robotActor);

 

                //! Returns the selected robot

                dtCore::RefPtr<srCore::RobotActorBase> getSelectedRobot();

 

                //! Selects another robot

                void selectRobot(dtCore::RefPtr<srCore::RobotActorBase> robotToSelect);

 

                //! Selects the next robot in the list

                void selectNextRobot();

 

                //! Resets the simulation

                void reset();

 

                //! Removes all robots and controllers from the scene

                void clear();

 

                //! toggles the screenshot saver

                void toggleScreenShots(bool toggle);

 

                //! Returns all Robots in the scene

                std::vector<dtCore::RefPtr<RobotActorBase> > getRobotsInScene();

 

                //! Returns a robot by its name

                dtCore::RefPtr<RobotActorBase> getRobot(const std::string &name);

 

        protected:

                virtual ~SimulationArenaComponent() { }

 

        private:

              void sendMessageToAll(dtDAL::GameEvent &event);

 

              float getZPos(float x, float y, dtCore::Scene &scene);

 

              //! Starts or resumes the simulation

              void start();

 

              //! Pauses the simulation. Can only be activated invoking a game message.

              void pause();

 

              //! Destroys selected robot

              void destroyRobot();

 

              bool isResettingTheScene;

 

              int robotFocus;

              int robotFocusIndex;

              bool paused;

              double timeScale;

              int numRobots, numRobotsAtBeginOfFrame;

              std::vector<int> freedInd;

              dtCore::RefPtr<dtDAL::GameEvent> mActorDestroyed;

              dtCore::RefPtr<dtDAL::GameEvent> mFocusChanged;

 

              std::vector<dtCore::RefPtr<RobotActorBase> > robotsInScene;

};

}

 

#endif /*SIMULATIONARENACOMPONENT_H_*/