Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/trunk/src/modules/pickup/PickupManager.cc @ 11353

Last change on this file since 11353 was 11353, checked in by patricwi, 3 years ago

merged HUD branch to trunk

  • Property svn:eol-style set to native
File size: 22.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 *      Damian 'Mozork' Frick
24 *   Co-authors:
25 *      ...
26 *
27*/
28
29/**
30    @file PickupManager.cc
31    @brief Implementation of the PickupManager class.
32*/
33
34#include "PickupManager.h"
35
36#include "core/CoreIncludes.h"
37#include "core/LuaState.h"
38#include "core/GUIManager.h"
39#include "core/class/Identifier.h"
40#include "core/singleton/ScopedSingletonIncludes.h"
41#include "network/Host.h"
42#include "network/NetworkFunctionIncludes.h"
43#include "core/input/KeyBinderManager.h"    //for keybinding
44#include "core/input/KeyBinder.h"           //for keybinding
45#include "core/command/ConsoleCommandIncludes.h"
46
47#include "infos/PlayerInfo.h"
48#include "interfaces/PickupCarrier.h"
49#include "worldentities/pawns/Pawn.h"
50
51#include "CollectiblePickup.h"
52#include "PickupRepresentation.h"
53#include "overlays/hud/HUDPickupSystem.h"
54
55namespace orxonox
56{
57    ManageScopedSingleton(PickupManager, ScopeID::ROOT, false);
58
59    // Initialization of the name of the PickupInventory GUI.
60    /*static*/ const std::string PickupManager::guiName_s = "PickupInventory";
61
62    // Register static network functions that are used to communicate changes to pickups over the network, such that the PickupInventory can display the information about the pickups properly.
63    registerStaticNetworkFunction(PickupManager::pickupChangedUsedNetwork);
64    registerStaticNetworkFunction(PickupManager::pickupChangedPickedUpNetwork);
65    registerStaticNetworkFunction(PickupManager::dropPickupNetworked);
66    registerStaticNetworkFunction(PickupManager::usePickupNetworked);
67
68    RegisterAbstractClass(PickupManager).inheritsFrom<PickupListener>();
69
70    SetConsoleCommand("useUnusePickup", &PickupManager::useUnusePickup).addShortcut().setActive(true);
71
72    /**
73    @brief
74        Constructor. Registers the PickupManager and creates the default PickupRepresentation.
75    */
76    PickupManager::PickupManager() : guiLoaded_(false), pickupHighestIndex_(0), defaultRepresentation_(nullptr)
77    {
78        RegisterObject(PickupManager);
79
80        this->defaultRepresentation_ = new PickupRepresentation();
81
82        orxout(internal_info, context::pickups) << "PickupManager created." << endl;
83    }
84
85    /**
86    @brief
87        Destructor.
88        Destroys the default PickupRepresentation and does some cleanup.
89    */
90    PickupManager::~PickupManager()
91    {
92        // Destroying the default representation.
93        if(this->defaultRepresentation_ != nullptr)
94            this->defaultRepresentation_->destroy();
95
96        this->representations_.clear();
97
98        // Destroying all the PickupInventoryContainers that are still there.
99        for(const auto& mapEntry : this->pickupInventoryContainers_)
100            delete mapEntry.second;
101        this->pickupInventoryContainers_.clear();
102
103        // Destroying all the WeakPointers that are still there.
104        this->pickups_.clear();
105
106        this->indexes_.clear();
107
108        orxout(internal_info, context::pickups) << "PickupManager destroyed." << endl;
109    }
110
111    /**
112    @brief
113        Registers a PickupRepresentation.
114    @param name
115        The representation's name.
116    @param representation
117        A pointer to the PickupRepresentation.
118    @return
119        Returns true if successful and false if not.
120    */
121    bool PickupManager::registerRepresentation(const std::string& name, PickupRepresentation* representation)
122    {
123        assert(representation);
124
125        // If the list is not empty and Pickupable already has a Representation registered.
126        if(!this->representations_.empty() && this->representations_.find(name) != this->representations_.end())
127            return false;
128
129        this->representations_[name] = representation;
130
131        orxout(verbose, context::pickups) << "PickupRepresentation &" << representation << " registered with the PickupManager." << endl;
132        return true;
133    }
134
135    /**
136    @brief
137        Unegisters a PickupRepresentation.
138    @param name
139        The representation's name.
140    @return
141        Returns true if successful and false if not.
142    */
143    bool PickupManager::unregisterRepresentation(const std::string& name)
144    {
145        std::map<std::string, PickupRepresentation*>::iterator it = this->representations_.find(name);
146        if(it == this->representations_.end()) // If the Pickupable is not registered in the first place.
147            return false;
148
149        this->representations_.erase(it);
150
151        orxout(verbose, context::pickups) << "PickupRepresentation &" << name << " unregistered with the PickupManager." << endl;
152        return true;
153    }
154
155    /**
156    @brief
157        Get the PickupRepresentation with the given name.
158    @param name
159        The name of the PickupRepresentation.
160    @return
161        Returns a pointer to the PickupRepresentation.
162    */
163    PickupRepresentation* PickupManager::getRepresentation(const std::string& name)
164    {
165        std::map<std::string, PickupRepresentation*>::iterator it = this->representations_.find(name);
166        if(it == this->representations_.end()) // If there is no PickupRepresentation associated with the input name.
167        {
168            orxout(verbose, context::pickups) << "PickupManager::getRepresentation() returned default representation." << endl;
169            return this->defaultRepresentation_;
170        }
171
172        return it->second;
173    }
174
175    /**
176    @brief
177        Is called by the PickupListener to notify the PickupManager, that the input Pickupable has transited to the input used state.
178    @param pickup
179        The Pickupable whose used status changed.
180    @param used
181        The used status the Pickupable changed to.
182    */
183    void PickupManager::pickupChangedUsed(Pickupable* pickup, bool used)
184    {
185        assert(pickup);
186
187        if(!GameMode::isMaster()) // If this is neither standalone nor the server.
188            return;
189
190        CollectiblePickup* collectible = orxonox_cast<CollectiblePickup*>(pickup);
191        // If the Pickupable is part of a PickupCollection it isn't displayed in the PickupInventory, just the PickupCollection is.
192        if(collectible != nullptr && collectible->isInCollection())
193            return;
194
195        // Getting clientId of the host this change of the pickup's used status concerns.
196        PickupCarrier* carrier = pickup->getCarrier();
197        while(carrier->getCarrierParent() != nullptr)
198            carrier = carrier->getCarrierParent();
199        Pawn* pawn = orxonox_cast<Pawn*>(carrier);
200        if(pawn == nullptr)
201            return;
202        PlayerInfo* info = pawn->getPlayer();
203        if(info == nullptr)
204            return;
205        unsigned int clientId = info->getClientID();
206
207        // Get the number identifying the pickup.
208        std::map<Pickupable*, uint32_t>::iterator it = this->indexes_.find(pickup);
209        assert(it != this->indexes_.end());
210        uint32_t index = it->second;
211
212        // If we're either in standalone mode or this is the host whom the change of the pickup's status concerns.
213        if(GameMode::isStandalone() || Host::getPlayerID() == clientId)
214        {
215            PickupManager::pickupChangedUsedNetwork(index, used, pickup->isUsable(), pickup->isUnusable());
216        }
217        // If the concerned host is somewhere in the network, we call pickupChangedUsedNetwork() on its PickupManager.
218        else
219        {
220            callStaticNetworkFunction(&PickupManager::pickupChangedUsedNetwork, clientId, index, used, pickup->isUsable(), pickup->isUnusable());
221        }
222    }
223
224    /**
225    @brief
226        Helper method to react to the change in the used status of a Pickupable.
227        Static method that is used by the server to inform the client it concerns about the status change.
228        The parameters that are given are used to update the information (i.e. the PickupInventoryContainer) the concerning PickupManager has about the Pickupable that changed.
229    @param pickup
230        A number identifying the Pickupable that changed its used status.
231    @param inUse
232        The used status the Pickupable changed to. (i.e. whether the Pickupable is in use or not).
233    @param usable
234        Whether the Pickupable's used status can be changed used in the PickupInventory.
235    @param unusable
236        Whether the Pickupable's used status can be changed to unused in the PickupInventory.
237    */
238    /*static*/ void PickupManager::pickupChangedUsedNetwork(uint32_t pickup, bool inUse, bool usable, bool unusable)
239    {
240        PickupManager& manager = PickupManager::getInstance(); // Get the PickupManager singleton on this host.
241        // If the input Pickupable (i.e its identifier) is not present in the list the PickupManager has.
242        if(manager.pickupInventoryContainers_.find(pickup) == manager.pickupInventoryContainers_.end())
243        {
244            orxout(internal_error, context::pickups) << "Pickupable &(" << pickup << ") was not registered with PickupManager for the PickupInventory, when it changed used." << endl;
245            return;
246        }
247
248        // Update the Pickupable's container with the information transferred.
249        manager.pickupInventoryContainers_[pickup]->inUse = inUse;
250        manager.pickupInventoryContainers_[pickup]->usable = usable;
251        manager.pickupInventoryContainers_[pickup]->unusable = unusable;
252
253        manager.updateGUI(); // Tell the PickupInventory that something has changed.
254    }
255
256    /**
257    @brief
258        Is called by the PickupListener to notify the PickupManager, that the input Pickupable has transited to the input pickedUp state.
259    @param pickup
260        The Pickupable whose pickedUp status changed.
261    @param pickedUp
262        The pickedUp status the Pickupable changed to.
263    */
264    void PickupManager::pickupChangedPickedUp(Pickupable* pickup, bool pickedUp)
265    {
266        assert(pickup);
267
268        for (HUDPickupSystem* hud : ObjectList<HUDPickupSystem>())
269            pickupSystem = hud;
270       
271        if(!GameMode::isMaster()) // If this is neither standalone nor the server.
272            return;
273
274        CollectiblePickup* collectible = orxonox_cast<CollectiblePickup*>(pickup);
275        // If the Pickupable is part of a PickupCollection it isn't displayed in the PickupInventory, just the PickupCollection is.
276        if(collectible != nullptr && collectible->isInCollection())
277            return;
278
279        // Getting clientId of the host this change of the pickup's pickedUp status concerns.
280        PickupCarrier* carrier = pickup->getCarrier();
281        while(carrier->getCarrierParent() != nullptr)
282            carrier = carrier->getCarrierParent();
283        Pawn* pawn = orxonox_cast<Pawn*>(carrier);
284        if(pawn == nullptr)
285            return;
286        PlayerInfo* info = pawn->getFormerPlayer();
287        if(info == nullptr)
288            return;
289        unsigned int clientId = info->getClientID();
290
291        uint32_t index = 0;
292        if(pickedUp) // If the Pickupable has changed to picked up, it is added to the required lists.
293        {
294            index = this->getPickupIndex(); // Get a new identifier (index) for the Pickupable.
295            // Add the Pickupable to the indexes_ and pickups_ lists.
296            this->indexes_[pickup] = index;
297            this->pickups_[index] = pickup;
298
299            this->picks.push_back(pickup);
300
301            if(pickupSystem)
302                pickupSystem->updatePickupList(picks, indexes_);
303           
304        }
305        else // If it was dropped, it is removed from the required lists.
306        {
307            // Get the indentifier (index) that identifies the input Pickupable.
308            std::map<Pickupable*, uint32_t>::iterator it = this->indexes_.find(pickup);
309            index = it->second;
310
311            this->indexes_.erase(pickup);
312            this->pickups_.erase(index); //set to null, so that can be identified as free slot by getPickupIndex()
313
314
315            this->picks.erase(std::remove(this->picks.begin(), this->picks.end(), pickup), this->picks.end()); //remove pickup from vector
316
317            if(pickupSystem)
318                pickupSystem->removePickup(pickup);
319        }
320
321        // If we're either in standalone mode or this is the host whom the change of the pickup's status concerns.
322        if(GameMode::isStandalone() || Host::getPlayerID() == clientId)
323        {
324            // If there is no PickupRepresentation registered the default representation is used.
325            if(this->representations_.find(pickup->getRepresentationName()) == this->representations_.end())
326                PickupManager::pickupChangedPickedUpNetwork(index, pickup->isUsable(), this->defaultRepresentation_->getObjectID(), pickup->getRepresentationName(), pickedUp);
327            else
328                PickupManager::pickupChangedPickedUpNetwork(index, pickup->isUsable(), this->representations_[pickup->getRepresentationName()]->getObjectID(), pickup->getRepresentationName(), pickedUp);
329        }
330        // If the concerned host is somewhere in the network, we call pickupChangedPickedUpNetwork() on its PickupManager.
331        else
332        {
333            // If there is no PickupRepresentation registered the default representation is used.
334            if(this->representations_.find(pickup->getRepresentationName()) == this->representations_.end())
335            {
336                callStaticNetworkFunction(&PickupManager::pickupChangedPickedUpNetwork, clientId, index, pickup->isUsable(), this->defaultRepresentation_->getObjectID(), pickedUp);
337            }
338            else
339            {
340                callStaticNetworkFunction(&PickupManager::pickupChangedPickedUpNetwork, clientId, index, pickup->isUsable(), this->representations_[pickup->getRepresentationName()]->getObjectID(), pickedUp);
341            }
342        }
343
344    }
345
346    //This function is called by the command line or by the key binding
347    //it uses or unuses the pickup, depending on its current state
348    //or drops it (depends what you comment/uncomment)
349    void PickupManager::useUnusePickup(uint32_t index) 
350    {
351        PickupManager& manager = PickupManager::getInstance();
352
353        if(!manager.pickups_.count(index)) return; //if pickup is no longer here, dont do anything
354
355        Pickupable* pickup=manager.pickups_.find(index)->second;
356        if(pickup==nullptr)
357        {
358            return;                       //pickup does not exist
359        }
360
361        //if the pickup should be dropped upon key press
362        manager.dropPickup(index);
363
364        //if the pickup should be used/unused upon key press
365
366        // if(pickup->isUsed())
367        //     manager.usePickup(index, false);
368        // else
369        //     manager.usePickup(index, true);
370    }
371
372
373    /**
374    @brief
375        Helper method to react to the change in the pickedUp status of a Pickupable.
376        Static method that is used by the server to inform the client it concerns about the status change.
377        The parameters that are given are used to update the information (i.e. the PickupInventoryContainer) the concerning PickupManager has about the Pickupable that changed.
378    @param pickup
379        A number identifying the Pickupable that changed its pickedUp status.
380    @param usable
381        Whether the Pickupable's used status can be changed to used in the PickupInventory.
382    @param representationObjectId
383        The objectId identifying (over the network) the PickupRepresentation that represents this Pickupable.
384    @param representationName
385        The name of the associated PickupRepresentation
386    @param pickedUp
387        The pickedUp status the Pickupable changed to.
388    */
389    /*static*/ void PickupManager::pickupChangedPickedUpNetwork(uint32_t pickup, bool usable, uint32_t representationObjectId, const std::string& representationName, bool pickedUp)
390    {
391        PickupManager& manager = PickupManager::getInstance(); // Get the PickupManager singleton on this host.
392        // If the Pickupable has been picked up, we create a new PickupInventoryContainer for it.
393        if(pickedUp)
394        {
395            // Create a new PickupInventoryContainer for the Pickupable and set all the necessary information.
396            PickupInventoryContainer* container = new PickupInventoryContainer;
397            container->pickup = pickup;
398            container->inUse = false;
399            container->pickedUp = pickedUp;
400            container->usable = usable;
401            container->unusable = false;
402            container->representationObjectId = representationObjectId;
403            container->representationName = representationName;
404            // Insert the container into the pickupInventoryContainers_ list.
405            manager.pickupInventoryContainers_.insert(std::pair<uint32_t, PickupInventoryContainer*>(pickup, container));
406
407            manager.updateGUI(); // Tell the PickupInventory that something has changed.
408        }
409        // If the Pickupable has been dropped, we remove it from the pickupInventoryContainers_ list.
410        else
411        {
412            std::map<uint32_t, PickupInventoryContainer*>::iterator it = manager.pickupInventoryContainers_.find(pickup);
413            if(it != manager.pickupInventoryContainers_.end())
414                delete it->second;
415            manager.pickupInventoryContainers_.erase(pickup);
416
417            manager.updateGUI(); // Tell the PickupInventory that something has changed.
418        }
419    }
420
421    /**
422    @brief
423        Get the number of pickups currently picked up by the player.
424        This method is used in lua to populate the PickupInventory. The intended usage is to call this method to reset the iterator of the list of PickupInventoryContainers and then use popPickup() to get the individual PickupInventoryContainers.
425    @return
426        Returns the number of the players picked up Pickupables.
427    */
428    int PickupManager::getNumPickups(void)
429    {
430        this->pickupsIterator_ = this->pickupInventoryContainers_.begin(); // Reset iterator.
431
432        return this->pickupInventoryContainers_.size();
433    }
434
435    /**
436    @brief
437        Drop the input Pickupable.
438        This method checks whether the input Pickupable still exists and drops it, if so.
439    @param pickup
440        The identifier of the Pickupable to be dropped.
441    */
442    void PickupManager::dropPickup(uint32_t pickup)
443    {
444        // If we're either server or standalone and the list of pickups is not empty, we find and drop the input pickup.
445        if(GameMode::isMaster())
446        {
447            if(this->pickups_.empty())
448                return;
449            Pickupable* pickupable = this->pickups_.find(pickup)->second;
450            if(pickupable != nullptr)
451            {
452                pickupable->drop();
453
454            }
455        }
456        // If we're neither server nor standalone we drop the pickup by calling dropPickupNetworked() of the PickupManager on the server.
457        else
458        {
459            callStaticNetworkFunction(&PickupManager::dropPickupNetworked, 0, pickup);
460        }
461    }
462
463    /**
464    @brief
465        Helper method to drop the input pickup on the server.
466        Static method that is used by clients to instruct the server to drop the input pickup.
467    @param pickup
468        The identifier of the Pickupable to be dropped.
469    */
470    /*static*/ void PickupManager::dropPickupNetworked(uint32_t pickup)
471    {
472        if(GameMode::isServer()) // Obviously we only want to do this on the server.
473        {
474            PickupManager& manager = PickupManager::getInstance();
475            manager.dropPickup(pickup);
476        }
477    }
478
479    /**
480    @brief
481        Use (or unuse) the input Pickupable.
482        This method checks whether the input Pickupable still exists and uses (or unuses) it, if so,
483    @param pickup
484        The identifier of the Pickupable to be used (or unused).
485    @param use
486        If true the input Pickupable is used, if false it is unused.
487    */
488    void PickupManager::usePickup(uint32_t pickup, bool use)
489    {
490        // If we're either server or standalone and the list of pickups is not empty, we find and change the used status of the input pickup.
491        if(GameMode::isMaster())
492        {
493            if(this->pickups_.empty())
494                return;
495            Pickupable* pickupable = this->pickups_.find(pickup)->second;
496            if(pickupable != nullptr)
497                pickupable->setUsed(use);
498        }
499        // If we're neither server nor standalone we change the used status of the pickup by calling usePickupNetworked() of the PickupManager on the server.
500        else
501        {
502            callStaticNetworkFunction(&PickupManager::usePickupNetworked, 0, pickup, use);
503        }
504    }
505
506    /**
507    @brief
508        Helper method to use (or unuse) the input Pickupable on the server.
509        Static method that is used by clients to instruct the server to use (or unuse) the input pickup.
510    @param pickup
511        The identifier of the Pickupable to be used (or unused).
512    @param use
513        If true the input Pickupable is used, if false it is unused.
514    */
515    /*static*/ void PickupManager::usePickupNetworked(uint32_t pickup, bool use)
516    {
517        if(GameMode::isServer())
518        {
519            PickupManager& manager = PickupManager::getInstance();
520            manager.usePickup(pickup, use);
521        }
522    }
523
524    /**
525    @brief
526        Updates the PickupInventory GUI.
527        Also loads the PickupInventory GUI if is hasn't been done already.
528    */
529    inline void PickupManager::updateGUI(void)
530    {
531        // We only need to update (and load) the GUI if this host shows graphics.
532        if(GameMode::showsGraphics())
533        {
534            if(!this->guiLoaded_) // If the GUI hasn't been loaded, yet, we load it.
535            {
536                GUIManager::getInstance().loadGUI(PickupManager::guiName_s);
537                this->guiLoaded_ = true;
538            }
539
540            // Update the GUI.
541            GUIManager::getInstance().getLuaState()->doString(PickupManager::guiName_s + ".update()");
542        }
543    }
544
545    /**
546    @brief
547        Get a new index between 0 and 9 for a Pickupable.
548        If all slots are occupied, the Pickupable in the first slot will be dropped.
549    @return
550        Returns the new index.
551    */
552    uint32_t PickupManager::getPickupIndex(void)
553    {
554        //check if there are free slots available
555
556        for(uint32_t i=0; i<10; i++)
557        {
558            if(!pickups_.count(i)) return i;
559        }
560        //all slots are full and we have to drop sth
561        orxout(internal_info, context::pickups) << "everything was full and we have now dropped the first element" << endl;
562        this->dropPickup(0);
563        return 0;
564    }
565
566}
Note: See TracBrowser for help on using the repository browser.