khanat-opennel-code/code/ryzom/tools/reynolds/reynolds_manager.h

352 lines
8.6 KiB
C
Raw Normal View History

2013-07-24 18:58:43 +00:00
// Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2010 Winch Gate Property Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 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 Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#ifndef NL_REYNOLDS_MANAGER_H
#define NL_REYNOLDS_MANAGER_H
// NeL
#include "nel/misc/types_nl.h"
#include "nel/misc/smart_ptr.h"
#include "nel/georges/u_form.h"
#include "nel/georges/u_form_elm.h"
// Game share
#include "game_share/continent_container.h"
// ReynoldsLib
#include "track.h"
// Stl
#include <map>
/**
* Track manager
* \author Benjamin Legros
* \author Nevrax France
* \date 2002
*/
class CReynoldsManager
{
friend CTrack::~CTrack();
public:
/**
* User Motion controlled Callback type
* \param track is the base track
*/
typedef void (*TUserCallback) (CTrackBase *track);
/**
* User Motion Callback type
* Called each time a controlled track is updated
* \param track is the base track
* \param motion is the current motion to be applied -- WARNING do not crash this value, only add or substract value to it
*/
typedef void (*TUserMotionCallback) (CTrackBase *track, NLMISC::CVectorD &motion);
/// The command interface
class ICommandInterface
{
public:
/**
* Called when manager needs a sheet for an entity.
* Reply using setSheet(CEntityId)
*/
virtual void requestSheet(const NLMISC::CEntityId &id) = 0;
/**
* Called when manager needs a position for an entity.
* Reply using setPosition(CEntityId)
*/
virtual void requestPosition(const NLMISC::CEntityId &id) = 0;
/**
* Called when manager needs a position to be updated evently
* Reply using setPosition(CEntityId) evently
*/
virtual void requestPositionUpdates(const NLMISC::CEntityId &id) = 0;
/**
* Called when manager doesn't need more position updates
*/
virtual void unrequestPositionUpdates(const NLMISC::CEntityId &id) = 0;
/**
* Called when manager needs an entity vision to be updated evently
* Reply using setVision() evently
*/
virtual void requestVision(const NLMISC::CEntityId &id) = 0;
/**
* Called when manager doesn't need more entity vision updates
*/
virtual void unrequestVision(const NLMISC::CEntityId &id) = 0;
/**
* Called when a track position is updated
*/
virtual void updatePosition(const NLMISC::CEntityId &id, const NLMISC::CVectorD &position, float &heading) = 0;
/**
* Called when track state changed
*/
virtual void stateChanged(const NLMISC::CEntityId &id, CTrackBase::TTrackState state) = 0;
/**
* Called when manager leave control of an entity
*/
virtual void stopTrack(const NLMISC::CEntityId &id) = 0;
};
public:
/// @name Reynolds Manager inits/update/release
//@{
/// Init
static void init(const std::string &packSheetFile = "reynolds.packed_sheets");
/// Load continent
static void loadContinent(const std::string &name, const std::string &file, sint index);
/// Set Sheet request callback
static void setCommandInterface(ICommandInterface *commandInterface) { _CommandInterface = commandInterface; }
/// Set User init callback
static void setUserInitCallback(TUserCallback cb) { _UserInitCallback = cb; }
/// Set User motion callback
static void setUserMotionCallback(TUserMotionCallback cb) { _UserMotionCallback = cb; }
/// Set User release callback
static void setUserReleaseCallback(TUserCallback cb) { _UserReleaseCallback = cb; }
/// Update
static void update(double dt = 0.1);
/// Release
static void release();
//@}
/// @name Control methods over tracks
//@{
/// Follow
static void follow(const NLMISC::CEntityId &entity, const NLMISC::CEntityId &target);
/// Go to
static void goTo(const NLMISC::CEntityId &entity, const NLMISC::CVectorD &position);
/// Stop
static void leaveMove(const NLMISC::CEntityId &entity);
/// Destroy a track
static void destroy(const NLMISC::CEntityId &entity);
//@}
/// @name Tracks requests and state towards interface
//@{
/// Request Sheet
static void requestSheet(const NLMISC::CEntityId &entity);
/// Request Position
static void requestPosition(const NLMISC::CEntityId &entity);
/// Request Position Updates
static void requestPositionUpdates(const NLMISC::CEntityId &entity);
/// Unrequest Position Updates
static void unrequestPositionUpdates(const NLMISC::CEntityId &entity);
/// Request Vision
static void requestVision(const NLMISC::CEntityId &entity);
/// Unrequest Vision
static void unrequestVision(const NLMISC::CEntityId &entity);
/// Track stopped following
static void trackStop(CTrack *track);
/// Updated position
static void updatedPosition(const NLMISC::CEntityId &entity, const NLMISC::CVectorD &position, float heading);
/// Updated state
static void stateChanged(const NLMISC::CEntityId &entity, CTrackBase::TTrackState state);
/// User init
static void initUserMotion(CTrack *track)
{
if (_UserInitCallback != NULL)
_UserInitCallback((CTrackBase*)track);
}
/// User move
static void applyUserMotion(CTrack *track, NLMISC::CVectorD &motion)
{
if (_UserMotionCallback != NULL)
_UserMotionCallback((CTrackBase*)track, motion);
}
/// User release
static void releaseUserMotion(CTrack *track)
{
if (_UserReleaseCallback != NULL)
_UserReleaseCallback((CTrackBase*)track);
}
/// Create Move primitive
static void createMovePrimitive(const NLMISC::CVectorD &pos, NLPACS::UMovePrimitive *&primitive, NLPACS::UMoveContainer *&container);
/// Lookup a sheet
static const CTrack::CSheet *lookup(const NLMISC::CSheetId &sheet);
//@}
/// @name Answers to tracks requests
//@{
/// Set Sheet
static void setSheet(const NLMISC::CEntityId &id, const NLMISC::CSheetId &sheet);
/// Set Position
static void setPosition(const NLMISC::CEntityId &id, const NLMISC::CVectorD &position, float heading);
/// Update Vision
static void setVision(const NLMISC::CEntityId &id, const std::vector<NLMISC::CEntityId> &in, const std::vector<NLMISC::CEntityId> &out);
/// Update Vision
static void setVision(const NLMISC::CEntityId &id, const std::vector<NLMISC::CEntityId> &vision);
/// Get a track
static CTrack *getTrack(const NLMISC::CEntityId &entity)
{
TTrackMap::iterator it = _TrackMap.find(entity);
return (it == _TrackMap.end()) ? NULL : (*it).second;
}
/// Get cycle
static uint32 getCycle() { return _Cycle; }
//@}
/// Create a non controlled track, referenced in _TrackMap
static CTrack *createTrack(const NLMISC::CEntityId &entity);
protected:
/// Constructor. Not to be used.
CReynoldsManager();
/// Remove a track from the whole map -- only called by the CTrack destructor
static void removeTrackFromMap(const NLMISC::CEntityId &entity);
/// Checks interface is ok
static bool checkInterface()
{
if (_CommandInterface == NULL)
{
nlwarning("CReynoldsLib:checkInterface(): CommandInterface not set");
return false;
}
return true;
}
/// Init sheets
static void initSheets(const std::string &packSheetFilnamePrefix);
protected:
/// Whole track container
typedef std::map<NLMISC::CEntityId, CTrack* > TTrackMap;
/// Only controlled track container
typedef std::map<NLMISC::CEntityId, NLMISC::CSmartPtr<CTrack> > TControlledTrackMap;
protected:
/// Continents
static CContinentContainer _Continents;
/// Track Map, all tracks referenced, held by a simple pointer so when no one references a track, it is deleted
static TTrackMap _TrackMap;
/// Controlled Track Map, only controlled tracks, held by a smart pointer
static TControlledTrackMap _ControlledTrackMap;
/// Georges sheets
static std::map<NLMISC::CSheetId, CTrack::CSheet> _Sheets;
/// Sheets initialised ?
static bool _Initialised;
/// Command interface
static ICommandInterface *_CommandInterface;
/// User init callback
static TUserCallback _UserInitCallback;
/// User motion callback
static TUserMotionCallback _UserMotionCallback;
/// User release callback
static TUserCallback _UserReleaseCallback;
/// Current internal cycle
static uint32 _Cycle;
};
#endif // NL_REYNOLDS_MANAGER_H
/* End of reynolds_manager.h */