Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/trunk/src/libraries/core/BaseObject.cc @ 8129

Last change on this file since 8129 was 7401, checked in by landauf, 14 years ago

merged doc branch back to trunk

  • Property svn:eol-style set to native
File size: 17.7 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 *      Fabian 'x3n' Landau
24 *   Co-authors:
25 *      ...
26 *
27 */
28
29/**
30    @file
31    @brief Implementation of the BaseObject class.
32*/
33
34#include "BaseObject.h"
35
36#include <tinyxml/tinyxml.h>
37
38#include "CoreIncludes.h"
39#include "Event.h"
40#include "EventIncludes.h"
41#include "Iterator.h"
42#include "Template.h"
43#include "XMLFile.h"
44#include "XMLNameListener.h"
45#include "XMLPort.h"
46#include "command/Functor.h"
47
48namespace orxonox
49{
50    CreateFactory(BaseObject);
51
52    /**
53        @brief Constructor: Registers the object in the BaseObject-list.
54    */
55    BaseObject::BaseObject(BaseObject* creator) : bInitialized_(false)
56    {
57        RegisterRootObject(BaseObject);
58
59        this->bInitialized_ = true;
60
61        this->bActive_ = true;
62        this->bVisible_ = true;
63        this->oldGametype_ = 0;
64        this->bRegisteredEventStates_ = false;
65
66        this->lastLoadedXMLElement_ = 0;
67
68        this->mainStateFunctor_ = 0;
69
70        this->setCreator(creator);
71        if (this->creator_)
72        {
73            this->setFile(this->creator_->getFile());
74            this->setNamespace(this->creator_->getNamespace());
75            this->setScene(this->creator_->getScene(), this->creator_->getSceneID());
76            this->setGametype(this->creator_->getGametype());
77            this->setLevel(this->creator_->getLevel());
78        }
79        else
80        {
81            this->file_ = 0;
82            this->namespace_ = 0;
83            this->scene_ = 0;
84            this->sceneID_ = OBJECTID_UNKNOWN;
85            this->gametype_ = 0;
86            this->level_ = 0;
87        }
88    }
89
90    /**
91        @brief Destructor
92    */
93    BaseObject::~BaseObject()
94    {
95        if (this->isInitialized())
96        {
97            for (std::map<BaseObject*, std::string>::const_iterator it = this->eventSources_.begin(); it != this->eventSources_.end(); )
98                this->removeEventSource((it++)->first);
99
100            for (std::set<BaseObject*>::const_iterator it = this->eventListeners_.begin(); it != this->eventListeners_.end(); )
101                (*(it++))->removeEventSource(this);
102
103            for (std::map<std::string, EventState*>::const_iterator it = this->eventStates_.begin(); it != this->eventStates_.end(); ++it)
104                delete it->second;
105        }
106    }
107
108    /** @brief Adds an object which listens to the events of this object. */
109    void BaseObject::registerEventListener(BaseObject* object)
110    {
111        COUT(4) << "New EventListener: " << object->getIdentifier()->getName() << " &(" << object << ")." << std::endl;
112        this->eventListeners_.insert(object);
113    }
114
115    /**
116        @brief XML loading and saving.
117        @param xmlelement The XML-element
118        @param mode The mode defines the operation that is being executed: loading or saving the object (from or to XML respectively)
119    */
120    void BaseObject::XMLPort(Element& xmlelement, XMLPort::Mode mode)
121    {
122        XMLPortParam(BaseObject, "name", setXMLName, getName, xmlelement, mode);
123        XMLPortParam(BaseObject, "visible", setVisible, isVisible, xmlelement, mode);
124        XMLPortParam(BaseObject, "active", setActive, isActive, xmlelement, mode);
125        XMLPortParam(BaseObject, "mainstate", setMainStateName, getMainStateName, xmlelement, mode);
126        XMLPortParamTemplate(BaseObject, "template", addTemplate, getSingleTemplate, xmlelement, mode, const std::string&);
127
128        XMLPortObjectTemplate(BaseObject, Template, "templates", addTemplate, getTemplate, xmlelement, mode, Template*);
129        XMLPortObject(BaseObject, BaseObject, "eventlisteners", addEventListener, getEventListener, xmlelement, mode);
130
131        Element* events = 0;
132        if (mode == XMLPort::LoadObject || mode == XMLPort::ExpandObject)
133            events = xmlelement.FirstChildElement("events", false);
134        else if (mode == XMLPort::SaveObject)
135            {}
136        if (events)
137            this->XMLEventPort(*events, mode);
138    }
139
140    /**
141        @brief Defines the possible event states of this object and parses eventsources from an XML file.
142        @param xmlelement The XML-element
143        @param mode The mode defines the operation that is being executed: loading or saving the object (from or to XML respectively)
144    */
145    void BaseObject::XMLEventPort(Element& xmlelement, XMLPort::Mode mode)
146    {
147        XMLPortEventState(BaseObject, BaseObject, "activity", setActive, xmlelement, mode);
148        XMLPortEventState(BaseObject, BaseObject, "visibility", setVisible, xmlelement, mode);
149        XMLPortEventState(BaseObject, BaseObject, "mainstate", setMainState, xmlelement, mode);
150
151        this->bRegisteredEventStates_ = true;
152    }
153
154    /**
155        @brief Loads the name of the object through XML and calls all XMLNameListener.
156        @param name The name of the object
157    */
158    void BaseObject::setXMLName(const std::string& name)
159    {
160        this->setName(name);
161
162        for (ObjectList<XMLNameListener>::iterator it = ObjectList<XMLNameListener>::begin(); it != ObjectList<XMLNameListener>::end(); ++it)
163            it->loadedNewXMLName(this);
164    }
165
166    /**
167        @brief Returns the levelfile that loaded this object.
168        @return The levelfile
169    */
170    const std::string& BaseObject::getFilename() const
171    {
172        if (this->file_)
173            return this->file_->getFilename();
174        else
175            return BLANKSTRING;
176    }
177
178    /**
179        @brief Adds a Template to the object.
180        @param name The name of the Template
181    */
182    void BaseObject::addTemplate(const std::string& name)
183    {
184        Template* temp = Template::getTemplate(name);
185        if (temp)
186            this->addTemplate(temp);
187        else
188            COUT(1) << "Error: \"" << name << "\" is not a valid Template name (in class: " << this->getIdentifier()->getName() << ", name: " << this->getName() << ")." << std::endl;
189    }
190
191    /**
192        @brief Adds a Template to the object.
193        @param temp The Template
194    */
195    void BaseObject::addTemplate(Template* temp)
196    {
197        this->templates_.insert(temp);
198        if( temp->isLink() )
199        {
200          this->networkTemplateNames_.insert(temp->getLink());
201          assert( !Template::getTemplate(temp->getLink())->isLink() );
202        }
203        else
204          this->networkTemplateNames_.insert(temp->getName());
205        temp->applyOn(this);
206    }
207
208    /**
209        @brief Returns the name of the first Template.
210        @return The name as string.
211    */
212    const std::string& BaseObject::getSingleTemplate(void) const
213    {
214        if(this->templates_.empty())
215            return BLANKSTRING;
216
217        return (*this->templates_.begin())->getName();
218    }
219
220    /**
221        @brief Returns the Template with the given index.
222        @param index The index
223    */
224    Template* BaseObject::getTemplate(unsigned int index) const
225    {
226        unsigned int i = 0;
227        for (std::set<Template*>::const_iterator it = this->templates_.begin(); it != this->templates_.end(); ++it)
228        {
229            if (i == index)
230                return (*it);
231            i++;
232        }
233        return 0;
234    }
235
236    /**
237        @brief Adds a new event source for a specific state.
238        @param source The object which sends events to this object
239        @param state The state of this object which will be affected by the events
240    */
241    void BaseObject::addEventSource(BaseObject* source, const std::string& state)
242    {
243        this->eventSources_[source] = state;
244        source->registerEventListener(this);
245    }
246
247    /**
248        @brief Removes an eventsource (but doesn't unregister itself at the source).
249    */
250    void BaseObject::removeEventSource(BaseObject* source)
251    {
252        this->eventSources_.erase(source);
253        source->unregisterEventListener(this);
254    }
255
256    /**
257        @brief Returns an eventsource with a given index.
258    */
259    BaseObject* BaseObject::getEventSource(unsigned int index, const std::string& state) const
260    {
261        unsigned int i = 0;
262        for (std::map<BaseObject*, std::string>::const_iterator it = this->eventSources_.begin(); it != this->eventSources_.end(); ++it)
263        {
264            if (it->second != state)
265                continue;
266
267            if (i == index)
268                return it->first;
269            ++i;
270        }
271        return 0;
272    }
273
274    /**
275        @brief Adds an object which listens to the events of this object. The events are sent to the other objects mainstate.
276    */
277    void BaseObject::addEventListener(BaseObject* listener)
278    {
279        this->eventListenersXML_.insert(listener);
280        listener->addEventSource(this, "mainstate");
281    }
282
283    /**
284        @brief Returns an event listener with a given index.
285    */
286    BaseObject* BaseObject::getEventListener(unsigned int index) const
287    {
288        unsigned int i = 0;
289        for (std::set<BaseObject*>::const_iterator it = this->eventListenersXML_.begin(); it != this->eventListenersXML_.end(); ++it)
290        {
291            if (i == index)
292                return *it;
293            ++i;
294        }
295        return 0;
296    }
297
298    /**
299        @brief Adds a new event-state to the object. Event-states are states which can be changed by events.
300        @param name  The name of the event
301        @param state The object containing information about the event-state
302    */
303    void BaseObject::addEventState(const std::string& name, EventState* state)
304    {
305        std::map<std::string, EventState*>::const_iterator it = this->eventStates_.find(name);
306        if (it != this->eventStates_.end())
307        {
308            COUT(2) << "Warning: Overwriting EventState in class " << this->getIdentifier()->getName() << '.' << std::endl;
309            delete (it->second);
310        }
311
312        this->eventStates_[name] = state;
313    }
314
315    /**
316        @brief Returns the event-state with the given name.
317    */
318    EventState* BaseObject::getEventState(const std::string& name) const
319    {
320        std::map<std::string, EventState*>::const_iterator it = this->eventStates_.find(name);
321        if (it != this->eventStates_.end())
322            return (it->second);
323        else
324            return 0;
325    }
326
327    /**
328        @brief Fires an event (without a state).
329    */
330    void BaseObject::fireEvent(const std::string& name)
331    {
332        this->fireEvent(true, name);
333        this->fireEvent(false, name);
334    }
335
336    /**
337        @brief Fires an event which activates or deactivates a state.
338    */
339    void BaseObject::fireEvent(bool activate, const std::string& name)
340    {
341        this->fireEvent(activate, this, name);
342    }
343
344    /**
345        @brief Fires an event which activates or deactivates a state with agiven originator (the object which triggered the event).
346    */
347    void BaseObject::fireEvent(bool activate, BaseObject* originator, const std::string& name)
348    {
349        Event event(activate, originator, name);
350
351        for (std::set<BaseObject*>::iterator it = this->eventListeners_.begin(); it != this->eventListeners_.end(); ++it)
352        {
353            event.statename_ = (*it)->eventSources_[this];
354            (*it)->processEvent(event);
355        }
356    }
357
358    /**
359        @brief Fires an event, using the Event struct.
360    */
361    void BaseObject::fireEvent(Event& event)
362    {
363        for (std::set<BaseObject*>::iterator it = this->eventListeners_.begin(); it != this->eventListeners_.end(); ++it)
364            (*it)->processEvent(event);
365    }
366
367    /**
368        @brief Processing an event by calling the right main state.
369        @param event The event struct which contains the information about the event
370    */
371    void BaseObject::processEvent(Event& event)
372    {
373        this->registerEventStates();
374
375        COUT(4) << this->getIdentifier()->getName() << " (&" << this << ") processing event. originator: " << event.originator_->getIdentifier()->getName() << " (&" << event.originator_ << "), activate: " << event.activate_ << ", name: " << event.name_ << ", statename: " << event.statename_ << "." << std::endl;
376
377        std::map<std::string, EventState*>::const_iterator it = this->eventStates_.find(event.statename_);
378        if (it != this->eventStates_.end())
379            it->second->process(event, this);
380        else if (!event.statename_.empty())
381            COUT(2) << "Warning: \"" << event.statename_ << "\" is not a valid state in object \"" << this->getName() << "\" of class " << this->getIdentifier()->getName() << "." << std::endl;
382        else
383            COUT(2) << "Warning: Event with invalid source sent to object \"" << this->getName() << "\" of class " << this->getIdentifier()->getName() << "." << std::endl;
384    }
385
386    /**
387        @brief Sets the main state of the object to a given boolean value.
388
389        Note: The main state of an object can be set with the @ref setMainStateName function.
390        It's part of the eventsystem and used for event forwarding (when the target object can't specify a specific state,
391        the main state is used by default).
392    */
393    void BaseObject::setMainState(bool state)
394    {
395        if (this->mainStateFunctor_)
396        {
397            if (this->mainStateFunctor_->getParamCount() == 0)
398            {
399                if (state)
400                    (*this->mainStateFunctor_)();
401            }
402            else
403            {
404                (*this->mainStateFunctor_)(state);
405            }
406        }
407        else
408            COUT(2) << "Warning: No MainState defined in object \"" << this->getName() << "\" (" << this->getIdentifier()->getName() << ")" << std::endl;
409    }
410
411    /**
412        @brief This function gets called if the main state name of the object changes.
413    */
414    void BaseObject::changedMainStateName()
415    {
416        this->mainStateFunctor_ = 0;
417
418        if (!this->mainStateName_.empty())
419        {
420            this->registerEventStates();
421
422            std::map<std::string, EventState*>::const_iterator it = this->eventStates_.find(this->mainStateName_);
423            if (it != this->eventStates_.end() && it->second->getFunctor())
424            {
425                if (it->second->getFunctor()->getParamCount() <= 1)
426                    this->mainStateFunctor_ = it->second->getFunctor();
427                else
428                    COUT(2) << "Warning: Can't use \"" << this->mainStateName_ << "\" as MainState because it needs a second argument." << std::endl;
429            }
430            else
431                COUT(2) << "Warning: \"" << this->mainStateName_ << "\" is not a valid MainState." << std::endl;
432        }
433    }
434
435    /**
436        @brief Calls XMLEventPort with an empty XML-element to register the event states if necessary.
437    */
438    void BaseObject::registerEventStates()
439    {
440        if (!this->bRegisteredEventStates_)
441        {
442            Element xmlelement;
443            this->XMLEventPort(xmlelement, XMLPort::NOP);
444        }
445    }
446
447    /**
448        @brief Manually loads all event states, even if the class doesn't officially support them. This is needed by some classes like @ref EventDispatcher or @ref EventTarget.
449    */
450    void BaseObject::loadAllEventStates(Element& xmlelement, XMLPort::Mode mode, BaseObject* object, Identifier* identifier)
451    {
452        Element* events = xmlelement.FirstChildElement("events", false);
453        if (events)
454        {
455            // get the list of all states present
456            std::list<std::string> eventnames;
457            if (mode == XMLPort::LoadObject || mode == XMLPort::ExpandObject)
458            {
459                for (ticpp::Iterator<ticpp::Element> child = events->FirstChildElement(false); child != child.end(); child++)
460                    eventnames.push_back(child->Value());
461            }
462            else if (mode == XMLPort::SaveObject)
463            {
464            }
465
466            // iterate through all states and get the event sources
467            for (std::list<std::string>::iterator it = eventnames.begin(); it != eventnames.end(); ++it)
468            {
469                const std::string& statename = (*it);
470
471                // if the event state is already known, continue with the next state
472                orxonox::EventState* eventstate = object->getEventState(statename);
473                if (eventstate)
474                    continue;
475
476                XMLPortClassObjectContainer<BaseObject, BaseObject>* container = (XMLPortClassObjectContainer<BaseObject, BaseObject>*)(identifier->getXMLPortObjectContainer(statename));
477                if (!container)
478                {
479                    const ExecutorMemberPtr<BaseObject>& setfunctor = createExecutor(createFunctor(&BaseObject::addEventSource), std::string( "BaseObject" ) + "::" + "addEventSource" + '(' + statename + ')');
480                    const ExecutorMemberPtr<BaseObject>& getfunctor = createExecutor(createFunctor(&BaseObject::getEventSource), std::string( "BaseObject" ) + "::" + "getEventSource" + '(' + statename + ')');
481                    setfunctor->setDefaultValue(1, statename);
482                    getfunctor->setDefaultValue(1, statename);
483
484                    container = new XMLPortClassObjectContainer<BaseObject, BaseObject>(statename, identifier, setfunctor, getfunctor, false, true);
485                    identifier->addXMLPortObjectContainer(statename, container);
486                }
487                container->port(object, *events, mode);
488            }
489        }
490    }
491}
Note: See TracBrowser for help on using the repository browser.