Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

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

Last change on this file since 9322 was 9016, checked in by jo, 13 years ago

Merging presentation2011 branch to trunk. Please check for possible bugs.

  • Property svn:eol-style set to native
File size: 23.8 KB
RevLine 
[2072]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:
[2662]25 *      Reto Grieder
[2072]26 *
27 */
28
29#include "ControllableEntity.h"
30
[2662]31#include <OgreSceneManager.h>
[3196]32#include <OgreSceneNode.h>
[2662]33
[2072]34#include "core/CoreIncludes.h"
[2662]35#include "core/ConfigValueIncludes.h"
[2896]36#include "core/GameMode.h"
[2072]37#include "core/XMLPort.h"
[6417]38#include "network/NetworkFunction.h"
[2072]39
[5735]40#include "Scene.h"
41#include "infos/PlayerInfo.h"
[7860]42#include "controllers/NewHumanController.h"
[5737]43#include "graphics/Camera.h"
[5735]44#include "worldentities/CameraPosition.h"
[2072]45#include "overlays/OverlayGroup.h"
46
47namespace orxonox
48{
49    CreateFactory(ControllableEntity);
50
[6417]51    registerMemberNetworkFunction( ControllableEntity, fire );
52    registerMemberNetworkFunction( ControllableEntity, setTargetInternal );
53
[2662]54    ControllableEntity::ControllableEntity(BaseObject* creator) : MobileEntity(creator)
[2072]55    {
56        RegisterObject(ControllableEntity);
57
[2662]58        this->bHasLocalController_ = false;
59        this->bHasHumanController_ = false;
60
[2072]61        this->server_overwrite_ = 0;
62        this->client_overwrite_ = 0;
63        this->player_ = 0;
[7534]64        this->formerPlayer_ = NULL;
[2171]65        this->playerID_ = OBJECTID_UNKNOWN;
[2072]66        this->hud_ = 0;
67        this->camera_ = 0;
[3049]68        this->xmlcontroller_ = 0;
[8891]69        //this->controller_ = 0;
[3089]70        this->reverseCamera_ = 0;
[2072]71        this->bDestroyWhenPlayerLeft_ = false;
[2662]72        this->cameraPositionRootNode_ = this->node_->createChildSceneNode();
[6417]73        this->currentCameraPosition_ = 0;
[2662]74        this->bMouseLook_ = false;
75        this->mouseLookSpeed_ = 200;
[2072]76
[2662]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;
[2072]85
[2662]86        this->setConfigValues();
[3280]87        this->setPriority( Priority::VeryHigh );
[2072]88        this->registerVariables();
[9016]89        this->team_ = -1;
[2072]90    }
91
92    ControllableEntity::~ControllableEntity()
93    {
94        if (this->isInitialized())
95        {
[2662]96            this->bDestroyWhenPlayerLeft_ = false;
[2072]97
[2662]98            if (this->getPlayer() && this->getPlayer()->getControllableEntity() == this)
[3038]99                this->getPlayer()->stopControl();
[2662]100
[3049]101            if (this->xmlcontroller_)
[5929]102                this->xmlcontroller_->destroy();
[3049]103
[2072]104            if (this->hud_)
[5929]105                this->hud_->destroy();
[2072]106
107            if (this->camera_)
[5929]108                this->camera_->destroy();
[2072]109
[5929]110            for (std::list<SmartPtr<CameraPosition> >::const_iterator it = this->cameraPositions_.begin(); it != this->cameraPositions_.end(); ++it)
111                (*it)->destroy();
[2662]112
113            if (this->getScene()->getSceneManager())
114                this->getScene()->getSceneManager()->destroySceneNode(this->cameraPositionRootNode_->getName());
[2072]115        }
116    }
117
118    void ControllableEntity::XMLPort(Element& xmlelement, XMLPort::Mode mode)
119    {
120        SUPER(ControllableEntity, XMLPort, xmlelement, mode);
121
[9016]122        XMLPortParam(ControllableEntity, "team", setTeam, getTeam, xmlelement, mode).defaultValues(-1);
[2072]123        XMLPortParam(ControllableEntity, "hudtemplate", setHudTemplate, getHudTemplate, xmlelement, mode);
[8706]124        XMLPortParam(ControllableEntity, "camerapositiontemplate", setCameraPositionTemplate, getCameraPositionTemplate, xmlelement, mode);
[2072]125
126        XMLPortObject(ControllableEntity, CameraPosition, "camerapositions", addCameraPosition, getCameraPosition, xmlelement, mode);
[3049]127        XMLPortObject(ControllableEntity, Controller,     "controller",      setXMLController,  getXMLController,  xmlelement, mode);
[2072]128    }
129
[2662]130    void ControllableEntity::setConfigValues()
131    {
132        SetConfigValue(mouseLookSpeed_, 3.0f);
133    }
134
[7889]135    void ControllableEntity::preDestroy()
136    {
137        // HACK - solve this clean and without preDestroy hook for multiplayer where removePlayer() isn't called
[7892]138        if (this->isInitialized() && this->bHasLocalController_ && this->bHasHumanController_)
[7889]139            this->stopLocalHumanControl();
140    }
141
[2072]142    void ControllableEntity::addCameraPosition(CameraPosition* position)
143    {
[2826]144        if (!position->getIsAbsolute())
145        {
146            if (position->getAllowMouseLook())
147                position->attachToNode(this->cameraPositionRootNode_);
148            else
149                this->attach(position);
150        }
[2662]151        else
[2826]152        {
153            WorldEntity* parent = this->getParent();
154            if (parent)
155                parent->attach(position);
156        }
[3089]157
158        if (!position->getRenderCamera())
159            this->cameraPositions_.push_back(position);
160        else
161            this->setReverseCamera(position);
[2072]162    }
163
164    CameraPosition* ControllableEntity::getCameraPosition(unsigned int index) const
165    {
166        unsigned int i = 0;
[5929]167        for (std::list<SmartPtr<CameraPosition> >::const_iterator it = this->cameraPositions_.begin(); it != this->cameraPositions_.end(); ++it)
[2072]168        {
169            if (i == index)
170                return (*it);
171            ++i;
172        }
173        return 0;
174    }
175
[8706]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    }
[8891]193
[8706]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
[2072]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_);
[6417]217                this->currentCameraPosition_ = this->cameraPositions_.front().get();
[2072]218            }
219            else if (this->cameraPositions_.size() > 0)
220            {
[5929]221                for (std::list<SmartPtr<CameraPosition> >::const_iterator it = this->cameraPositions_.begin(); it != this->cameraPositions_.end(); ++it)
[2072]222                {
223                    if ((*it) == this->camera_->getParent())
224                    {
225                        ++it;
226                        if (it != this->cameraPositions_.end())
[6417]227                        {
[2072]228                            (*it)->attachCamera(this->camera_);
[6417]229                            this->currentCameraPosition_ = *it;
230                        }
[2072]231                        else
[6417]232                        {
[2072]233                            (*this->cameraPositions_.begin())->attachCamera(this->camera_);
[6417]234                            this->currentCameraPosition_ = *this->cameraPositions_.begin();
235                        }
[2072]236                        break;
237                    }
238                }
239            }
240            else
241            {
[2662]242                this->camera_->attachToNode(this->cameraPositionRootNode_);
[6417]243                this->currentCameraPosition_ = 0;
[2072]244            }
[7860]245
[7857]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();
[7860]249
250            // disable drag if in mouse look
251            if (this->bMouseLook_)
252                this->getCamera()->setDrag(false);
[2072]253        }
254    }
255
[2662]256    void ControllableEntity::mouseLook()
257    {
[7857]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_;
[2662]262
[7857]263            if (!this->bMouseLook_)
[7860]264            {
[7857]265                this->cameraPositionRootNode_->setOrientation(Quaternion::IDENTITY);
[7860]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 = dynamic_cast<NewHumanController*>(this->getController());
269                if (controller)
270                    controller->centerCursor();
271            }
272
[7857]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            }
[6417]280        }
[2662]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
[6417]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
[8891]313    void ControllableEntity::setController(Controller* val)
314    {
315        this->controller_ = val;
316    }
317
[6417]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
[2072]339    void ControllableEntity::setPlayer(PlayerInfo* player)
340    {
341        if (!player)
342        {
343            this->removePlayer();
344            return;
345        }
346
347        this->player_ = player;
[7533]348        this->formerPlayer_ = player;
[2072]349        this->playerID_ = player->getObjectID();
[2662]350        this->bHasLocalController_ = player->isLocalPlayer();
351        this->bHasHumanController_ = player->isHumanPlayer();
352
353        if (this->bHasLocalController_ && this->bHasHumanController_)
[2072]354        {
[2662]355            this->startLocalHumanControl();
[2072]356
[2896]357            if (!GameMode::isMaster())
[2072]358            {
359                this->client_overwrite_ = this->server_overwrite_;
[5929]360                this->setSyncMode(ObjectDirection::Bidirectional);
[2072]361            }
362        }
[2839]363
364        this->changedPlayer();
[2072]365    }
366
367    void ControllableEntity::removePlayer()
368    {
[2662]369        if (this->bHasLocalController_ && this->bHasHumanController_)
370            this->stopLocalHumanControl();
[2072]371
372        this->player_ = 0;
[2171]373        this->playerID_ = OBJECTID_UNKNOWN;
[2662]374        this->bHasLocalController_ = false;
375        this->bHasHumanController_ = false;
[5929]376        this->setSyncMode(ObjectDirection::ToClient);
[2072]377
[2839]378        this->changedPlayer();
379
[2072]380        if (this->bDestroyWhenPlayerLeft_)
[5929]381            this->destroy();
[2072]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
[2171]387        if (this->playerID_ != OBJECTID_UNKNOWN)
[2072]388        {
[3325]389            this->player_ = orxonox_cast<PlayerInfo*>(Synchronisable::getSynchronisable(this->playerID_));
[2072]390            if (this->player_ && (this->player_->getControllableEntity() != this))
391                this->player_->startControl(this);
392        }
393    }
394
[2662]395    void ControllableEntity::startLocalHumanControl()
396    {
[5929]397        if (!this->camera_ && GameMode::showsGraphics())
[2072]398        {
[2662]399            this->camera_ = new Camera(this);
400            this->camera_->requestFocus();
[6417]401            if (!this->cameraPositionTemplate_.empty())
[2662]402                this->addTemplate(this->cameraPositionTemplate_);
403            if (this->cameraPositions_.size() > 0)
[6417]404            {
[2662]405                this->cameraPositions_.front()->attachCamera(this->camera_);
[6417]406                this->currentCameraPosition_ = this->cameraPositions_.front();
407            }
[2662]408            else
[6417]409            {
[2662]410                this->camera_->attachToNode(this->cameraPositionRootNode_);
[6417]411                this->currentCameraPosition_ = 0;
412            }
[2072]413        }
[2662]414
[8706]415        this->createHud();
416    }
417
418    // HACK-ish
419    void ControllableEntity::createHud(void)
420    {
[5929]421        if (!this->hud_ && GameMode::showsGraphics())
[2662]422        {
[6417]423            if (!this->hudtemplate_.empty())
[2662]424            {
425                this->hud_ = new OverlayGroup(this);
426                this->hud_->addTemplate(this->hudtemplate_);
427                this->hud_->setOwner(this);
428            }
429        }
[2072]430    }
431
[8706]432    void ControllableEntity::destroyHud(void)
433    {
434        if (this->hud_ != NULL)
435        {
436            this->hud_->destroy();
437            this->hud_ = NULL;
438        }
439    }
440
[2662]441    void ControllableEntity::stopLocalHumanControl()
[2072]442    {
[2662]443        if (this->camera_)
444        {
445            this->camera_->detachFromParent();
[5929]446            this->camera_->destroy();
[2662]447            this->camera_ = 0;
448        }
[2072]449
[2662]450        if (this->hud_)
451        {
[5929]452            this->hud_->destroy();
[2662]453            this->hud_ = 0;
454        }
[2072]455    }
456
[3049]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
[8858]466            orxout(internal_warning) << "ControllableEntity \"" << this->getName() << "\" already has a Controller." << endl;
[3049]467    }
468
[2851]469    void ControllableEntity::parentChanged()
470    {
471        WorldEntity::parentChanged();
472
473        WorldEntity* parent = this->getParent();
474        if (parent)
475        {
[5929]476            for (std::list<SmartPtr<CameraPosition> >::iterator it = this->cameraPositions_.begin(); it != this->cameraPositions_.end(); ++it)
[2851]477                if ((*it)->getIsAbsolute())
478                    parent->attach((*it));
479        }
480    }
481
[2072]482    void ControllableEntity::tick(float dt)
483    {
[2662]484        MobileEntity::tick(dt);
485
[2072]486        if (this->isActive())
487        {
[2662]488            // Check whether Bullet doesn't do the physics for us
489            if (!this->isDynamic())
[2072]490            {
[2896]491                if (GameMode::isMaster())
[2662]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                }
[2072]505            }
506        }
507    }
508
509    void ControllableEntity::registerVariables()
510    {
[3280]511        registerVariable(this->cameraPositionTemplate_,  VariableDirection::ToClient);
512        registerVariable(this->hudtemplate_,             VariableDirection::ToClient);
[2072]513
[3280]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));
[2072]518
[3280]519        registerVariable(this->server_overwrite_,        VariableDirection::ToClient, new NetworkCallback<ControllableEntity>(this, &ControllableEntity::processOverwrite));
520        registerVariable(this->client_overwrite_,        VariableDirection::ToServer);
[2072]521
[3280]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));
[2072]526
[5735]527
[3280]528        registerVariable(this->playerID_,                VariableDirection::ToClient, new NetworkCallback<ControllableEntity>(this, &ControllableEntity::networkcallback_changedplayerID));
[2072]529    }
530
531    void ControllableEntity::processServerPosition()
532    {
[2662]533        if (!this->bHasLocalController_)
534            MobileEntity::setPosition(this->server_position_);
[2072]535    }
536
[2662]537    void ControllableEntity::processServerLinearVelocity()
[2072]538    {
[2662]539        if (!this->bHasLocalController_)
540            MobileEntity::setVelocity(this->server_linear_velocity_);
[2072]541    }
542
543    void ControllableEntity::processServerOrientation()
544    {
[2662]545        if (!this->bHasLocalController_)
546            MobileEntity::setOrientation(this->server_orientation_);
[2072]547    }
548
[2662]549    void ControllableEntity::processServerAngularVelocity()
550    {
551        if (!this->bHasLocalController_)
552            MobileEntity::setAngularVelocity(this->server_angular_velocity_);
553    }
554
[2072]555    void ControllableEntity::processOverwrite()
556    {
[2662]557        if (this->bHasLocalController_)
[2072]558        {
559            this->setPosition(this->server_position_);
560            this->setOrientation(this->server_orientation_);
[2662]561            this->setVelocity(this->server_linear_velocity_);
562            this->setAngularVelocity(this->server_angular_velocity_);
[2072]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        {
[2662]572            MobileEntity::setPosition(this->client_position_);
573            this->server_position_ = this->getPosition();
[2072]574        }
575    }
576
[2662]577    void ControllableEntity::processClientLinearVelocity()
[2072]578    {
579        if (this->server_overwrite_ == this->client_overwrite_)
580        {
[2662]581            MobileEntity::setVelocity(this->client_linear_velocity_);
582            this->server_linear_velocity_ = this->getVelocity();
[2072]583        }
584    }
585
586    void ControllableEntity::processClientOrientation()
587    {
588        if (this->server_overwrite_ == this->client_overwrite_)
589        {
[2662]590            MobileEntity::setOrientation(this->client_orientation_);
591            this->server_orientation_ = this->getOrientation();
[2072]592        }
593    }
594
[2662]595    void ControllableEntity::processClientAngularVelocity()
[2072]596    {
[2662]597        if (this->server_overwrite_ == this->client_overwrite_)
[2072]598        {
[2662]599            MobileEntity::setAngularVelocity(this->client_angular_velocity_);
600            this->server_angular_velocity_ = this->getAngularVelocity();
[2072]601        }
602    }
603
[2662]604    void ControllableEntity::setPosition(const Vector3& position)
[2072]605    {
[2896]606        if (GameMode::isMaster())
[2072]607        {
[2662]608            MobileEntity::setPosition(position);
609            this->server_position_ = this->getPosition();
[2072]610            ++this->server_overwrite_;
611        }
[2662]612        else if (this->bHasLocalController_)
[2072]613        {
[2662]614            MobileEntity::setPosition(position);
615            this->client_position_ = this->getPosition();
[2072]616        }
617    }
618
619    void ControllableEntity::setOrientation(const Quaternion& orientation)
620    {
[2896]621        if (GameMode::isMaster())
[2072]622        {
[2662]623            MobileEntity::setOrientation(orientation);
624            this->server_orientation_ = this->getOrientation();
[2072]625            ++this->server_overwrite_;
626        }
[2662]627        else if (this->bHasLocalController_)
[2072]628        {
[2662]629            MobileEntity::setOrientation(orientation);
630            this->client_orientation_ = this->getOrientation();
[2072]631        }
632    }
633
[2662]634    void ControllableEntity::setVelocity(const Vector3& velocity)
[2072]635    {
[2896]636        if (GameMode::isMaster())
[2072]637        {
[2662]638            MobileEntity::setVelocity(velocity);
639            this->server_linear_velocity_ = this->getVelocity();
[2072]640            ++this->server_overwrite_;
641        }
[2662]642        else if (this->bHasLocalController_)
[2072]643        {
[2662]644            MobileEntity::setVelocity(velocity);
645            this->client_linear_velocity_ = this->getVelocity();
[2072]646        }
647    }
648
[2662]649    void ControllableEntity::setAngularVelocity(const Vector3& velocity)
[2072]650    {
[2896]651        if (GameMode::isMaster())
[2072]652        {
[2662]653            MobileEntity::setAngularVelocity(velocity);
654            this->server_angular_velocity_ = this->getAngularVelocity();
[2072]655            ++this->server_overwrite_;
656        }
[2662]657        else if (this->bHasLocalController_)
[2072]658        {
[2662]659            MobileEntity::setAngularVelocity(velocity);
660            this->client_angular_velocity_ = this->getAngularVelocity();
[2072]661        }
662    }
663
[2662]664    void ControllableEntity::setWorldTransform(const btTransform& worldTrans)
[2072]665    {
[2662]666        MobileEntity::setWorldTransform(worldTrans);
[2896]667        if (GameMode::isMaster())
[2072]668        {
[2662]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();
[2072]673        }
[2662]674        else if (this->bHasLocalController_)
[2072]675        {
[2662]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();
[2072]680        }
681    }
682}
Note: See TracBrowser for help on using the repository browser.