Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/branches/sound5/src/modules/weapons/projectiles/Rocket.cc @ 6505

Last change on this file since 6505 was 6502, checked in by rgrieder, 15 years ago

Removed a ton of msvc warnings revealed with OGRE v1.7 (they removed the warning suppressors in OgrePrerequisites.h).
All of them are conversions from one type to another that might be lossy (mostly double to float, please always use "3.7f" instead of "3.7" as constants when using floats).

  • Property svn:eol-style set to native
File size: 9.2 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 *      Oliver Scheuss
24 *   Co-authors:
25 *      ...
26 *
27 */
28
29#include "Rocket.h"
30
31#include <BulletDynamics/Dynamics/btRigidBody.h>
32
33#include "core/CoreIncludes.h"
34#include "core/XMLPort.h"
35#include "worldentities/CameraPosition.h"
36#include "worldentities/pawns/Pawn.h"
37#include "graphics/ParticleSpawner.h"
38#include "graphics/Model.h"
39#include "objects/collisionshapes/ConeCollisionShape.h"
40#include "infos/PlayerInfo.h"
41#include "controllers/Controller.h"
42#include "sound/WorldSound.h"
43
44namespace orxonox
45{
46    CreateFactory(Rocket);
47    // create the factory for the Rocket
48
49    /**
50    @brief
51        Constructor. Registers the object and initializes some default values.
52    */
53    Rocket::Rocket(BaseObject* creator) : ControllableEntity(creator)
54    {
55        RegisterObject(Rocket);// - register the Rocket class to the core
56
57        this->localAngularVelocity_ = 0;
58        this->bDestroy_ = false;
59        this->lifetime_ = 100;
60
61        if (GameMode::isMaster())
62        {
63            this->setCollisionType(WorldEntity::Kinematic);
64            this->setVelocity(0,0,-100);
65
66            Model* model = new Model(this);
67            model->setMeshSource("rocket.mesh");
68            model->scale(0.7f);
69            this->attach(model);
70            ParticleEmitter* fire = new ParticleEmitter(this);
71            this->attach(fire);
72            fire->setOrientation(this->getOrientation());
73            fire->setSource("Orxonox/rocketfire");
74
75            this->enableCollisionCallback();
76            this->setCollisionResponse(false);
77            this->setCollisionType(Kinematic);
78
79            ConeCollisionShape* collisionShape = new ConeCollisionShape(this);
80            collisionShape->setRadius(3);
81            collisionShape->setHeight(500);
82            this->attachCollisionShape(collisionShape);
83
84            this->destroyTimer_.setTimer(this->lifetime_, false, createExecutor(createFunctor(&Rocket::destroyObject, this)));
85
86            this->defSndWpnEngine_ = new WorldSound(this);
87            this->defSndWpnEngine_->setLooping(true);
88            this->defSndWpnEngine_->setSource("sounds/Rocket_engine.ogg");
89            this->attach(defSndWpnEngine_);
90
91            this->defSndWpnLaunch_ = new WorldSound(this);
92            this->defSndWpnLaunch_->setLooping(false);
93            this->defSndWpnLaunch_->setSource("sounds/Rocket_launch.ogg");
94            this->attach(defSndWpnLaunch_);
95        }
96        else
97        {
98            this->defSndWpnEngine_ = 0;
99            this->defSndWpnLaunch_ = 0;
100        }
101
102        CameraPosition* camPosition = new CameraPosition(this);
103        camPosition->setPosition(0,4,15);
104        camPosition->setAllowMouseLook(true);
105        this->addCameraPosition(camPosition);
106    }
107
108    /**
109    @brief
110        Destructor. Destroys controller, if present and kills sounds, if playing.
111    */
112    Rocket::~Rocket()
113    {
114        if(this->isInitialized())
115        {
116            if (GameMode::isMaster() && this->player_)
117                this->player_->stopTemporaryControl();
118
119            if ( this->defSndWpnEngine_ )
120                this->defSndWpnEngine_->destroy();
121
122            if ( this->defSndWpnLaunch_ )
123                this->defSndWpnLaunch_->destroy();
124        }
125    }
126
127    /**
128    @brief
129        Method for creating a Rocket through XML.
130    */
131    void Rocket::XMLPort(Element& xmlelement, XMLPort::Mode mode)
132    {
133        // this calls the XMLPort function of the parent class
134        SUPER(Rocket, XMLPort, xmlelement, mode);
135    }
136
137    void Rocket::setOwner(Pawn* owner)
138    {
139        this->owner_ = owner;
140        this->originalControllableEntity_ = this->owner_->getPlayer()->getControllableEntity();
141        this->player_ = this->owner_->getPlayer();
142        this->owner_->getPlayer()->startTemporaryControl(this);
143
144        if( GameMode::isMaster() )
145        {
146            this->defSndWpnEngine_->play();
147            this->defSndWpnLaunch_->play();
148        }
149    }
150
151    /**
152    @brief
153        Defines which actions the Rocket has to take in each tick.
154    @param dt
155        The length of the tick.
156    */
157    void Rocket::tick(float dt)
158    {
159        SUPER(Rocket, tick, dt);
160
161        if( this->hasLocalController() )
162        {
163            this->setAngularVelocity(this->getOrientation() * this->localAngularVelocity_);
164            this->setVelocity( this->getOrientation()*WorldEntity::FRONT*this->getVelocity().length() );
165            this->localAngularVelocity_ = 0;
166
167            if( this->bDestroy_ )
168                this->destroy();
169        }
170    }
171
172    bool Rocket::collidesAgainst(WorldEntity* otherObject, btManifoldPoint& contactPoint)
173    {
174        if (!this->bDestroy_ && GameMode::isMaster())
175        {
176            if (otherObject == this->owner_)
177                return false;
178
179            this->bDestroy_ = true;
180
181            if (this->owner_)
182            {
183                {
184                    ParticleSpawner* effect = new ParticleSpawner(this->owner_->getCreator());
185                    effect->setPosition(this->getPosition());
186                    effect->setOrientation(this->getOrientation());
187                    effect->setDestroyAfterLife(true);
188                    effect->setSource("Orxonox/explosion4");
189                    effect->setLifetime(2.0f);
190                }
191
192                {
193                    ParticleSpawner* effect = new ParticleSpawner(this->owner_->getCreator());
194                    effect->setPosition(this->getPosition());
195                    effect->setOrientation(this->getOrientation());
196                    effect->setDestroyAfterLife(true);
197                    effect->setSource("Orxonox/smoke4");
198                    effect->setLifetime(3.0f);
199                }
200            }
201
202            float dmg = this->damage_;
203            if (this->owner_)
204                dmg = this->owner_->getPickups().processModifiers(ModifierType::Damage, dmg, false);
205
206            Pawn* victim = orxonox_cast<Pawn*>(otherObject);
207            if (victim)
208                victim->hit(this->owner_, contactPoint, dmg);
209//             this->destroy();
210        }
211        return false;
212    }
213
214    void Rocket::destroyObject()
215    {
216        if (GameMode::isMaster())
217        {
218            if(this->defSndWpnEngine_->isPlaying())
219            {
220                this->defSndWpnEngine_->stop();
221            }
222            this->destroy();
223        }
224    }
225
226    void Rocket::fired(unsigned int firemode)
227    {
228        if (this->owner_)
229        {
230            {
231                ParticleSpawner* effect = new ParticleSpawner(this->owner_->getCreator());
232                effect->setPosition(this->getPosition());
233                effect->setOrientation(this->getOrientation());
234                effect->setDestroyAfterLife(true);
235                effect->setSource("Orxonox/explosion4");
236                effect->setLifetime(2.0f);
237            }
238
239            {
240                ParticleSpawner* effect = new ParticleSpawner(this->owner_->getCreator());
241                effect->setPosition(this->getPosition());
242                effect->setOrientation(this->getOrientation());
243                effect->setDestroyAfterLife(true);
244                effect->setSource("Orxonox/smoke4");
245                effect->setLifetime(3.0f);
246            }
247            this->destroy();
248        }
249    }
250
251    /**
252    @brief
253        Rotates the Rocket around the y-axis by the amount specified by the first component of the input 2-dim vector.
254    @param value
255        The vector determining the amount of the angular movement.
256    */
257    void Rocket::rotateYaw(const Vector2& value)
258    {
259        ControllableEntity::rotateYaw(value);
260
261        if( !this->isInMouseLook() )
262            this->localAngularVelocity_.y += value.x;
263    }
264
265    /**
266    @brief
267        Rotates the Rocket around the x-axis by the amount specified by the first component of the input 2-dim vector.
268    @param value
269        The vector determining the amount of the angular movement.
270    */
271    void Rocket::rotatePitch(const Vector2& value)
272    {
273        ControllableEntity::rotatePitch(value);
274
275        if( !this->isInMouseLook() )
276            this->localAngularVelocity_.x += value.x;
277    }
278
279    /**
280    @brief
281        Rotates the Rocket around the z-axis by the amount specified by the first component of the input 2-dim vector.
282    @param value
283        The vector determining the amount of the angular movement.
284    */
285    void Rocket::rotateRoll(const Vector2& value)
286    {
287        ControllableEntity::rotateRoll(value);
288
289        if( !this->isInMouseLook() )
290            this->localAngularVelocity_.z += value.x;
291    }
292
293}
Note: See TracBrowser for help on using the repository browser.