Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/trunk/src/modules/pickup/PickupSpawner.cc @ 8993

Last change on this file since 8993 was 8891, checked in by jo, 13 years ago

Ai and tutorial improvements merged back to the trunk. AI features: all weapons are used, the ai-firestrength is configurable, bots are able to collect pickups . I've set the tutorial level as default level.

  • Property svn:eol-style set to native
File size: 11.3 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            orxout(internal_warning, context::pickups) << "A PickupSpawner was created without a valid Pickupable. This won't work." << 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            orxout(internal_warning, context::pickups) << "A PickupSpawner was created without a valid Pickupable. This won't work." << 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            WeakPtr<PickupSpawner> spawner = 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                if(spawner == NULL) // Stop if the PickupSpawner has been deleted (e.g. because it has run out of pickups to distribute).
198                    break;
199
200                Vector3 distance = it->getWorldPosition() - this->getWorldPosition();
201                PickupCarrier* carrier = dynamic_cast<PickupCarrier*>(*it);
202                // If a PickupCarrier, that fits the target-range of the Pickupable spawned by this PickupSpawner, is in trigger-distance and the carrier is not blocked.
203                if(distance.length() < this->triggerDistance_ && carrier != NULL && this->blocked_.find(carrier) == this->blocked_.end())
204                {
205                    if(carrier->isTarget(this->pickup_))
206                        this->trigger(*it);
207                }
208            }
209        }
210    }
211
212    /**
213    @brief
214        Sets the maximum number of spawned items.
215    @param items
216        The maximum number of spawned items to be set.
217    */
218    void PickupSpawner::setMaxSpawnedItems(int items)
219    {
220        this->maxSpawnedItems_ = items;
221        this->spawnsRemaining_ = items;
222    }
223
224    /**
225    @brief
226        Decrements the number of remaining spawns.
227        Sets the PickupSpawner to inactive for the duration of the respawnTime.
228        Destroys the PickupSpawner if the number of remaining spawns has reached zero.
229    */
230    void PickupSpawner::decrementSpawnsRemaining(void)
231    {
232        if(this->spawnsRemaining_ != INF)
233            this->spawnsRemaining_--;
234
235        if(this->spawnsRemaining_ != 0 && this->respawnTime_ > 0)
236        {
237            this->startRespawnTimer();
238
239            this->setActive(false);
240            this->fireEvent();
241        }
242        else
243        {
244            orxout(verbose, context::pickups) << "PickupSpawner (&" << this << ") empty, selfdestruct initialized." << endl;
245            this->setActive(false);
246            this->destroy();
247        }
248    }
249
250    /**
251    @brief
252        Starts the respawn timer.
253    */
254    void PickupSpawner::startRespawnTimer(void)
255    {
256        this->respawnTimer_.setTimer(this->respawnTime_, false, createExecutor(createFunctor(&PickupSpawner::respawnTimerCallback, this)));
257    }
258
259    /**
260    @brief
261        Sets a Pickupable for the PickupSpawner to spawn.
262    @param pickup
263        The Pickupable to be set.
264    */
265    void PickupSpawner::setPickupable(Pickupable* pickup)
266    {
267        if(this->pickup_ != NULL)
268        {
269            orxout(internal_error, context::pickups) << "In PickupSpawner (&" << this << "): setPickupable called, with this->pickup_ already set." << endl;
270            return;
271        }
272        if(pickup == NULL)
273        {
274            orxout(internal_error, context::pickups) << "In PickupSpawner (&" << this << "): Argument of setPickupable is NULL." << endl;
275            return;
276        }
277
278        this->pickup_ = pickup;
279    }
280
281    /**
282    @brief
283        Get the Pickupable that is spawned by this PickupSpawner.
284    @return
285        Returns the Pickupable that is spawned by this PickupSpawner.
286    */
287    const Pickupable* PickupSpawner::getPickupable(void) const
288    {
289        return this->pickup_;
290    }
291
292    /**
293    @brief
294        Trigger the PickupSpawner.
295        Adds the pickup to the Pawn that triggered, sets the timer to re-activate and deactives the PickupSpawner.
296    @param pawn
297        Pawn which triggered the PickupSpawner.
298    */
299    void PickupSpawner::trigger(Pawn* pawn)
300    {
301        if(this->isActive()) // Checks whether PickupSpawner is active.
302        {
303            orxout(verbose, context::pickups) << "PickupSpawner (&" << this << ") triggered and active." << endl;
304
305            PickupCarrier* carrier = dynamic_cast<PickupCarrier*>(pawn);
306            assert(carrier);
307
308            // If the Pawn isn't a target of the Pickupable.
309            if(!carrier->isTarget(this->pickup_))
310            {
311                orxout(verbose, context::pickups) << "PickupSpawner (&" << this << ") triggered but Pawn wasn't a target of the Pickupable." << endl;
312                return;
313            }
314
315            PickupCarrier* target = carrier->getTarget(this->pickup_);
316            Pickupable* pickup = this->getPickup();
317
318            this->block(carrier);
319
320            assert(pickup);
321            assert(target);
322            bool pickedUp = pickup->pickup(target);
323            assert(pickedUp);
324            pickedUp = false; // To avoid compiler warning.
325
326            this->decrementSpawnsRemaining();
327        }
328    }
329
330    /**
331    @brief
332        Creates a new Pickupable.
333    @return
334        The Pickupable created.
335    */
336    Pickupable* PickupSpawner::getPickup(void)
337    {
338        if(this->spawnsRemaining_ == 0)
339        {
340            orxout(internal_error, context::pickups) << "Massive Error: PickupSpawner still alive until having spawned last item." << endl;
341            return NULL;
342        }
343
344        Pickupable* pickup = this->pickup_->clone();
345        return pickup;
346    }
347
348    /**
349    @brief
350        Invoked by the timer, re-activates the PickupSpawner.
351    */
352    void PickupSpawner::respawnTimerCallback()
353    {
354        orxout(verbose, context::pickups) << "PickupSpawner (&" << this << ") reactivated." << endl;
355
356        this->setActive(true);
357    }
358}
Note: See TracBrowser for help on using the repository browser.