Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/branches/particles2/src/orxonox/weaponsystem/WeaponSystem.cc @ 6287

Last change on this file since 6287 was 6078, checked in by landauf, 15 years ago

delete weaponpacks which were defined in xml but don't fit onto the weaponslots (in the future we could put them into the inventory).

+ some small changes

  • Property svn:eol-style set to native
File size: 9.6 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 *      Martin Polak
24 *   Co-authors:
25 *      ...
26 *
27 */
28
29#include "WeaponSystem.h"
30
31#include "core/CoreIncludes.h"
32#include "worldentities/pawns/Pawn.h"
33
34#include "WeaponSlot.h"
35#include "WeaponPack.h"
36#include "WeaponSet.h"
37#include "Weapon.h"
38#include "Munition.h"
39
40/* WeaponSystem
41 *
42 *  www.orxonox.net/wiki/WeaponSystem
43 */
44
45namespace orxonox
46{
47    CreateFactory(WeaponSystem);
48
49    WeaponSystem::WeaponSystem(BaseObject* creator) : BaseObject(creator)
50    {
51        RegisterObject(WeaponSystem);
52
53        this->pawn_ = 0;
54    }
55
56    WeaponSystem::~WeaponSystem()
57    {
58        if (this->isInitialized())
59        {
60            if (this->pawn_)
61                this->pawn_->setWeaponSystem(0);
62
63            while (!this->weaponSets_.empty())
64                this->weaponSets_.begin()->second->destroy();
65
66            while (!this->weaponPacks_.empty())
67                (*this->weaponPacks_.begin())->destroy();
68
69            while (!this->weaponSlots_.empty())
70                (*this->weaponSlots_.begin())->destroy();
71
72            while (!this->munitions_.empty())
73                { this->munitions_.begin()->second->destroy(); this->munitions_.erase(this->munitions_.begin()); }
74        }
75    }
76
77    void WeaponSystem::addWeaponSlot(WeaponSlot * wSlot)
78    {
79        if (!wSlot)
80            return;
81
82        this->weaponSlots_.push_back(wSlot);
83        wSlot->setWeaponSystem(this);
84    }
85
86    void WeaponSystem::removeWeaponSlot(WeaponSlot * wSlot)
87    {
88        if (!wSlot)
89            return;
90
91        if (wSlot->getWeapon())
92            this->removeWeaponPack(wSlot->getWeapon()->getWeaponPack());
93
94        for (std::vector<WeaponSlot*>::iterator it = this->weaponSlots_.begin(); it != this->weaponSlots_.end(); ++it)
95        {
96            if ((*it) == wSlot)
97            {
98                this->weaponSlots_.erase(it);
99                break;
100            }
101        }
102    }
103
104    WeaponSlot * WeaponSystem::getWeaponSlot(unsigned int index) const
105    {
106        unsigned int i = 0;
107        for (std::vector<WeaponSlot*>::const_iterator it = this->weaponSlots_.begin(); it != this->weaponSlots_.end(); ++it)
108        {
109            ++i;
110            if (i > index)
111                return (*it);
112        }
113        return 0;
114    }
115
116    bool WeaponSystem::addWeaponSet(WeaponSet * wSet)
117    {
118        if (wSet)
119            return this->addWeaponSet(wSet, wSet->getDesiredFiremode());
120        else
121            return false;
122    }
123
124    bool WeaponSystem::addWeaponSet(WeaponSet * wSet, unsigned int firemode)
125    {
126        if (!wSet || firemode >= WeaponSystem::MAX_FIRE_MODES)
127            return false;
128
129        std::map<unsigned int, WeaponSet*>::const_iterator it = this->weaponSets_.find(firemode);
130        if (it == this->weaponSets_.end())
131        {
132            this->weaponSets_[firemode] = wSet;
133            wSet->setWeaponSystem(this);
134            return true;
135        }
136
137        return false;
138    }
139
140    void WeaponSystem::removeWeaponSet(WeaponSet * wSet)
141    {
142        for (std::map<unsigned int, WeaponSet*>::iterator it = this->weaponSets_.begin(); it != this->weaponSets_.end(); )
143        {
144            if (it->second == wSet)
145                this->weaponSets_.erase(it++);
146            else
147                ++it;
148        }
149    }
150
151    WeaponSet * WeaponSystem::getWeaponSet(unsigned int index) const
152    {
153        unsigned int i = 0;
154        for (std::map<unsigned int, WeaponSet*>::const_iterator it = this->weaponSets_.begin(); it != this->weaponSets_.end(); ++it)
155        {
156            ++i;
157            if (i > index)
158                return it->second;
159        }
160        return 0;
161    }
162
163    bool WeaponSystem::canAddWeaponPack(WeaponPack * wPack)
164    {
165        if (!wPack)
166            return false;
167
168        unsigned int freeSlots = 0;
169        for (std::vector<WeaponSlot*>::iterator it = this->weaponSlots_.begin(); it != this->weaponSlots_.end(); ++it)
170        {
171            if (!(*it)->isOccupied())
172                ++freeSlots;
173        }
174
175        return (freeSlots >= wPack->getNumWeapons());
176    }
177
178    bool WeaponSystem::addWeaponPack(WeaponPack * wPack)
179    {
180        if (!this->canAddWeaponPack(wPack))
181            return false;
182
183        // Attach all weapons to the first free slots (and to the Pawn)
184        unsigned int i = 0;
185        for (std::vector<WeaponSlot*>::iterator it = this->weaponSlots_.begin(); it != this->weaponSlots_.end(); ++it)
186        {
187            if (!(*it)->isOccupied() && i < wPack->getNumWeapons())
188            {
189                Weapon* weapon = wPack->getWeapon(i);
190                (*it)->attachWeapon(weapon);
191                this->getPawn()->attach(weapon);
192                ++i;
193            }
194        }
195
196        // Assign the desired weaponmode to the firemodes
197        for (std::map<unsigned int, WeaponSet *>::iterator it = this->weaponSets_.begin(); it != this->weaponSets_.end(); ++it)
198        {
199            unsigned int weaponmode = wPack->getDesiredWeaponmode(it->first);
200            if (weaponmode != WeaponSystem::WEAPON_MODE_UNASSIGNED)
201                it->second->setWeaponmodeLink(wPack, weaponmode);
202        }
203
204        this->weaponPacks_.push_back(wPack);
205        wPack->setWeaponSystem(this);
206
207        return true;
208    }
209
210    void WeaponSystem::removeWeaponPack(WeaponPack * wPack)
211    {
212        // Remove all weapons from their WeaponSlot
213        unsigned int i = 0;
214        Weapon* weapon = 0;
215        while ((weapon = wPack->getWeapon(i++)))
216            weapon->getWeaponSlot()->removeWeapon();
217
218        // Remove all added links from the WeaponSets
219        for (std::map<unsigned int, WeaponSet *>::iterator it = this->weaponSets_.begin(); it != this->weaponSets_.end(); ++it)
220            it->second->removeWeaponmodeLink(wPack);
221
222        // Remove the WeaponPack from the WeaponSystem
223        std::vector<WeaponPack*>::iterator it = std::find(this->weaponPacks_.begin(),this->weaponPacks_.end(), wPack);
224        assert(it !=this->weaponPacks_.end());
225        this->weaponPacks_.erase(it);
226    }
227
228    WeaponPack * WeaponSystem::getWeaponPack(unsigned int index) const
229    {
230        unsigned int i = 0;
231        for (std::vector<WeaponPack*>::const_iterator it = this->weaponPacks_.begin(); it != this->weaponPacks_.end(); ++it)
232        {
233            ++i;
234            if (i > index)
235                return (*it);
236        }
237        return 0;
238    }
239
240    bool WeaponSystem::swapWeaponSlots(WeaponSlot * wSlot1, WeaponSlot * wSlot2)
241    {
242        if (!wSlot1 || !wSlot2)
243            return false;
244
245        Weapon* weapon1 = wSlot1->getWeapon();
246        Weapon* weapon2 = wSlot2->getWeapon();
247
248        wSlot1->attachWeapon(weapon2);
249        wSlot2->attachWeapon(weapon1);
250
251        return true;
252        // In the future, certain weapons might not fit to some slots. Swapping would then be
253        // impossible and the returnvalue would be false.
254    }
255
256    void WeaponSystem::changeWeaponmode(WeaponPack * wPack, WeaponSet * wSet, unsigned int weaponmode)
257    {
258        if (!wPack || !wSet)
259            return;
260
261        // Check if the WeaponPack belongs to this WeaponSystem
262        std::vector<WeaponPack *>::iterator it1 = std::find( this->weaponPacks_.begin(), this->weaponPacks_.end(), wPack );
263        if (it1 == this->weaponPacks_.end())
264            return;
265
266        // Check if the WeaponSet belongs to this WeaponSystem
267        bool foundWeaponSet = false;
268        for (std::map<unsigned int, WeaponSet *>::iterator it2 = this->weaponSets_.begin(); it2 != this->weaponSets_.end(); ++it2)
269        {
270            if (it2->second == wSet)
271            {
272                foundWeaponSet = true;
273                break;
274            }
275        }
276        if (!foundWeaponSet)
277            return;
278
279        // Finally set the link between firemode and weaponmode
280        wSet->setWeaponmodeLink(wPack, weaponmode);
281    }
282
283    void WeaponSystem::fire(unsigned int firemode)
284    {
285        std::map<unsigned int, WeaponSet *>::iterator it = this->weaponSets_.find(firemode);
286        if (it != this->weaponSets_.end() && it->second)
287            it->second->fire();
288    }
289
290    void WeaponSystem::reload()
291    {
292        for (std::map<unsigned int, WeaponSet *>::iterator it = this->weaponSets_.begin(); it != this->weaponSets_.end(); ++it)
293            it->second->reload();
294    }
295
296    Munition * WeaponSystem::getMunition(SubclassIdentifier<Munition> * identifier)
297    {
298        if (!identifier || !identifier->getIdentifier())
299            return 0;
300
301        std::map<Identifier *, Munition *>::iterator it = this->munitions_.find(identifier->getIdentifier());
302        if (it != this->munitions_.end())
303        {
304            return it->second;
305        }
306        else if (identifier->getIdentifier()->isA(Class(Munition)))
307        {
308            Munition* munition = identifier->fabricate(this);
309            this->munitions_[identifier->getIdentifier()] = munition;
310            return munition;
311        }
312        else
313        {
314            return 0;
315        }
316    }
317}
Note: See TracBrowser for help on using the repository browser.