Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/branches/tutorial/src/modules/pickup/PickupSpawner.cc @ 8784

Last change on this file since 8784 was 7801, checked in by dafrick, 14 years ago

Merging presentation2 branch back to trunk.

  • Property svn:eol-style set to native
File size: 10.9 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 *      Daniel 'Huty' Haggenmueller
24 *   Co-authors:
25 *      Damian 'Mozork' Frick
26 *
27 */
28
29/**
30    @file PickupSpawner.cc
31    @brief Implementation of the PickupSpawner class.
32*/
33
34#include "PickupSpawner.h"
35
36#include "core/CoreIncludes.h"
37#include "core/GameMode.h"
38#include "core/Template.h"
39#include "core/XMLPort.h"
40
41#include "worldentities/pawns/Pawn.h"
42
43#include "PickupManager.h"
44#include "PickupRepresentation.h"
45
46namespace orxonox
47{
48
49    CreateFactory(PickupSpawner);
50
51    /**
52    @brief
53        Constructor. Creates a blank PickupSpawner.
54    @param creator
55        Pointer to the object which created this item.
56    */
57    PickupSpawner::PickupSpawner(BaseObject* creator) : StaticEntity(creator), pickup_(NULL)
58    {
59        RegisterObject(PickupSpawner);
60
61        this->initialize();
62    }
63
64    /**
65    @brief
66        Constructor, Creates a fully functional PickupSpawner.
67    @param creator
68        The creator of this PickupSpawner.
69    @param pickup
70        The Pickupable to be spawned by this PickupSpawner.
71    @param triggerDistance
72        The distance at which the PickupSpawner will trigger.
73    @param respawnTime
74        The minimum time between two spawns.
75    @param maxSpawnedItems
76        The maximum number of items spawned by this PickupSpawner.
77    */
78    PickupSpawner::PickupSpawner(BaseObject* creator, Pickupable* pickup, float triggerDistance, float respawnTime, int maxSpawnedItems) : StaticEntity(creator), pickup_(NULL)
79    {
80        RegisterObject(PickupSpawner);
81
82        this->initialize();
83
84        this->pickup_ = pickup;
85
86        this->triggerDistance_ = triggerDistance;
87        this->respawnTime_ = respawnTime;
88        this->setMaxSpawnedItems(maxSpawnedItems);
89
90        if(this->pickup_ == NULL)
91        {
92            COUT(2) << "A PickupSpawner was created without a valid Pickupable. This won't work." << std::endl;
93            this->setActive(false);
94        }
95        else
96        {
97            PickupRepresentation* representation = PickupManager::getInstance().getRepresentation(this->pickup_->getPickupIdentifier());
98            this->attach(representation->getSpawnerRepresentation(this));
99            this->setActive(true);
100        }
101    }
102
103    /**
104    @brief
105        Registers the object and sets some default values.
106    */
107    void PickupSpawner::initialize(void)
108    {
109        this->triggerDistance_ = 10;
110        this->respawnTime_ = 5.0f;
111        this->maxSpawnedItems_ = INF;
112        this->spawnsRemaining_ = INF;
113        this->selfDestruct_ = false;
114    }
115
116    /**
117    @brief
118        Destructor.
119    */
120    PickupSpawner::~PickupSpawner()
121    {
122        if(this->isInitialized() && this->selfDestruct_ && this->pickup_ != NULL)
123            this->pickup_->destroy();
124    }
125
126    /**
127    @brief
128        Method for creating a PickupSpawner through XML.
129    @param xmlelement
130        XML element which contains the PickupSpawner.
131    @param mode
132        XMLPort mode.
133    */
134    void PickupSpawner::XMLPort(Element& xmlelement, XMLPort::Mode mode)
135    {
136        SUPER(PickupSpawner, XMLPort, xmlelement, mode);
137
138        XMLPortObject(PickupSpawner, Pickupable, "pickup", setPickupable, getPickupable, xmlelement, mode);
139
140        XMLPortParam(PickupSpawner, "triggerDistance", setTriggerDistance, getTriggerDistance, xmlelement, mode);
141        XMLPortParam(PickupSpawner, "respawnTime", setRespawnTime, getRespawnTime, xmlelement, mode);
142        XMLPortParam(PickupSpawner, "maxSpawnedItems", setMaxSpawnedItems, getMaxSpawnedItems, xmlelement, mode);
143
144        if(this->pickup_ == NULL)
145        {
146            COUT(2) << "A PickupSpawner was created without a valid Pickupable. This won't work." << std::endl;
147            this->setActive(false);
148        }
149        else
150        {
151            PickupRepresentation* representation = PickupManager::getInstance().getRepresentation(this->pickup_->getPickupIdentifier());
152            this->attach(representation->getSpawnerRepresentation(this));
153            this->setActive(true);
154        }
155    }
156
157    /**
158    @brief
159        Invoked when the activity has changed. Sets visibility of attached objects.
160    */
161    void PickupSpawner::changedActivity()
162    {
163        SUPER(PickupSpawner, changedActivity);
164
165        if(GameMode::isMaster())
166            this->setVisible(this->isActive());
167    }
168
169    /**
170    @brief
171        Tick, checks if any Pawn is close enough to trigger.
172    @param dt
173        Time since last tick.
174    */
175    //TODO: Replace with collisions?
176    void PickupSpawner::tick(float dt)
177    {
178        SUPER(PickupSpawner, tick, dt);
179
180        // If the PickupSpawner is active.
181        if(GameMode::isMaster() && this->isActive())
182        {
183            SmartPtr<PickupSpawner> temp = this; //Create a smart pointer to keep the PickupSpawner alive until we iterated through all Pawns (in case a Pawn takes the last pickup)
184
185            // Remove PickupCarriers from the blocked list if they have exceeded their time.
186            for(std::map<PickupCarrier*, std::time_t>::iterator it = this->blocked_.begin(); it != this->blocked_.end(); )
187            {
188                std::map<PickupCarrier*, std::time_t>::iterator temp = it;
189                it++;
190                if(temp->second < std::time(0))
191                    this->blocked_.erase(temp);
192            }
193
194            // Iterate trough all Pawns.
195            for(ObjectList<Pawn>::iterator it = ObjectList<Pawn>::begin(); it != ObjectList<Pawn>::end(); ++it)
196            {
197                Vector3 distance = it->getWorldPosition() - this->getWorldPosition();
198                PickupCarrier* carrier = dynamic_cast<PickupCarrier*>(*it);
199                // If a PickupCarrier, that fits the target-range of the Pickupable spawned by this PickupSpawnder, is in trigger-distance and the carrier is not blocked.
200                if(distance.length() < this->triggerDistance_ && carrier != NULL && this->blocked_.find(carrier) == this->blocked_.end())
201                {
202                    if(carrier->isTarget(this->pickup_))
203                        this->trigger(*it);
204                }
205            }
206        }
207    }
208
209    /**
210    @brief
211        Sets the maximum number of spawned items.
212    @param items
213        The maximum number of spawned items to be set.
214    */
215    void PickupSpawner::setMaxSpawnedItems(int items)
216    {
217        this->maxSpawnedItems_ = items;
218        this->spawnsRemaining_ = items;
219    }
220
221    /**
222    @brief
223        Decrements the number of remaining spawns.
224        Sets the PickupSpawner to inactive for the duration of the respawnTime.
225        Destroys the PickupSpawner if the number of remaining spawns has reached zero.
226    */
227    void PickupSpawner::decrementSpawnsRemaining(void)
228    {
229        if(this->spawnsRemaining_ != INF)
230            this->spawnsRemaining_--;
231
232        if(this->spawnsRemaining_ != 0 && this->respawnTime_ > 0)
233        {
234            this->startRespawnTimer();
235
236            this->setActive(false);
237            this->fireEvent();
238        }
239        else
240        {
241            COUT(4) << "PickupSpawner (&" << this << ") empty, selfdestruct initialized." << std::endl;
242            this->setActive(false);
243            this->destroy();
244        }
245    }
246
247    /**
248    @brief
249        Starts the respawn timer.
250    */
251    void PickupSpawner::startRespawnTimer(void)
252    {
253        this->respawnTimer_.setTimer(this->respawnTime_, false, createExecutor(createFunctor(&PickupSpawner::respawnTimerCallback, this)));
254    }
255
256    /**
257    @brief
258        Sets a Pickupable for the PickupSpawner to spawn.
259    @param pickup
260        The Pickupable to be set.
261    */
262    void PickupSpawner::setPickupable(Pickupable* pickup)
263    {
264        if(this->pickup_ != NULL)
265        {
266            COUT(1) << "In PickupSpawner (&" << this << "): setPickupable called, with this->pickup_ already set." << std::endl;
267            return;
268        }
269        if(pickup == NULL)
270        {
271            COUT(1) << "In PickupSpawner (&" << this << "): Argument of setPickupable is NULL." << std::endl;
272            return;
273        }
274
275        this->pickup_ = pickup;
276    }
277
278    /**
279    @brief
280        Get the Pickupable that is spawned by this PickupSpawner.
281    @return
282        Returns the Pickupable that is spawned by this PickupSpawner.
283    */
284    const Pickupable* PickupSpawner::getPickupable(void) const
285    {
286        return this->pickup_;
287    }
288
289    /**
290    @brief
291        Trigger the PickupSpawner.
292        Adds the pickup to the Pawn that triggered, sets the timer to re-activate and deactives the PickupSpawner.
293    @param pawn
294        Pawn which triggered the PickupSpawner.
295    */
296    void PickupSpawner::trigger(Pawn* pawn)
297    {
298        if(this->isActive()) // Checks whether PickupSpawner is active.
299        {
300            COUT(4) << "PickupSpawner (&" << this << ") triggered and active." << std::endl;
301
302            PickupCarrier* carrier = dynamic_cast<PickupCarrier*>(pawn);
303            assert(carrier);
304
305            // If the Pawn isn't a target of the Pickupable.
306            if(!carrier->isTarget(this->pickup_))
307            {
308                COUT(4) << "PickupSpawner (&" << this << ") triggered but Pawn wasn't a target of the Pickupable." << std::endl;
309                return;
310            }
311
312            PickupCarrier* target = carrier->getTarget(this->pickup_);
313            Pickupable* pickup = this->getPickup();
314
315            this->block(carrier);
316
317            assert(pickup);
318            assert(target);
319            bool pickedUp = pickup->pickup(target);
320            assert(pickedUp);
321            pickedUp = false; // To avoid compiler warning.
322
323            this->decrementSpawnsRemaining();
324        }
325    }
326
327    /**
328    @brief
329        Creates a new Pickupable.
330    @return
331        The Pickupable created.
332    */
333    Pickupable* PickupSpawner::getPickup(void)
334    {
335        if(this->spawnsRemaining_ == 0)
336        {
337            COUT(1) << "Massive Error: PickupSpawner still alive until having spawned last item." << std::endl;
338            return NULL;
339        }
340
341        Pickupable* pickup = this->pickup_->clone();
342        return pickup;
343    }
344
345    /**
346    @brief
347        Invoked by the timer, re-activates the PickupSpawner.
348    */
349    void PickupSpawner::respawnTimerCallback()
350    {
351        COUT(4) << "PickupSpawner (&" << this << ") reactivated." << std::endl;
352
353        this->setActive(true);
354    }
355}
Note: See TracBrowser for help on using the repository browser.