Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/trunk/src/orxonox/worldentities/ControllableEntity.cc @ 9550

Last change on this file since 9550 was 9348, checked in by landauf, 12 years ago

merged branch presentation2012merge back to trunk

  • Property svn:eol-style set to native
File size: 23.8 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#include "ControllableEntity.h"
30
31#include <OgreSceneManager.h>
32#include <OgreSceneNode.h>
33
34#include "core/CoreIncludes.h"
35#include "core/ConfigValueIncludes.h"
36#include "core/GameMode.h"
37#include "core/XMLPort.h"
38#include "network/NetworkFunction.h"
39
40#include "Scene.h"
41#include "infos/PlayerInfo.h"
42#include "controllers/NewHumanController.h"
43#include "graphics/Camera.h"
44#include "worldentities/CameraPosition.h"
45#include "overlays/OverlayGroup.h"
46
47namespace orxonox
48{
49    CreateFactory(ControllableEntity);
50
51    registerMemberNetworkFunction( ControllableEntity, fire );
52    registerMemberNetworkFunction( ControllableEntity, setTargetInternal );
53
54    ControllableEntity::ControllableEntity(BaseObject* creator) : MobileEntity(creator)
55    {
56        RegisterObject(ControllableEntity);
57
58        this->bHasLocalController_ = false;
59        this->bHasHumanController_ = false;
60
61        this->server_overwrite_ = 0;
62        this->client_overwrite_ = 0;
63        this->player_ = 0;
64        this->formerPlayer_ = NULL;
65        this->playerID_ = OBJECTID_UNKNOWN;
66        this->hud_ = 0;
67        this->camera_ = 0;
68        this->xmlcontroller_ = 0;
69        //this->controller_ = 0;
70        this->reverseCamera_ = 0;
71        this->bDestroyWhenPlayerLeft_ = false;
72        this->cameraPositionRootNode_ = this->node_->createChildSceneNode();
73        this->currentCameraPosition_ = 0;
74        this->bMouseLook_ = false;
75        this->mouseLookSpeed_ = 200;
76
77        this->server_position_         = Vector3::ZERO;
78        this->client_position_         = Vector3::ZERO;
79        this->server_linear_velocity_  = Vector3::ZERO;
80        this->client_linear_velocity_  = Vector3::ZERO;
81        this->server_orientation_      = Quaternion::IDENTITY;
82        this->client_orientation_      = Quaternion::IDENTITY;
83        this->server_angular_velocity_ = Vector3::ZERO;
84        this->client_angular_velocity_ = Vector3::ZERO;
85
86        this->setConfigValues();
87        this->setPriority( Priority::VeryHigh );
88        this->registerVariables();
89        this->team_ = -1;
90    }
91
92    ControllableEntity::~ControllableEntity()
93    {
94        if (this->isInitialized())
95        {
96            this->bDestroyWhenPlayerLeft_ = false;
97
98            if (this->getPlayer() && this->getPlayer()->getControllableEntity() == this)
99                this->getPlayer()->stopControl();
100
101            if (this->xmlcontroller_)
102                this->xmlcontroller_->destroy();
103
104            if (this->hud_)
105                this->hud_->destroy();
106
107            if (this->camera_)
108                this->camera_->destroy();
109
110            for (std::list<SmartPtr<CameraPosition> >::const_iterator it = this->cameraPositions_.begin(); it != this->cameraPositions_.end(); ++it)
111                (*it)->destroy();
112
113            if (this->getScene()->getSceneManager())
114                this->getScene()->getSceneManager()->destroySceneNode(this->cameraPositionRootNode_->getName());
115        }
116    }
117
118    void ControllableEntity::XMLPort(Element& xmlelement, XMLPort::Mode mode)
119    {
120        SUPER(ControllableEntity, XMLPort, xmlelement, mode);
121
122        XMLPortParam(ControllableEntity, "team", setTeam, getTeam, xmlelement, mode).defaultValues(-1);
123        XMLPortParam(ControllableEntity, "hudtemplate", setHudTemplate, getHudTemplate, xmlelement, mode);
124        XMLPortParam(ControllableEntity, "camerapositiontemplate", setCameraPositionTemplate, getCameraPositionTemplate, xmlelement, mode);
125
126        XMLPortObject(ControllableEntity, CameraPosition, "camerapositions", addCameraPosition, getCameraPosition, xmlelement, mode);
127        XMLPortObject(ControllableEntity, Controller,     "controller",      setXMLController,  getXMLController,  xmlelement, mode);
128    }
129
130    void ControllableEntity::setConfigValues()
131    {
132        SetConfigValue(mouseLookSpeed_, 3.0f);
133    }
134
135    void ControllableEntity::preDestroy()
136    {
137        // HACK - solve this clean and without preDestroy hook for multiplayer where removePlayer() isn't called
138        if (this->isInitialized() && this->bHasLocalController_ && this->bHasHumanController_)
139            this->stopLocalHumanControl();
140    }
141
142    void ControllableEntity::addCameraPosition(CameraPosition* position)
143    {
144        if (!position->getIsAbsolute())
145        {
146            if (position->getAllowMouseLook())
147                position->attachToNode(this->cameraPositionRootNode_);
148            else
149                this->attach(position);
150        }
151        else
152        {
153            WorldEntity* parent = this->getParent();
154            if (parent)
155                parent->attach(position);
156        }
157
158        if (!position->getRenderCamera())
159            this->cameraPositions_.push_back(position);
160        else
161            this->setReverseCamera(position);
162    }
163
164    CameraPosition* ControllableEntity::getCameraPosition(unsigned int index) const
165    {
166        unsigned int i = 0;
167        for (std::list<SmartPtr<CameraPosition> >::const_iterator it = this->cameraPositions_.begin(); it != this->cameraPositions_.end(); ++it)
168        {
169            if (i == index)
170                return (*it);
171            ++i;
172        }
173        return 0;
174    }
175
176    unsigned int ControllableEntity::getCurrentCameraIndex() const
177    {
178        if (this->cameraPositions_.size() <= 0)
179            return 0;
180
181        unsigned int counter = 0;
182        for (std::list<SmartPtr<CameraPosition> >::const_iterator it = this->cameraPositions_.begin(); it != this->cameraPositions_.end(); ++it)
183        {
184            if ((*it) == this->currentCameraPosition_)
185                break;
186            counter++;
187        }
188        if (counter >= this->cameraPositions_.size())
189            return 0;
190
191        return counter;
192    }
193
194    bool ControllableEntity::setCameraPosition(unsigned int index)
195    {
196        if(this->camera_ != NULL && this->cameraPositions_.size() > 0)
197        {
198            if(index >= this->cameraPositions_.size())
199                index = 0;
200
201            CameraPosition* position = this->getCameraPosition(index);
202            position->attachCamera(this->camera_);
203            this->currentCameraPosition_ = position;
204            return true;
205        }
206
207        return false;
208    }
209
210    void ControllableEntity::switchCamera()
211    {
212        if (this->camera_)
213        {
214            if (this->camera_->getParent() == this && this->cameraPositions_.size() > 0)
215            {
216                this->cameraPositions_.front()->attachCamera(this->camera_);
217                this->currentCameraPosition_ = this->cameraPositions_.front().get();
218            }
219            else if (this->cameraPositions_.size() > 0)
220            {
221                for (std::list<SmartPtr<CameraPosition> >::const_iterator it = this->cameraPositions_.begin(); it != this->cameraPositions_.end(); ++it)
222                {
223                    if ((*it) == this->camera_->getParent())
224                    {
225                        ++it;
226                        if (it != this->cameraPositions_.end())
227                        {
228                            (*it)->attachCamera(this->camera_);
229                            this->currentCameraPosition_ = *it;
230                        }
231                        else
232                        {
233                            (*this->cameraPositions_.begin())->attachCamera(this->camera_);
234                            this->currentCameraPosition_ = *this->cameraPositions_.begin();
235                        }
236                        break;
237                    }
238                }
239            }
240            else
241            {
242                this->camera_->attachToNode(this->cameraPositionRootNode_);
243                this->currentCameraPosition_ = 0;
244            }
245
246            // disable mouse look if the new camera position doesn't allow it
247            if (this->currentCameraPosition_ && !this->currentCameraPosition_->getAllowMouseLook() && this->bMouseLook_)
248                this->mouseLook();
249
250            // disable drag if in mouse look
251            if (this->bMouseLook_)
252                this->getCamera()->setDrag(false);
253        }
254    }
255
256    void ControllableEntity::mouseLook()
257    {
258        // enable mouse look only if allowed - disabling it works always
259        if (this->currentCameraPosition_ && (this->currentCameraPosition_->getAllowMouseLook() || this->bMouseLook_))
260        {
261            this->bMouseLook_ = !this->bMouseLook_;
262
263            if (!this->bMouseLook_)
264            {
265                this->cameraPositionRootNode_->setOrientation(Quaternion::IDENTITY);
266                this->cameraPositionRootNode_->_update(true, false); // update the camera node because otherwise the camera will drag back in position which looks strange
267
268                NewHumanController* controller = orxonox_cast<NewHumanController*>(this->getController());
269                if (controller)
270                    controller->centerCursor();
271            }
272
273            if (this->getCamera())
274            {
275                if (!this->bMouseLook_ && this->currentCameraPosition_->getDrag())
276                    this->getCamera()->setDrag(true);
277                else
278                    this->getCamera()->setDrag(false);
279            }
280        }
281    }
282
283    void ControllableEntity::rotateYaw(const Vector2& value)
284    {
285        if (this->bMouseLook_)
286            this->cameraPositionRootNode_->yaw(Radian(value.y * this->mouseLookSpeed_), Ogre::Node::TS_LOCAL);
287    }
288
289    void ControllableEntity::rotatePitch(const Vector2& value)
290    {
291        if (this->bMouseLook_)
292            this->cameraPositionRootNode_->pitch(Radian(value.y * this->mouseLookSpeed_), Ogre::Node::TS_LOCAL);
293    }
294
295    void ControllableEntity::rotateRoll(const Vector2& value)
296    {
297        if (this->bMouseLook_)
298            this->cameraPositionRootNode_->roll(Radian(value.y * this->mouseLookSpeed_), Ogre::Node::TS_LOCAL);
299    }
300
301    void ControllableEntity::fire(unsigned int firemode)
302    {
303        if(GameMode::isMaster())
304        {
305            this->fired(firemode);
306        }
307        else
308        {
309            callMemberNetworkFunction(ControllableEntity, fire, this->getObjectID(), 0, firemode);
310        }
311    }
312
313    void ControllableEntity::setController(Controller* val)
314    {
315        this->controller_ = val;
316    }
317
318    void ControllableEntity::setTarget( WorldEntity* target )
319    {
320        this->target_ = target;
321        if ( !GameMode::isMaster() )
322        {
323            if ( target != 0 )
324            {
325                callMemberNetworkFunction(ControllableEntity, setTargetInternal, this->getObjectID(), 0, target->getObjectID() );
326            }
327           else
328           {
329                callMemberNetworkFunction(ControllableEntity, setTargetInternal, this->getObjectID(), 0, OBJECTID_UNKNOWN );
330           }
331        }
332    }
333
334    void ControllableEntity::setTargetInternal( uint32_t targetID )
335    {
336        this->setTarget( orxonox_cast<WorldEntity*>(Synchronisable::getSynchronisable(targetID)) );
337    }
338
339    void ControllableEntity::setPlayer(PlayerInfo* player)
340    {
341        if (!player)
342        {
343            this->removePlayer();
344            return;
345        }
346
347        this->player_ = player;
348        this->formerPlayer_ = player;
349        this->playerID_ = player->getObjectID();
350        this->bHasLocalController_ = player->isLocalPlayer();
351        this->bHasHumanController_ = player->isHumanPlayer();
352
353        if (this->bHasLocalController_ && this->bHasHumanController_)
354        {
355            this->startLocalHumanControl();
356
357            if (!GameMode::isMaster())
358            {
359                this->client_overwrite_ = this->server_overwrite_;
360                this->setSyncMode(ObjectDirection::Bidirectional);
361            }
362        }
363
364        this->changedPlayer();
365    }
366
367    void ControllableEntity::removePlayer()
368    {
369        if (this->bHasLocalController_ && this->bHasHumanController_)
370            this->stopLocalHumanControl();
371
372        this->player_ = 0;
373        this->playerID_ = OBJECTID_UNKNOWN;
374        this->bHasLocalController_ = false;
375        this->bHasHumanController_ = false;
376        this->setSyncMode(ObjectDirection::ToClient);
377
378        this->changedPlayer();
379
380        if (this->bDestroyWhenPlayerLeft_)
381            this->destroy();
382    }
383
384    void ControllableEntity::networkcallback_changedplayerID()
385    {
386        // just do this in case the entity wasn't yet synchronized when the corresponding PlayerInfo got our objectID
387        if (this->playerID_ != OBJECTID_UNKNOWN)
388        {
389            this->player_ = orxonox_cast<PlayerInfo*>(Synchronisable::getSynchronisable(this->playerID_));
390            if (this->player_ && (this->player_->getControllableEntity() != this))
391                this->player_->startControl(this);
392        }
393    }
394
395    void ControllableEntity::startLocalHumanControl()
396    {
397        if (!this->camera_ && GameMode::showsGraphics())
398        {
399            this->camera_ = new Camera(this);
400            this->camera_->requestFocus();
401            if (!this->cameraPositionTemplate_.empty())
402                this->addTemplate(this->cameraPositionTemplate_);
403            if (this->cameraPositions_.size() > 0)
404            {
405                this->cameraPositions_.front()->attachCamera(this->camera_);
406                this->currentCameraPosition_ = this->cameraPositions_.front();
407            }
408            else
409            {
410                this->camera_->attachToNode(this->cameraPositionRootNode_);
411                this->currentCameraPosition_ = 0;
412            }
413        }
414
415        this->createHud();
416    }
417
418    // HACK-ish
419    void ControllableEntity::createHud(void)
420    {
421        if (!this->hud_ && GameMode::showsGraphics())
422        {
423            if (!this->hudtemplate_.empty())
424            {
425                this->hud_ = new OverlayGroup(this);
426                this->hud_->addTemplate(this->hudtemplate_);
427                this->hud_->setOwner(this);
428            }
429        }
430    }
431
432    void ControllableEntity::destroyHud(void)
433    {
434        if (this->hud_ != NULL)
435        {
436            this->hud_->destroy();
437            this->hud_ = NULL;
438        }
439    }
440
441    void ControllableEntity::stopLocalHumanControl()
442    {
443        if (this->camera_)
444        {
445            this->camera_->detachFromParent();
446            this->camera_->destroy();
447            this->camera_ = 0;
448        }
449
450        if (this->hud_)
451        {
452            this->hud_->destroy();
453            this->hud_ = 0;
454        }
455    }
456
457    void ControllableEntity::setXMLController(Controller* controller)
458    {
459        if (!this->xmlcontroller_)
460        {
461            this->xmlcontroller_ = controller;
462            this->bHasLocalController_ = true;
463            this->xmlcontroller_->setControllableEntity(this);
464        }
465        else
466            orxout(internal_warning) << "ControllableEntity \"" << this->getName() << "\" already has a Controller." << endl;
467    }
468
469    void ControllableEntity::parentChanged()
470    {
471        WorldEntity::parentChanged();
472
473        WorldEntity* parent = this->getParent();
474        if (parent)
475        {
476            for (std::list<SmartPtr<CameraPosition> >::iterator it = this->cameraPositions_.begin(); it != this->cameraPositions_.end(); ++it)
477                if ((*it)->getIsAbsolute())
478                    parent->attach((*it));
479        }
480    }
481
482    void ControllableEntity::tick(float dt)
483    {
484        MobileEntity::tick(dt);
485
486        if (this->isActive())
487        {
488            // Check whether Bullet doesn't do the physics for us
489            if (!this->isDynamic())
490            {
491                if (GameMode::isMaster())
492                {
493                    this->server_position_ = this->getPosition();
494                    this->server_orientation_ = this->getOrientation();
495                    this->server_linear_velocity_ = this->getVelocity();
496                    this->server_angular_velocity_ = this->getAngularVelocity();
497                }
498                else if (this->bHasLocalController_)
499                {
500                    this->client_position_ = this->getPosition();
501                    this->client_orientation_ = this->getOrientation();
502                    this->client_linear_velocity_ = this->getVelocity();
503                    this->client_angular_velocity_ = this->getAngularVelocity();
504                }
505            }
506        }
507    }
508
509    void ControllableEntity::registerVariables()
510    {
511        registerVariable(this->cameraPositionTemplate_,  VariableDirection::ToClient);
512        registerVariable(this->hudtemplate_,             VariableDirection::ToClient);
513
514        registerVariable(this->server_position_,         VariableDirection::ToClient, new NetworkCallback<ControllableEntity>(this, &ControllableEntity::processServerPosition));
515        registerVariable(this->server_linear_velocity_,  VariableDirection::ToClient, new NetworkCallback<ControllableEntity>(this, &ControllableEntity::processServerLinearVelocity));
516        registerVariable(this->server_orientation_,      VariableDirection::ToClient, new NetworkCallback<ControllableEntity>(this, &ControllableEntity::processServerOrientation));
517        registerVariable(this->server_angular_velocity_, VariableDirection::ToClient, new NetworkCallback<ControllableEntity>(this, &ControllableEntity::processServerAngularVelocity));
518
519        registerVariable(this->server_overwrite_,        VariableDirection::ToClient, new NetworkCallback<ControllableEntity>(this, &ControllableEntity::processOverwrite));
520        registerVariable(this->client_overwrite_,        VariableDirection::ToServer);
521
522        registerVariable(this->client_position_,         VariableDirection::ToServer, new NetworkCallback<ControllableEntity>(this, &ControllableEntity::processClientPosition));
523        registerVariable(this->client_linear_velocity_,  VariableDirection::ToServer, new NetworkCallback<ControllableEntity>(this, &ControllableEntity::processClientLinearVelocity));
524        registerVariable(this->client_orientation_,      VariableDirection::ToServer, new NetworkCallback<ControllableEntity>(this, &ControllableEntity::processClientOrientation));
525        registerVariable(this->client_angular_velocity_, VariableDirection::ToServer, new NetworkCallback<ControllableEntity>(this, &ControllableEntity::processClientAngularVelocity));
526
527
528        registerVariable(this->playerID_,                VariableDirection::ToClient, new NetworkCallback<ControllableEntity>(this, &ControllableEntity::networkcallback_changedplayerID));
529    }
530
531    void ControllableEntity::processServerPosition()
532    {
533        if (!this->bHasLocalController_)
534            MobileEntity::setPosition(this->server_position_);
535    }
536
537    void ControllableEntity::processServerLinearVelocity()
538    {
539        if (!this->bHasLocalController_)
540            MobileEntity::setVelocity(this->server_linear_velocity_);
541    }
542
543    void ControllableEntity::processServerOrientation()
544    {
545        if (!this->bHasLocalController_)
546            MobileEntity::setOrientation(this->server_orientation_);
547    }
548
549    void ControllableEntity::processServerAngularVelocity()
550    {
551        if (!this->bHasLocalController_)
552            MobileEntity::setAngularVelocity(this->server_angular_velocity_);
553    }
554
555    void ControllableEntity::processOverwrite()
556    {
557        if (this->bHasLocalController_)
558        {
559            this->setPosition(this->server_position_);
560            this->setOrientation(this->server_orientation_);
561            this->setVelocity(this->server_linear_velocity_);
562            this->setAngularVelocity(this->server_angular_velocity_);
563
564            this->client_overwrite_ = this->server_overwrite_;
565        }
566    }
567
568    void ControllableEntity::processClientPosition()
569    {
570        if (this->server_overwrite_ == this->client_overwrite_)
571        {
572            MobileEntity::setPosition(this->client_position_);
573            this->server_position_ = this->getPosition();
574        }
575    }
576
577    void ControllableEntity::processClientLinearVelocity()
578    {
579        if (this->server_overwrite_ == this->client_overwrite_)
580        {
581            MobileEntity::setVelocity(this->client_linear_velocity_);
582            this->server_linear_velocity_ = this->getVelocity();
583        }
584    }
585
586    void ControllableEntity::processClientOrientation()
587    {
588        if (this->server_overwrite_ == this->client_overwrite_)
589        {
590            MobileEntity::setOrientation(this->client_orientation_);
591            this->server_orientation_ = this->getOrientation();
592        }
593    }
594
595    void ControllableEntity::processClientAngularVelocity()
596    {
597        if (this->server_overwrite_ == this->client_overwrite_)
598        {
599            MobileEntity::setAngularVelocity(this->client_angular_velocity_);
600            this->server_angular_velocity_ = this->getAngularVelocity();
601        }
602    }
603
604    void ControllableEntity::setPosition(const Vector3& position)
605    {
606        if (GameMode::isMaster())
607        {
608            MobileEntity::setPosition(position);
609            this->server_position_ = this->getPosition();
610            ++this->server_overwrite_;
611        }
612        else if (this->bHasLocalController_)
613        {
614            MobileEntity::setPosition(position);
615            this->client_position_ = this->getPosition();
616        }
617    }
618
619    void ControllableEntity::setOrientation(const Quaternion& orientation)
620    {
621        if (GameMode::isMaster())
622        {
623            MobileEntity::setOrientation(orientation);
624            this->server_orientation_ = this->getOrientation();
625            ++this->server_overwrite_;
626        }
627        else if (this->bHasLocalController_)
628        {
629            MobileEntity::setOrientation(orientation);
630            this->client_orientation_ = this->getOrientation();
631        }
632    }
633
634    void ControllableEntity::setVelocity(const Vector3& velocity)
635    {
636        if (GameMode::isMaster())
637        {
638            MobileEntity::setVelocity(velocity);
639            this->server_linear_velocity_ = this->getVelocity();
640            ++this->server_overwrite_;
641        }
642        else if (this->bHasLocalController_)
643        {
644            MobileEntity::setVelocity(velocity);
645            this->client_linear_velocity_ = this->getVelocity();
646        }
647    }
648
649    void ControllableEntity::setAngularVelocity(const Vector3& velocity)
650    {
651        if (GameMode::isMaster())
652        {
653            MobileEntity::setAngularVelocity(velocity);
654            this->server_angular_velocity_ = this->getAngularVelocity();
655            ++this->server_overwrite_;
656        }
657        else if (this->bHasLocalController_)
658        {
659            MobileEntity::setAngularVelocity(velocity);
660            this->client_angular_velocity_ = this->getAngularVelocity();
661        }
662    }
663
664    void ControllableEntity::setWorldTransform(const btTransform& worldTrans)
665    {
666        MobileEntity::setWorldTransform(worldTrans);
667        if (GameMode::isMaster())
668        {
669            this->server_position_ = this->getPosition();
670            this->server_orientation_ = this->getOrientation();
671            this->server_linear_velocity_ = this->getVelocity();
672            this->server_angular_velocity_ = this->getAngularVelocity();
673        }
674        else if (this->bHasLocalController_)
675        {
676            this->client_position_ = this->getPosition();
677            this->client_orientation_ = this->getOrientation();
678            this->client_linear_velocity_ = this->getVelocity();
679            this->client_angular_velocity_ = this->getAngularVelocity();
680        }
681    }
682}
Note: See TracBrowser for help on using the repository browser.