Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/branches/hoverHS15/src/orxonox/worldentities/ControllableEntity.h @ 10633

Last change on this file since 10633 was 10624, checked in by landauf, 9 years ago

merged branch core7 back to trunk

  • Property svn:eol-style set to native
File size: 9.7 KB
Line 
1/*
2 *   ORXONOX - the hottest 3D action shooter ever to exist
3 *                    > www.orxonox.net <
4 *
5 *
6 *   License notice:
7 *
8 *   This program is free software; you can redistribute it and/or
9 *   modify it under the terms of the GNU General Public License
10 *   as published by the Free Software Foundation; either version 2
11 *   of the License, or (at your option) any later version.
12 *
13 *   This program is distributed in the hope that it will be useful,
14 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
15 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 *   GNU General Public License for more details.
17 *
18 *   You should have received a copy of the GNU General Public License
19 *   along with this program; if not, write to the Free Software
20 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
21 *
22 *   Author:
23 *      Fabian 'x3n' Landau
24 *   Co-authors:
25 *      Reto Grieder
26 *
27 */
28
29#ifndef _ControllableEntity_H__
30#define _ControllableEntity_H__
31
32#include "OrxonoxPrereqs.h"
33
34#include <list>
35#include <string>
36#include "util/Math.h"
37#include "MobileEntity.h"
38
39namespace orxonox
40{
41    /**
42    @brief
43        The ControllableEntity is derived from the @ref orxonox::MobileEntity. ControllableEntities can be controlled by @ref orxonox::Controller Controllers.
44        A Controller will call (based on user input, AI decision, ...) for example the function @see moveFrontBack or the function @see rotateYaw to
45        move the ControllableEntity through space. A Controller could also call the @see boost function to tell the ControllableEntity that he wants it to boost.
46    */
47
48    class _OrxonoxExport ControllableEntity : public MobileEntity
49    {
50        friend class PlayerInfo; // PlayerInfo uses setPlayer and removePlayer
51
52        public:
53            ControllableEntity(Context* context);
54            virtual ~ControllableEntity();
55
56            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
57            virtual void tick(float dt);
58            void setConfigValues();
59
60            virtual void changedPlayer() {}
61
62            inline PlayerInfo* getPlayer() const
63                { return this->player_; }
64            /**
65            @brief Get the player even after the ControllableEntity has stopped being the players ControllableEntity.
66            @return Returns the most recent PlayerInfo.
67            */
68            inline PlayerInfo* getFormerPlayer() const
69                { return this->formerPlayer_; }
70
71            inline void setDestroyWhenPlayerLeft(bool bDestroy)
72                { this->bDestroyWhenPlayerLeft_ = bDestroy; }
73            inline bool getDestroyWhenPlayerLeft() const
74                { return this->bDestroyWhenPlayerLeft_; }
75
76            virtual void moveFrontBack(const Vector2& value) {}
77            virtual void moveRightLeft(const Vector2& value) {}
78            virtual void moveUpDown(const Vector2& value) {}
79
80            virtual void rotateYaw(const Vector2& value);
81            virtual void rotatePitch(const Vector2& value);
82            virtual void rotateRoll(const Vector2& value);
83
84            inline void moveFrontBack(float value)
85                { this->moveFrontBack(Vector2(value, 0)); }
86            inline void moveRightLeft(float value)
87                { this->moveRightLeft(Vector2(value, 0)); }
88            inline void moveUpDown(float value)
89                { this->moveUpDown(Vector2(value, 0)); }
90
91            inline void rotateYaw(float value)
92                { this->rotateYaw(Vector2(value, 0)); }
93            inline void rotatePitch(float value)
94                { this->rotatePitch(Vector2(value, 0)); }
95            inline void rotateRoll(float value)
96                { this->rotateRoll(Vector2(value, 0)); }
97
98            void fire(unsigned int firemode);
99            virtual void fired(unsigned int firemode) {}
100            virtual void reload() {}
101
102            /**
103            @brief Tells the ControllableEntity to either start or stop boosting.
104                   This doesn't mean, that the ControllableEntity will do so, there might be additional restrictions on boosting, but if it can, then it will.
105            @param bBoost If true the ControllableEntity is told to start boosting, if false it is told to stop.
106            */
107            virtual void boost(bool bBoost) {}
108
109            virtual void greet() {}
110            virtual void switchCamera();
111            virtual void mouseLook();
112
113            inline const std::string& getHudTemplate() const
114                { return this->hudtemplate_; }
115
116            inline Camera* getCamera() const
117                { return this->camera_; }
118            inline OverlayGroup* getHUD() const
119                { return this->hud_; }
120
121            void addCameraPosition(CameraPosition* position);
122            CameraPosition* getCameraPosition(unsigned int index) const;
123            inline const std::list<StrongPtr<CameraPosition> >& getCameraPositions() const
124                { return this->cameraPositions_; }
125            unsigned int getCurrentCameraIndex() const;
126            bool setCameraPosition(unsigned int index);
127
128            inline void setCameraPositionTemplate(const std::string& name)
129                { this->cameraPositionTemplate_ = name; }
130            inline const std::string& getCameraPositionTemplate() const
131                { return this->cameraPositionTemplate_; }
132
133            inline void setReverseCamera(CameraPosition* camera)
134                { this->reverseCamera_ = camera; }
135            inline CameraPosition* getReverseCamera() const
136                { return this->reverseCamera_; }
137
138            using WorldEntity::setPosition;
139            using WorldEntity::setOrientation;
140            using MobileEntity::setVelocity;
141            using MobileEntity::setAngularVelocity;
142
143            void setPosition(const Vector3& position);
144            void setOrientation(const Quaternion& orientation);
145            void setVelocity(const Vector3& velocity);
146            void setAngularVelocity(const Vector3& velocity);
147
148            inline bool hasLocalController() const
149                { return this->bHasLocalController_; }
150            inline bool hasHumanController() const
151                { return this->bHasHumanController_; }
152
153            inline bool isInMouseLook() const
154                { return this->bMouseLook_; }
155            inline float getMouseLookSpeed() const
156                { return this->mouseLookSpeed_; }
157            inline CameraPosition* getCurrentCameraPosition()
158                { return this->currentCameraPosition_; }
159
160            inline Controller* getXMLController() const
161                { return this->xmlcontroller_; }
162
163            inline Controller* getController() const
164                { return this->controller_; }
165            void setController(Controller* val);
166
167
168            virtual void setTarget( WorldEntity* target );
169            virtual WorldEntity* getTarget()
170                { return this->target_; }
171            void setTargetInternal( uint32_t targetID );
172
173            inline void setTeam(int team)
174                { this->team_ = team; }
175            inline int getTeam() const
176                { return this->team_; }
177
178        protected:
179            virtual void preDestroy();
180
181            virtual void setPlayer(PlayerInfo* player); // don't call this directly, use friend class PlayerInfo instead
182            virtual void removePlayer();                // don't call this directly, use friend class PlayerInfo instead
183
184            virtual void startLocalHumanControl();
185            virtual void stopLocalHumanControl();
186            virtual void parentChanged();
187
188            inline void setHudTemplate(const std::string& name)
189                { this->hudtemplate_ = name; }
190            // HACK-ish
191            void createHud(void);
192            void destroyHud(void);
193
194            Ogre::SceneNode* cameraPositionRootNode_;
195
196        private:
197            void registerVariables();
198            void setXMLController(Controller* controller);
199
200            void overwrite();
201            void processOverwrite();
202
203            void processServerPosition();
204            void processServerLinearVelocity();
205            void processServerOrientation();
206            void processServerAngularVelocity();
207
208            void processClientPosition();
209            void processClientLinearVelocity();
210            void processClientOrientation();
211            void processClientAngularVelocity();
212
213            void networkcallback_changedplayerID();
214
215            // Bullet btMotionState related
216            void setWorldTransform(const btTransform& worldTrans);
217
218            unsigned int server_overwrite_;
219            unsigned int client_overwrite_;
220
221            bool bHasLocalController_;
222            bool bHasHumanController_;
223            bool bDestroyWhenPlayerLeft_;
224
225            Vector3 server_position_;
226            Vector3 client_position_;
227            Vector3 server_linear_velocity_;
228            Vector3 client_linear_velocity_;
229            Quaternion server_orientation_;
230            Quaternion client_orientation_;
231            Vector3 server_angular_velocity_;
232            Vector3 client_angular_velocity_;
233
234            PlayerInfo* player_;
235            PlayerInfo* formerPlayer_;
236            unsigned int playerID_;
237
238            std::string hudtemplate_;
239            OverlayGroup* hud_;
240
241            Camera* camera_;
242            bool bMouseLook_;
243            float mouseLookSpeed_;
244            std::list<StrongPtr<CameraPosition> > cameraPositions_;
245            CameraPosition* currentCameraPosition_;
246            std::string cameraPositionTemplate_;
247            Controller* xmlcontroller_;
248            WeakPtr<Controller> controller_;
249            CameraPosition* reverseCamera_;
250            WeakPtr<WorldEntity> target_;
251
252            int team_ ; //<! teamnumber
253    };
254}
255
256#endif /* _ControllableEntity_H__ */
Note: See TracBrowser for help on using the repository browser.