Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/branches/mergeFS18/src/orxonox/worldentities/ControllableEntity.cc @ 12069

Last change on this file since 12069 was 12028, checked in by merholzl, 6 years ago

added scriptable controller

  • 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"
[9667]35#include "core/config/ConfigValueIncludes.h"
[2896]36#include "core/GameMode.h"
[2072]37#include "core/XMLPort.h"
[10624]38#include "network/NetworkFunctionIncludes.h"
[2072]39
[5735]40#include "Scene.h"
[12028]41#include "Level.h"
[5735]42#include "infos/PlayerInfo.h"
[7860]43#include "controllers/NewHumanController.h"
[5737]44#include "graphics/Camera.h"
[5735]45#include "worldentities/CameraPosition.h"
[2072]46#include "overlays/OverlayGroup.h"
47
48namespace orxonox
49{
[9667]50    RegisterClass(ControllableEntity);
[2072]51
[6417]52    registerMemberNetworkFunction( ControllableEntity, fire );
53    registerMemberNetworkFunction( ControllableEntity, setTargetInternal );
54
[9667]55    ControllableEntity::ControllableEntity(Context* context) : MobileEntity(context)
[2072]56    {
57        RegisterObject(ControllableEntity);
58
[2662]59        this->bHasLocalController_ = false;
60        this->bHasHumanController_ = false;
61
[2072]62        this->server_overwrite_ = 0;
63        this->client_overwrite_ = 0;
[11071]64        this->player_ = nullptr;
65        this->formerPlayer_ = nullptr;
[2171]66        this->playerID_ = OBJECTID_UNKNOWN;
[11071]67        this->hud_ = nullptr;
68        this->camera_ = nullptr;
69        this->xmlcontroller_ = nullptr;
70        this->reverseCamera_ = nullptr;
[2072]71        this->bDestroyWhenPlayerLeft_ = false;
[2662]72        this->cameraPositionRootNode_ = this->node_->createChildSceneNode();
[11071]73        this->currentCameraPosition_ = nullptr;
[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();
[9348]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
[11071]110            for (CameraPosition* cameraPosition : this->cameraPositions_)
111                cameraPosition->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;
[11071]167        for (CameraPosition* cameraPosition : this->cameraPositions_)
[2072]168        {
169            if (i == index)
[11071]170                return cameraPosition;
[2072]171            ++i;
172        }
[11071]173        return nullptr;
[2072]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;
[11071]182        for (CameraPosition* cameraPosition : this->cameraPositions_)
[8706]183        {
[11071]184            if (cameraPosition == this->currentCameraPosition_)
[8706]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    {
[11071]196        if(this->camera_ != nullptr && this->cameraPositions_.size() > 0)
[8706]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_);
[10624]217                this->currentCameraPosition_ = this->cameraPositions_.front();
[2072]218            }
219            else if (this->cameraPositions_.size() > 0)
220            {
[11071]221                for (std::list<StrongPtr<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_);
[11071]243                this->currentCameraPosition_ = nullptr;
[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
[9348]268                NewHumanController* controller = orxonox_cast<NewHumanController*>(this->getController());
[7860]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        {
[10624]309            callMemberNetworkFunction(&ControllableEntity::fire, this->getObjectID(), 0, firemode);
[6417]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        {
[11071]323            if ( target != nullptr )
[6417]324            {
[10624]325                callMemberNetworkFunction(&ControllableEntity::setTargetInternal, this->getObjectID(), 0, target->getObjectID() );
[6417]326            }
327           else
328           {
[10624]329                callMemberNetworkFunction(&ControllableEntity::setTargetInternal, this->getObjectID(), 0, OBJECTID_UNKNOWN );
[6417]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();
[11071]352        if(controller_ != nullptr)
[9799]353            this->team_ = controller_->getTeam(); // forward controller team number
[2662]354
355        if (this->bHasLocalController_ && this->bHasHumanController_)
[2072]356        {
[2662]357            this->startLocalHumanControl();
[2072]358
[2896]359            if (!GameMode::isMaster())
[2072]360            {
361                this->client_overwrite_ = this->server_overwrite_;
[5929]362                this->setSyncMode(ObjectDirection::Bidirectional);
[2072]363            }
364        }
[2839]365
366        this->changedPlayer();
[2072]367    }
368
369    void ControllableEntity::removePlayer()
370    {
[2662]371        if (this->bHasLocalController_ && this->bHasHumanController_)
372            this->stopLocalHumanControl();
[2072]373
[11071]374        this->player_ = nullptr;
[2171]375        this->playerID_ = OBJECTID_UNKNOWN;
[2662]376        this->bHasLocalController_ = false;
377        this->bHasHumanController_ = false;
[5929]378        this->setSyncMode(ObjectDirection::ToClient);
[2072]379
[2839]380        this->changedPlayer();
381
[2072]382        if (this->bDestroyWhenPlayerLeft_)
[5929]383            this->destroy();
[2072]384    }
385
386    void ControllableEntity::networkcallback_changedplayerID()
387    {
388        // just do this in case the entity wasn't yet synchronized when the corresponding PlayerInfo got our objectID
[2171]389        if (this->playerID_ != OBJECTID_UNKNOWN)
[2072]390        {
[3325]391            this->player_ = orxonox_cast<PlayerInfo*>(Synchronisable::getSynchronisable(this->playerID_));
[2072]392            if (this->player_ && (this->player_->getControllableEntity() != this))
393                this->player_->startControl(this);
394        }
395    }
396
[2662]397    void ControllableEntity::startLocalHumanControl()
398    {
[5929]399        if (!this->camera_ && GameMode::showsGraphics())
[2072]400        {
[9667]401            this->camera_ = new Camera(this->getContext());
[2662]402            this->camera_->requestFocus();
[6417]403            if (!this->cameraPositionTemplate_.empty())
[2662]404                this->addTemplate(this->cameraPositionTemplate_);
405            if (this->cameraPositions_.size() > 0)
[6417]406            {
[2662]407                this->cameraPositions_.front()->attachCamera(this->camera_);
[6417]408                this->currentCameraPosition_ = this->cameraPositions_.front();
409            }
[2662]410            else
[6417]411            {
[2662]412                this->camera_->attachToNode(this->cameraPositionRootNode_);
[11071]413                this->currentCameraPosition_ = nullptr;
[6417]414            }
[2072]415        }
[2662]416
[8706]417        this->createHud();
418    }
419
420    // HACK-ish
421    void ControllableEntity::createHud(void)
422    {
[5929]423        if (!this->hud_ && GameMode::showsGraphics())
[2662]424        {
[6417]425            if (!this->hudtemplate_.empty())
[2662]426            {
[9667]427                this->hud_ = new OverlayGroup(this->getContext());
[2662]428                this->hud_->addTemplate(this->hudtemplate_);
429                this->hud_->setOwner(this);
430            }
431        }
[2072]432    }
433
[8706]434    void ControllableEntity::destroyHud(void)
435    {
[11071]436        if (this->hud_ != nullptr)
[8706]437        {
438            this->hud_->destroy();
[11071]439            this->hud_ = nullptr;
[8706]440        }
441    }
442
[2662]443    void ControllableEntity::stopLocalHumanControl()
[2072]444    {
[2662]445        if (this->camera_)
446        {
447            this->camera_->detachFromParent();
[5929]448            this->camera_->destroy();
[11071]449            this->camera_ = nullptr;
[2662]450        }
[2072]451
[2662]452        if (this->hud_)
453        {
[5929]454            this->hud_->destroy();
[11071]455            this->hud_ = nullptr;
[2662]456        }
[2072]457    }
458
[3049]459    void ControllableEntity::setXMLController(Controller* controller)
460    {
461        if (!this->xmlcontroller_)
462        {
463            this->xmlcontroller_ = controller;
464            this->bHasLocalController_ = true;
465            this->xmlcontroller_->setControllableEntity(this);
[9799]466            this->team_ = this->xmlcontroller_->getTeam(); //forward the team number
[3049]467        }
468        else
[8858]469            orxout(internal_warning) << "ControllableEntity \"" << this->getName() << "\" already has a Controller." << endl;
[3049]470    }
471
[2851]472    void ControllableEntity::parentChanged()
473    {
474        WorldEntity::parentChanged();
475
476        WorldEntity* parent = this->getParent();
477        if (parent)
478        {
[11071]479            for (CameraPosition* cameraPosition : this->cameraPositions_)
480                if (cameraPosition->getIsAbsolute())
481                    parent->attach(cameraPosition);
[2851]482        }
483    }
484
[2072]485    void ControllableEntity::tick(float dt)
486    {
[2662]487        MobileEntity::tick(dt);
488
[2072]489        if (this->isActive())
490        {
[2662]491            // Check whether Bullet doesn't do the physics for us
492            if (!this->isDynamic())
[2072]493            {
[2896]494                if (GameMode::isMaster())
[2662]495                {
496                    this->server_position_ = this->getPosition();
497                    this->server_orientation_ = this->getOrientation();
498                    this->server_linear_velocity_ = this->getVelocity();
499                    this->server_angular_velocity_ = this->getAngularVelocity();
500                }
501                else if (this->bHasLocalController_)
502                {
503                    this->client_position_ = this->getPosition();
504                    this->client_orientation_ = this->getOrientation();
505                    this->client_linear_velocity_ = this->getVelocity();
506                    this->client_angular_velocity_ = this->getAngularVelocity();
507                }
[2072]508            }
509        }
510    }
511
512    void ControllableEntity::registerVariables()
513    {
[3280]514        registerVariable(this->cameraPositionTemplate_,  VariableDirection::ToClient);
515        registerVariable(this->hudtemplate_,             VariableDirection::ToClient);
[2072]516
[3280]517        registerVariable(this->server_position_,         VariableDirection::ToClient, new NetworkCallback<ControllableEntity>(this, &ControllableEntity::processServerPosition));
518        registerVariable(this->server_linear_velocity_,  VariableDirection::ToClient, new NetworkCallback<ControllableEntity>(this, &ControllableEntity::processServerLinearVelocity));
519        registerVariable(this->server_orientation_,      VariableDirection::ToClient, new NetworkCallback<ControllableEntity>(this, &ControllableEntity::processServerOrientation));
520        registerVariable(this->server_angular_velocity_, VariableDirection::ToClient, new NetworkCallback<ControllableEntity>(this, &ControllableEntity::processServerAngularVelocity));
[2072]521
[3280]522        registerVariable(this->server_overwrite_,        VariableDirection::ToClient, new NetworkCallback<ControllableEntity>(this, &ControllableEntity::processOverwrite));
523        registerVariable(this->client_overwrite_,        VariableDirection::ToServer);
[2072]524
[3280]525        registerVariable(this->client_position_,         VariableDirection::ToServer, new NetworkCallback<ControllableEntity>(this, &ControllableEntity::processClientPosition));
526        registerVariable(this->client_linear_velocity_,  VariableDirection::ToServer, new NetworkCallback<ControllableEntity>(this, &ControllableEntity::processClientLinearVelocity));
527        registerVariable(this->client_orientation_,      VariableDirection::ToServer, new NetworkCallback<ControllableEntity>(this, &ControllableEntity::processClientOrientation));
528        registerVariable(this->client_angular_velocity_, VariableDirection::ToServer, new NetworkCallback<ControllableEntity>(this, &ControllableEntity::processClientAngularVelocity));
[2072]529
[5735]530
[3280]531        registerVariable(this->playerID_,                VariableDirection::ToClient, new NetworkCallback<ControllableEntity>(this, &ControllableEntity::networkcallback_changedplayerID));
[2072]532    }
533
534    void ControllableEntity::processServerPosition()
535    {
[2662]536        if (!this->bHasLocalController_)
537            MobileEntity::setPosition(this->server_position_);
[2072]538    }
539
[2662]540    void ControllableEntity::processServerLinearVelocity()
[2072]541    {
[2662]542        if (!this->bHasLocalController_)
543            MobileEntity::setVelocity(this->server_linear_velocity_);
[2072]544    }
545
546    void ControllableEntity::processServerOrientation()
547    {
[2662]548        if (!this->bHasLocalController_)
549            MobileEntity::setOrientation(this->server_orientation_);
[2072]550    }
551
[2662]552    void ControllableEntity::processServerAngularVelocity()
553    {
554        if (!this->bHasLocalController_)
555            MobileEntity::setAngularVelocity(this->server_angular_velocity_);
556    }
557
[2072]558    void ControllableEntity::processOverwrite()
559    {
[2662]560        if (this->bHasLocalController_)
[2072]561        {
562            this->setPosition(this->server_position_);
563            this->setOrientation(this->server_orientation_);
[2662]564            this->setVelocity(this->server_linear_velocity_);
565            this->setAngularVelocity(this->server_angular_velocity_);
[2072]566
567            this->client_overwrite_ = this->server_overwrite_;
568        }
569    }
570
571    void ControllableEntity::processClientPosition()
572    {
573        if (this->server_overwrite_ == this->client_overwrite_)
574        {
[2662]575            MobileEntity::setPosition(this->client_position_);
576            this->server_position_ = this->getPosition();
[2072]577        }
578    }
579
[2662]580    void ControllableEntity::processClientLinearVelocity()
[2072]581    {
582        if (this->server_overwrite_ == this->client_overwrite_)
583        {
[2662]584            MobileEntity::setVelocity(this->client_linear_velocity_);
585            this->server_linear_velocity_ = this->getVelocity();
[2072]586        }
587    }
588
589    void ControllableEntity::processClientOrientation()
590    {
591        if (this->server_overwrite_ == this->client_overwrite_)
592        {
[2662]593            MobileEntity::setOrientation(this->client_orientation_);
594            this->server_orientation_ = this->getOrientation();
[2072]595        }
596    }
597
[2662]598    void ControllableEntity::processClientAngularVelocity()
[2072]599    {
[2662]600        if (this->server_overwrite_ == this->client_overwrite_)
[2072]601        {
[2662]602            MobileEntity::setAngularVelocity(this->client_angular_velocity_);
603            this->server_angular_velocity_ = this->getAngularVelocity();
[2072]604        }
605    }
606
[2662]607    void ControllableEntity::setPosition(const Vector3& position)
[2072]608    {
[2896]609        if (GameMode::isMaster())
[2072]610        {
[2662]611            MobileEntity::setPosition(position);
612            this->server_position_ = this->getPosition();
[2072]613            ++this->server_overwrite_;
614        }
[2662]615        else if (this->bHasLocalController_)
[2072]616        {
[2662]617            MobileEntity::setPosition(position);
618            this->client_position_ = this->getPosition();
[2072]619        }
620    }
621
622    void ControllableEntity::setOrientation(const Quaternion& orientation)
623    {
[2896]624        if (GameMode::isMaster())
[2072]625        {
[2662]626            MobileEntity::setOrientation(orientation);
627            this->server_orientation_ = this->getOrientation();
[2072]628            ++this->server_overwrite_;
629        }
[2662]630        else if (this->bHasLocalController_)
[2072]631        {
[2662]632            MobileEntity::setOrientation(orientation);
633            this->client_orientation_ = this->getOrientation();
[2072]634        }
635    }
636
[2662]637    void ControllableEntity::setVelocity(const Vector3& velocity)
[2072]638    {
[2896]639        if (GameMode::isMaster())
[2072]640        {
[2662]641            MobileEntity::setVelocity(velocity);
642            this->server_linear_velocity_ = this->getVelocity();
[2072]643            ++this->server_overwrite_;
644        }
[2662]645        else if (this->bHasLocalController_)
[2072]646        {
[2662]647            MobileEntity::setVelocity(velocity);
648            this->client_linear_velocity_ = this->getVelocity();
[2072]649        }
650    }
651
[2662]652    void ControllableEntity::setAngularVelocity(const Vector3& velocity)
[2072]653    {
[2896]654        if (GameMode::isMaster())
[2072]655        {
[2662]656            MobileEntity::setAngularVelocity(velocity);
657            this->server_angular_velocity_ = this->getAngularVelocity();
[2072]658            ++this->server_overwrite_;
659        }
[2662]660        else if (this->bHasLocalController_)
[2072]661        {
[2662]662            MobileEntity::setAngularVelocity(velocity);
663            this->client_angular_velocity_ = this->getAngularVelocity();
[2072]664        }
665    }
666
[2662]667    void ControllableEntity::setWorldTransform(const btTransform& worldTrans)
[2072]668    {
[2662]669        MobileEntity::setWorldTransform(worldTrans);
[2896]670        if (GameMode::isMaster())
[2072]671        {
[2662]672            this->server_position_ = this->getPosition();
673            this->server_orientation_ = this->getOrientation();
674            this->server_linear_velocity_ = this->getVelocity();
675            this->server_angular_velocity_ = this->getAngularVelocity();
[2072]676        }
[2662]677        else if (this->bHasLocalController_)
[2072]678        {
[2662]679            this->client_position_ = this->getPosition();
680            this->client_orientation_ = this->getOrientation();
681            this->client_linear_velocity_ = this->getVelocity();
682            this->client_angular_velocity_ = this->getAngularVelocity();
[2072]683        }
684    }
685}
Note: See TracBrowser for help on using the repository browser.