Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Changeset 11099


Ignore:
Timestamp:
Jan 27, 2016, 6:50:51 PM (4 years ago)
Author:
muemart
Message:

Fix loads of doxygen warnings and other documentation issues

Location:
code/trunk
Files:
90 edited

Legend:

Unmodified
Added
Removed
  • code/trunk/doc/api/doxy.config.in

    r10266 r11099  
    883883# of the generated HTML documentation.
    884884
    885 GENERATE_HTMLHELP      = YES
     885GENERATE_HTMLHELP      = NO
    886886
    887887# If the GENERATE_HTMLHELP tag is set to YES, the CHM_FILE tag can
  • code/trunk/doc/api/groups/Pickup.dox

    r8351 r11099  
    151151
    152152    @subsection CreatingTheInnerWorkings Creating the inner workings of your pickup
     153    @todo This is completely outdated. Someone who knows how pickups work should update this.
     154   
    153155    Now that we have the skeleton of a pickup and we have defined which carriers are allowed to pick our pickup up we are going to take a look at all the methods we can (or sometimes have to) overload from @ref orxonox::Pickupable "Pickupable", for our pickup to work properly. But first I will introduce some more concepts to make the need for these methods more obvious.
    154156    - Since one pickup class can by itself be many pickup types, we need a way to find out whether a particular instance of a pickup is of the same type as another instance of a pickup. To that end the @ref orxonox::PickupIdentifier "PickupIdentifier" was created. The @ref orxonox::PickupIdentifier "PickupIdentifier" accounts for the type of class your pickup is of and also for the parameters (and their values) that distinguish different types of pickups of the same class. Much of the functionality of the pickup module relies on this identifier being correct, thus it is very important to initialize it correctly. (We will see, how that is done in a short while.)
  • code/trunk/doc/api/groups/Portals.dox

    r9348 r11099  
    6060     - design: the name of the @ref orxonox::Template "design template"
    6161*/
    62 
    63 /**
    64     @addtogroup Pickup Pickup
    65     @ingroup Modules
    66 
    67     The Pickup module adds a special type of object to Orxonox, the so-called @ref orxonox::Pickupable "Pickupables". @ref orxonox::Pickupable "Pickupables" are objects that can be picked up (by virtually any entity, but commonly by the @ref orxonox::Pawn "Pawn") and have some kind of effect on the entity that picked the @ref orxonox::Pickupable "Pickupable" up.
    68 
    69     @section IncludingPickups Including pickups in a level
    70     @ref orxonox::Pickupable "Pickupables" are designed so that they can be included in levels fairly easily, while also ensuring, that the pickup itself (its game-logic component) and how it is represented (e.g. in the PickupInventory (the GUI that displays @ref orxonox::Pickupable "Pickupables") or in the game) are neatly seperated.
    71     To be able to use @ref orxonox::Pickupable "Pickupables" in a level one must understand some basic concepts.
    72     - @ref orxonox::Pickupable "Pickupables" are entities which (by itself) have no physical (or graphical) dimension. The simply represent the effect they will have on a @ref orxonox::PickupCarrier "PickupCarrier" (the entity that can pick up @ref orxonox::Pickupable "Pickupables", @ref orxonox::Pawn "Pawn" for example inherits from @ref orxonox::PickupSpawner "PickupSpawner" and thus is able to pick up and carry @ref orxonox::Pickupable "Pickupables"), when used and the mechanism that leads to that.
    73     - The physical (or graphical) dimension of a pickup is called a @ref orxonox::PickupRepresentation "PickupRepresentation".
    74     - The @ref orxonox::PickupRepresentation "PickupRepresentation" of a @ref orxonox::Pickupable "Pickupable" and the @ref orxonox::Pickupable "Pickupable" itself are linked to each other, in such a way that a @ref orxonox::PickupRepresentation "PickupRepresentation" can only represent one type of @ref orxonox::Pickupable "Pickupable".
    75     - A type of @ref orxonox::Pickupable "Pickupable" is a specific pickup class (inheriting from @ref orxonox::Pickupable "Pickupable") with specific values for all its relevant parameters. This means, that a pickup of the same class with the same values for all parameters except for one is a different type of pickup and will therefore have a different @ref orxonox::PickupRepresentation "PickupRepresentation". Which parameters are the ones relevant to destinguish between two types of pickups can be defined in the class description of the specific pickup.
    76     - The entity that actually gives a @ref orxonox::Pickupable "Pickupable" to a @ref orxonox::PickupCarrier "PickupCarrier" is called a @ref orxonox::PickupSpawner "PickupSpawner". A @ref orxonox::PickupSpawner "PickupSpawner" creates (based on some parameters) @ref orxonox::Pickupable "Pickupables" which then is picked up by the @ref orxonox::PickupCarrier "PickupCarrier", that caused the @ref orxonox::PickupSpawner "PickupSpawner" to spawn a new pickup. How the spawner looks in the game is defined by the @ref orxonox::PickupRepresentation "PickupRepresentation" of the @ref orxonox::Pickupable "Pickupable" it spawns.
    77 
    78     @subsection UsingPredifinedPickups Using predefined pickups
    79     There is a file called <code>pickupRepresentationTemplates.oxt</code> in <code>levels/templates</code>, which holds the templates for the @ref orxonox::PickupRepresentation "PickupRepresentations" and also templates for @ref orxonox::Pickupable "Pickupables". The templates for the @ref orxonox::PickupRepresentation "PickupRepresentations" define the @ref orxonox::StaticEntity "StaticEntities" that are attached to the @ref orxonox::PickupSpawner "PickupSpawners" to make them look like the @ref orxonox::Pickupable "Pickupable" they are spawning. The templates for the @ref orxonox::Pickupable "Pickupables" can be added just for ease of use.
    80     If you want to use pickups you will have to include this file in your level file, somewhere above the Level-tag.
    81     @code
    82     <?lua
    83         include("templates/pickupRepresentationTemplates.oxt")
    84     ?>
    85     ...
    86     <Level>
    87     ...
    88     @endcode
    89     There is another file called <code>pickups.oxi</code> in <code>level/includes</code> which creates all @ref orxonox::PickupRepresentation "PickupRepresentations" needed for the @ref orxonox::Pickupable "Pickupable" supplied by the <code>pickupRepresentationTemplates.oxt</code> file. This file will have to be included as well. It has to be somewhere after the opening Scene-tag and your first use of a pickup.
    90     @code
    91     <Scene>
    92     ...
    93     <?lua
    94         include("includes/pickups.oxi")
    95     ?>
    96     @endcode
    97     After that all the predefined pickups specified in those two files can be used just by creating a @ref orxonox::PickupSpawner "PickupSpawner" for them in the respective level.
    98     For example:
    99     @code
    100     <PickupSpawner position="-100,0,-100" respawnTime="30" maxSpawnedItems="10">
    101         <pickup>
    102             <HealthPickup
    103                 health = 10
    104                 healthType = "limited"
    105                 activationType = "immediate"
    106                 durationType = "once"
    107             />
    108         </pickup>
    109     </PickupSpawner>
    110     @endcode
    111     Please be aware, that the @ref orxonox::Pickupable "Pickupable" specified for the @ref orxonox::PickupSpawner "PickupSpawner", has to be exactly the same (including all parameters) to the one specified in the <code>pickups.oxi</code> file.
    112     To make things simpler, one could just use the templates specified in the <code>pickupRepresentationTemplates.oxt</code> file. Which, following the previous example, would look like this:
    113     @code
    114     <PickupSpawner position="-100,0,-100" respawnTime="30" maxSpawnedItems="10">
    115         <pickup>
    116             <HealthPickup template="smallhealthpickup" />
    117         </pickup>
    118     </PickupSpawner>
    119     @endcode
    120 
    121     @subsection UnsingNon-PredefinedPickups Using non-predefined pickups
    122     To include a type of pickup (which, as we remember, is the class of the @ref orxonox::Pickupable "Pickupable" with specific values for all the relevant parameters) in a level file, you can just create a new @ref orxonox::PickupSpawner "PickupSpawner" and specify the @ref orxonox::Pickupable "Pickupable".
    123     @code
    124     <PickupSpawner position="-100,0,-100" respawnTime="30" maxSpawnedItems="10">
    125     <pickup>
    126         <HealthPickup
    127             health = 33
    128             healthType = "limited"
    129             activationType = "immediate"
    130             durationType = "once"
    131         />
    132     </pickup>
    133     </PickupSpawner>
    134     @endcode
    135     As can be seen in the <code>pickupRepresentationTemplates.oxt</code> file and the <code>pickups.oxi</code> file there is no @ref orxonox::PickupRepresentation "PickupRepresentation" defined for this type of pickup. Thus the default representation will be used.
    136 
    137     To create an appropriate @ref orxonox::PickupRepresentation "PickupRepresentation" for the inserted pickup above, you can just create a @ref orxonox::PickupRepresentation "PickupRepresentation" within the scene (Within the Scene-tags).
    138     @code
    139     <PickupRepresentation
    140         name = "My new health pickup"
    141         description = "This is an awesome new health pickup."
    142         spawnerTemplate = "mediumhealthpickupRepresentation"
    143         inventoryRepresentation = "MediumHealth"
    144     >
    145         <pickup>
    146             <HealthPickup
    147             health = 33
    148             healthType = "limited"
    149             activationType = "immediate"
    150             durationType = "once"
    151         />
    152         </pickup>
    153     </PickupRepresentation>
    154     @endcode
    155     Notice, that the type of pickup specified for the @ref orxonox::PickupRepresentation "PickupRepresentation", naturally, needs to be the same (this is the way they can be connected). Also, we just used an existing <em>spawnerTemplate</em>, to make things simpler.
    156 
    157     The next step is to create a <em>spawnerRepresentation</em> uniquely for our new type of pickup. Lets call it <code>newhealthpickupRepresentation</code>. Thus the parameter <em>spawnerTemplate</em> of the @ref orxonox::PickupRepresentation "PickupRepresentation" has to be changed to that value.
    158     @code
    159     spawnerTemplate = "newhealthpickupRepresentation"
    160     @endcode
    161     The <em>spawnerTemplate</em> defines how the @ref orxonox::PickupSpawner "PickupSpawner" is displayed in a level.
    162     In our example case it could look like this:
    163     @code
    164     <Template name=newhealthpickupRepresentation>
    165         <PickupRepresentation>
    166             <spawner-representation>
    167                 <StaticEntity>
    168                     <attached>
    169                         -- Here you can put all the objects which define the look of the spawner. --
    170                     </attached>
    171                 </StaticEntity>
    172             </spawner-representation>
    173         </PickupRepresentation>
    174     </Template>
    175     @endcode
    176     Please refer to the <code>pickupRepresentationTemplates.oxt</code> for more examples.
    177 
    178     The @ref orxonox::PickupRepresentation "PickupRepresentation" also needs another parameter the <em>inventoryRepresentation</em>. This parameter defined how the @ref orxonox::Pickupable "Pickupable" is displayed in the PickupInventory (a menu to browse the currently equipped pickups).
    179     @code
    180     inventoryRepresentation = "MediumHealth"
    181     @endcode
    182     This is the name of an image defined in the PickupInventory imageset (<code>PickupInventory.imageset</code>), which can be found in <code>data_extern/gui/imagesets</code>.
    183 
    184     This is all that has to be done. Now you have a new pickup type with an appropriate @ref orxonox::PickupRepresentation "PickupRepresentation" for your use. If you feel that your pickup is useful in general, please don't hesitate to create a template for the pickup and add your pickup to the <code>pickupRepresentationTemplates.oxt</code> file and the <code>pickups.oxi</code> file, so that anyone who wants to use it can do so quite easily.
    185 
    186     There is also an additional way to create new types of pickups to be used in a level (without having to do any coding). There is a @ref orxonox::Pickupable "Pickupable" called the @ref orxonox::PickupCollection "PickupCollection", which is just a collection (hence the name) of @ref orxonox::Pickupable "Pickupables" (more precisely of @ref orxonox::CollectiblePickup "CollectiblePickups"), behaving as if it was just one @ref orxonox::Pickupable "Pickupable".
    187     A @ref orxonox::PickupCollection "PickupCollection" can be created as follows:
    188     @code
    189     <PickupCollection>
    190         <pickupables>
    191             -- some pickups you want to have in your collection, e.g. --
    192             <HealthPickup template=smallhealthpickup />
    193             <HealthPickup health=50 healthRate=5 durationType=continuous activationType=immediate healthType=limited />
    194         </pickupables>
    195     </PickupCollection>
    196     @endcode
    197     Of which types of pickups a collection is made up is entirely up to the one creating the @ref orxonox::PickupCollection "PickupCollection", they can be mixed freely.
    198 
    199     @section CreatingAPickup Creating a new pickup
    200     Things have been fairly straightforward so far. Creating a @ref orxonox::Pickupable "Pickupable" form scratch isn't as easy. Therefore I'm just going to supply you with a recipe, or a set of steps you have to take, without which your pickup won't work and point out some common pitfalls.
    201 
    202     @subsection CreatingAPickupClass Creating the class
    203     For a new @ref orxonox::Pickupable "Pickupable" you need to create a new class in <code>>modules/pickup/items</code>. Your class needs to be derived from another pickup class, normally this would either be @ref orxonox::Pickupable "Pickupable", @ref orxonox::CollectiblePickup "CollectiblePickup" or @ref orxonox::Pickup "Pickup". @ref orxonox::Pickupable "Pickupable" is (as mentioned earlier) the base class of all things that can be picked up, thus of all pickups. @ref orxonox::CollectiblePickup "CollectiblePickup" is a (directly) derived class of @ref orxonox::Pickupable  "Pickupable" and provides the additional functionality of enabling your pickup to be used in a @ref orxonox::PickupCollection "PickupCollection". However you are probably going to want to derive your class form @ref orxonox::Pickup "Pickup", because it is a @ref orxonox::CollectiblePickup "CollectiblePickup" and provides some useful methods. So have a look at @ref orxonox::Pickup "Pickup".
    204     Once you have created your new pickup class you have to insert it in the <code>PickupPrereqs.h</code> file in the <code>modules/pickup</code> folder and in the <code>CMakeList.txt</code> file in the <code>modules/pickup/items</code> folder. Also have a look at other pickups to make sure you include all the necessary files in your class.
    205 
    206     @subsection ChoosingTheCarriers Coosing the carriers
    207     You also have to choose the entities that are allowed to pick your pickup up. After you have chosen the entity that carries your pickup, you need to do the following.
    208     - The enity that carries your pickup needs to be derived from the @ref orxonox::PickupCarrier "PickupCarrier" interface. And you need to implement the @ref orxonox::PickupCarrier "PickupCarriers'" virtual functions <code>getCarrierChildren()</code> and <code>getCarrierParent()</code>. These tow methods are needed, because all pickups are initially picked up by a @ref orxonox::Pawn "Pawn" and then handed down to the entity that effectively carries them. With the above mentioned two function just that is accomplished. A hierarchical structure is established with one parent and a set of children, where the @ref orxonox::Pawn "Pawn" is the root node of this hierarchical structure, the only entity with no parent.
    209     - Once you have done that you will also want to specify in your pickup which carriers can pick it up, this is done via the <code>addTarget()</code> function. So you have to make sure the target is added whenever one of your pickups is created (so, most conveniently somewhere in the constructor), with the following command.
    210     @code
    211     this->addTarget(ClassIdentifier<MyCarrierClass>::getIdentifier());
    212     @endcode
    213 
    214     @subsection CreatingTheInnerWorkings Creating the inner workings of your pickup
    215     Now that we have the skeleton of a pickup and we have defined which carriers are allowed to pick our pickup up we are going to take a look at all the methods we can (or sometimes have to) overload from @ref orxonox::Pickupable "Pickupable", for our pickup to work properly. But first I will introduce some more concepts to make the need for these methods more obvious.
    216     - Since one pickup class can by itself be many pickup types, we need a way to find out whether a particular instance of a pickup is of the same type as another instance of a pickup. To that end the @ref orxonox::PickupIdentifier "PickupIdentifier" was created. The @ref orxonox::PickupIdentifier "PickupIdentifier" accounts for the type of class your pickup is of and also for the parameters (and their values) that distinguish different types of pickups of the same class. Much of the functionality of the pickup module relies on this identifier being correct, thus it is very important to initialize it correctly. (We will see, how that is done in a short while.)
    217     - Every @ref orxonox::Pickupable "Pickupable" has at least two states which are very important. The first is, whether the @ref orxonox::Pickupable "Pickupable" is currently in use or not and the second is whether the pickup is currently picked up or not.
    218 
    219     Let's have a look at the important methods.
    220     - <b>changedUsed()</b> The <code>changedUsed()</code> method is called whenever the state of the @ref orxonox::Pickupable "Pickupable" transits from being used to not being used or the other way around. Which means this method is probably the most important method you have at your fingertips, since it enables you to apply the effect of your pickup when it gets used and remove the effect as soon as it is no longer in use.
    221     - <b>changedPickedUp()</b> The <code>changedPickedUp()</code> method is called whenever the state of the @ref orxonox::Pickupable "Pickupable" changes from being picked up to not being picked up or the other way around. For example if you want your pickup to be used as soon as it is picked up, this is the method you have to overload to achieve that behavior (or just let your pickup be derived from @ref orxonox::Pickup "Pickup", which implements exactly that behavior, if the <em>activationType</em> is set to <em>immediate</em>). You don't have to concern yourself with destroying the pickup or creating a spawner when it changes to not picked up, since that is already implemented with the @ref orxonox::Pickupable "Pickupable" and @ref orxonox::PickupCarrier "PickupCarrier" classes. If you want a different behavior, however, once again, this is the method.
    222     - <b>changedCarrier()</b> The <code>changedCarrier()</code> method is called whenever the carrier of the @ref orxonox::Pickupable "Pickupable" changes. And by that I don't mean the class that is allowed to carry the pickup, but the object that actually carries (or carried) the pickup. Please do not overload this class to implement behavior for picked up -> not picked up transitions, use <code>changedPickedUp()</code> for that. For most pickup classes this method doesn't need to be overloaded. Where it is used, however is in the @ref orxonox::PickupCollection "PickupCollection" class, where the new carrier needed to be communicated to all pickups the collection consists of, whenever the carrier was changed.
    223 
    224     Please be aware, that these three methods are methods registered with @ref Super.h "Super", meaning, that whenever overloading them, don't forget to call <code>SUPER(MyClass, myMethod);</code>.
    225     Also when implementing the above methods you should think of what should happen in unexpected situations, e.g. when your pickup is unused manually and set to used again.
    226     Additionally you should use the <code>destroy()</code> method of Pickupable instead of the method provided by @ref orxonox::OrxonoxClass "OrxonoxClass", meaning <code>Pickupable::destroy()</code> instead of plain <code>destroy()</code>.
    227 
    228     - <b>clone()</b> The <code>clone()</code> method creates a new pickup of the same type as the pickup it is cloned from. So the cloned pickup is not exactly the same, as it doesn't necessarily completely reflect the status of the pickup it is cloned from, but it reflects all the parameters and their values, that distinguish different types of this pickup class. It needs to be implemented by every pickup class. And it is best if this is done in a very specific way. Below is shown how:
    229     @code
    230     void MyPickup::clone(OrxonoxClass*& item)
    231     {
    232         if(item == NULL)
    233             item = new MyPickup(this);
    234 
    235         SUPER(MyPickup, clone, item);
    236 
    237         MyPickup* pickup = dynamic_cast<MyPickup*>(item);
    238         // Here you should set all the important parameters (that distinguish the different types of this pickup), e.g.
    239         pickup->setSomeParameter(this->getSomeParameter());
    240         // You must also initialize the identifier of the new pickup, this is normally done in a member function called in
    241         pickup->initializeIdentifier();
    242     }
    243     @endcode
    244     - <b>initializeIdentifier()</b> The <code>initializeIdentifier()</code> method initializes (or more simply put, creates) the @ref orxonox::PickupIdentifier "PickupIdentifier" of the instance of your pickup. Since the important values of the parameters are not yet available in the constructor of your pickup this <code>initializeIdentifier()</code> method must be called as soon as they are available, which normally is in the <code>XMLPort()</code> method, and the <code>clone()</code> method, as seen above. In the <code>initializeIdentifier()</code> method you need to register each parameter that is important for the type of your pickup to its identifier, this is normally done as follows:
    245     @code
    246     void Pickup::initializeIdentifier(void)
    247     {
    248         // If the get method returns a string.
    249         std::string val1 = this->getSomeParameter();
    250         std::string type1 = "someParameter";
    251         this->pickupIdentifier_->addParameter(type1, val1);
    252         // If the get method doesn't return a string
    253         std::stringstream stream;
    254         stream << this->getSomeOtherParameter();
    255         std::string type2 = "someOtherParameter";
    256         std::string val2 = stream.str();
    257         this->pickupIdentifier_->addParameter(type2, val2);
    258     }
    259     @endcode
    260 
    261     Be aware, this only works for parameters that are simple enough, meaning with pointers for example it will, naturally, not work, and other ways must be found (this is for example done in @ref orxonox::PickupCollection "PickupCollection" with a derived class of the @ref orxonox::PickupIdentifier "PickupIdentifier", the @ref orxonox::PickupCollectionIdentifier "PickupCollectionIdentifier") or in the @ref orxonox::DronePickup "DronePickup" class by using a @ref orxonox::Template "Template".
    262     - <b>createSpawner()</b> The <code>createSpawner()</code> method needs to be implemented by any pickup directly inheriting from @ref orxonox::Pickupable "Pickupable" (or directly from @ref orxonox::CollectiblePickup "CollectiblePickup"), so if you inherit from @ref orxonox::Pickup "Pickup", you don't need to implement this. It is used to create a @ref orxonox::PickupSpawner "PickupSpawner", when the pickup is dropped. A standard implementation would look like this.
    263     @code
    264     bool MyPickup::createSpawner(void)
    265     {
    266         new DroppedPickup(this, this, this->getCarrier());
    267         return true;
    268     }
    269     @endcode
    270 
    271     @section PickupTechnicalDetails Technical details
    272 
    273     @image html pickupmodule.png
    274 */
    275 
    276 /**
    277     @defgroup PickupItems Items
    278     @ingroup Pickup
    279 
    280     The actual pickups can be found here.
    281 */
  • code/trunk/src/libraries/core/CoreIncludes.h

    r11071 r11099  
    125125    @brief Registers the class in the framework with a given Factory.
    126126    @param ClassName The name of the class
     127    @param FactoryInstance An instance of a factory that can create the class
     128    @param bLoadable Whether the class is allowed to be loaded through XML
    127129*/
    128130#define RegisterClassWithFactory(ClassName, FactoryInstance, bLoadable) \
     
    201203        @note This of course only works with Identifiables.
    202204              The only use is in conjunction with macros that don't know the class type.
    203         @param object Pointer to an Identifiable
     205        @param p Pointer to an Identifiable
    204206    */
    205207    template <class T>
    206     inline Identifier* ClassByObjectType(const T*)
     208    inline Identifier* ClassByObjectType(const T* p)
    207209    {
    208210        return ClassIdentifier<T>::getIdentifier();
  • code/trunk/src/libraries/core/GUIManager.cc

    r11083 r11099  
    793793    }
    794794
    795     /** Executes a CEGUI function normally, but catches CEGUI::ScriptException.
     795    /**
     796    @copydoc protectedCeguiSystemCall
     797    @param function
     798        Any callable object/function that takes one parameter.
     799    @param object
     800        Object to be used as an argument for the @p function
     801    @return
     802        True if input was handled, false otherwise. A caught exception yields true.
     803    */
     804    template <typename FunctionType, typename ObjectType>
     805    bool GUIManager::protectedCall(FunctionType function, ObjectType object)
     806    {
     807        try
     808        {
     809            return function(object);
     810        }
     811        catch (CEGUI::ScriptException& ex)
     812        {
     813            // Display the error and proceed. See @remarks why this can be dangerous.
     814            orxout(internal_error) << ex.getMessage() << endl;
     815            return true;
     816        }
     817    }
     818
     819    /**
     820        Executes a CEGUI function normally, but catches CEGUI::ScriptException.
    796821        When a ScriptException occurs, the error message will be displayed and
    797822        the program carries on.
     
    808833        True if input was handled, false otherwise. A caught exception yields true.
    809834    */
    810     template <typename FunctionType, typename ObjectType>
    811     bool GUIManager::protectedCall(FunctionType function, ObjectType object)
    812     {
    813         try
    814         {
    815             return function(object);
    816         }
    817         catch (CEGUI::ScriptException& ex)
    818         {
    819             // Display the error and proceed. See @remarks why this can be dangerous.
    820             orxout(internal_error) << ex.getMessage() << endl;
    821             return true;
    822         }
    823     }
    824 
    825835    template <typename FunctionType>
    826836    bool GUIManager::protectedCeguiSystemCall(FunctionType function)
  • code/trunk/src/libraries/core/class/IdentifierManager.cc

    r11071 r11099  
    255255    /**
    256256        @brief Returns the Identifier with a given typeid-name.
    257         @param name The typeid-name of the wanted Identifier
     257        @param typeInfo The type_info of the wanted Identifier
    258258        @return The Identifier
    259259    */
  • code/trunk/src/libraries/core/command/CommandExecutor.cc

    r11071 r11099  
    6767        @param command A string containing the command
    6868        @param useTcl If true, the command is passed to tcl (see TclBind)
     69        @param printErrors If true, print an error when command failed
    6970        @return Returns the error-code (see @ref CommandExecutorErrorCodes "error codes")
    7071    */
  • code/trunk/src/libraries/core/command/ConsoleCommandCompilation.cc

    r10624 r11099  
    100100        @brief Prints text to the console.
    101101        @param level_name The name of the output level
     102        @param text The text to print
    102103    */
    103104    void orxout_level(const std::string& level_name, const std::string& text)
     
    119120        @param level_name The name of the output level
    120121        @param context_name The name of the output context
     122        @param text The text to print
    121123    */
    122124    void orxout_level_context(const std::string& level_name, const std::string& context_name, const std::string& text)
  • code/trunk/src/libraries/core/commandline/CommandLineIncludes.h

    r11071 r11099  
    3030    @defgroup CmdArgs Commandline arguments
    3131    @ingroup Config
    32     @brief For a reference of all commandline arguments see @ref cmdargspage
    3332*/
    3433
  • code/trunk/src/libraries/core/commandline/CommandLineParser.cc

    r11071 r11099  
    218218    @param value
    219219        String containing the value
    220     @param bParsingFile
    221         Parsing a file or the command line itself
    222220    */
    223221    void CommandLineParser::checkFullArgument(const std::string& name, const std::string& value)
     
    237235    @param value
    238236        String containing the value
    239     @param bParsingFile
    240         Parsing a file or the command line itself
    241237    */
    242238    void CommandLineParser::checkShortcut(const std::string& shortcut, const std::string& value)
  • code/trunk/src/libraries/core/commandline/CommandLineParser.h

    r11071 r11099  
    2626 *
    2727 */
    28 
    29 /**
    30     @defgroup CmdArgs Commandline arguments
    31     @ingroup Config
    32     @brief For a reference of all commandline arguments see @ref cmdargspage
    33 */
    3428
    3529/**
  • code/trunk/src/libraries/core/config/ConfigValueContainer.h

    r11071 r11099  
    109109            */
    110110            template <class D, class V>
    111             ConfigValueContainer(ConfigFileType::Value type, Identifier* identifier, const std::string& sectionname, const std::string& varname, const D& defvalue, const V&)
     111            ConfigValueContainer(ConfigFileType::Value type, Identifier* identifier, const std::string& sectionname, const std::string& varname, const D& defvalue, const V& value)
    112112            {
    113113                this->init(type, identifier, sectionname, varname);
     
    125125            */
    126126            template <class D, class V>
    127             ConfigValueContainer(ConfigFileType::Value type, Identifier* identifier, const std::string& sectionname, const std::string& varname, const std::vector<D>& defvalue, const std::vector<V>&)
     127            ConfigValueContainer(ConfigFileType::Value type, Identifier* identifier, const std::string& sectionname, const std::string& varname, const std::vector<D>& defvalue, const std::vector<V>& value)
    128128            {
    129129                this->init(type, identifier, sectionname, varname);
  • code/trunk/src/libraries/core/object/IteratorBase.h

    r11071 r11099  
    173173            /**
    174174                @brief Increments the Iterator if it points at the given element.
    175                 @param object The object to compare with
     175                @param element The element to compare with
    176176            */
    177177            virtual void removedElement(ObjectListBaseElement* element) override
  • code/trunk/src/libraries/core/object/ObjectListBase.h

    r11071 r11099  
    5555            /**
    5656                @brief Constructor: Creates the list-element with an object.
    57                 @param objectBase The object to store
     57                @param object The object to store
    5858            */
    5959            ObjectListBaseElement(Listable* object) : next_(nullptr), prev_(nullptr), objectBase_(object), list_(nullptr) {}
  • code/trunk/src/libraries/network/MasterServerComm.h

    r8858 r11099  
    8888      int sendRequest( std::string data );
    8989
    90       /** \param callback The callback function to call with data received.
     90      /** \param listener The listener to call with data received.
    9191       *  \param delayms Delay in milliseconds.
    9292       * \return 0 for success, other for error
  • code/trunk/src/libraries/network/ServerList.h

    r10622 r11099  
    7474      /* BASIC MANIPULATION */
    7575      /** \param toadd the server to add.
     76       *  \param peer the peer
    7677       *
    7778       * Add server to the game server list
  • code/trunk/src/libraries/tools/BulletDebugDrawer.cc

    r10277 r11099  
    11/**
     2 * @file BulletDebugDrawer.cc
    23 * Originally from http://www.ogre3d.org/tikiwiki/BulletDebugDrawer&structure=Cookbook
    34 * This source code is released into the Public Domain.
  • code/trunk/src/libraries/tools/BulletDebugDrawer.h

    r11071 r11099  
    1 /**
    2  * Originally from http://www.ogre3d.org/tikiwiki/BulletDebugDrawer&structure=Cookbook
    3  * This source code is released into the Public Domain.
    4  *
    5  * Modified by Fabian 'x3n' Landau by using DebugDrawer and Orxonox specific utilities (e.g. output).
    6  */
    7 
    81#ifndef _BulletDebugDrawer_H__
    92#define _BulletDebugDrawer_H__
     
    1811namespace orxonox
    1912{
     13    /**
     14    * Originally from http://www.ogre3d.org/tikiwiki/BulletDebugDrawer&structure=Cookbook
     15    * This source code is released into the Public Domain.
     16    *
     17    * Modified by Fabian 'x3n' Landau by using DebugDrawer and Orxonox specific utilities (e.g. output).
     18    */
    2019    class _ToolsExport BulletDebugDrawer : public btIDebugDraw, public Ogre::FrameListener
    2120    {
  • code/trunk/src/libraries/tools/DebugDrawer.cc

    r11071 r11099  
    11/**
     2 * @file DebugDrawer.cc
    23 * Copy-pasted from
    34 *  - https://bitbucket.org/hasyimi/ogre-debug-drawing-utility/src
  • code/trunk/src/libraries/tools/DebugDrawer.h

    r10262 r11099  
    11/**
     2 * @file DebugDrawer.h
    23 * Copy-pasted from
    34 *  - https://bitbucket.org/hasyimi/ogre-debug-drawing-utility/src
     
    910 */
    1011
    11 /**
    12  * @file
    13  * @brief DebugDrawer is a utility to draw debug shapes (lines, triangles, spheres) with Ogre.
    14  * This utility is e.g. used by @ref BulletDebugDrawer to visualize collision shapes and other physical entities.
    15  */
     12
    1613
    1714#ifndef _DebugDrawer_H__
     
    2623namespace orxonox
    2724{
     25    /**
     26     * @brief DebugDrawer is a utility to draw debug shapes (lines, triangles, spheres) with Ogre.
     27     * This utility is e.g. used by @ref orxonox::BulletDebugDrawer to visualize collision shapes and other physical entities.
     28     */
    2829    class _ToolsExport DebugDrawer
    2930    {
  • code/trunk/src/libraries/tools/IcoSphere.cc

    r11071 r11099  
    11/**
     2 * @file IcoSphere.cc
    23 * Copy-pasted from
    34 *  - https://bitbucket.org/hasyimi/ogre-debug-drawing-utility/src
  • code/trunk/src/libraries/tools/IcoSphere.h

    r10262 r11099  
    1 /**
    2  * Copy-pasted from
    3  *  - https://bitbucket.org/hasyimi/ogre-debug-drawing-utility/src
    4  *  - http://www.ogre3d.org/tikiwiki/tiki-index.php?page=Debug+Drawing+Utility+Class
    5  *
    6  * This source code is released into the Public Domain.
    7  *
    8  * Modified by Fabian 'x3n' Landau
    9  */
    101
    11 /**
    12  * @file
    13  * @brief DebugDrawer is a utility to draw debug shapes (lines, triangles, spheres) with Ogre.
    14  * This utility is e.g. used by @ref BulletDebugDrawer to visualize collision shapes and other physical entities.
    15  */
    162
    173#ifndef _IcoSphere_H__
     
    2713    typedef std::pair<Ogre::Vector3, Ogre::ColourValue> VertexPair;
    2814
     15    /**
     16    * Copy-pasted from
     17    *  - https://bitbucket.org/hasyimi/ogre-debug-drawing-utility/src
     18    *  - http://www.ogre3d.org/tikiwiki/tiki-index.php?page=Debug+Drawing+Utility+Class
     19    *
     20    * This source code is released into the Public Domain.
     21    *
     22    * Modified by Fabian 'x3n' Landau
     23    */
    2924    class _ToolsExport IcoSphere
    3025    {
  • code/trunk/src/libraries/tools/OgreBulletUtils.h

    r11071 r11099  
    11/**
     2 * @file OgreBulletUtils.h
    23 * Copy-pasted from http://www.ogre3d.org/tikiwiki/BulletDebugDrawer&structure=Cookbook
    34 * This source code is released into the Public Domain.
  • code/trunk/src/libraries/util/Clock.h

    r11071 r11099  
    5454        caveat because it will only capture the time on the same CPU core.
    5555        Confining the main thread to one process could speed up the game.
    56         See \ref cmdargspage "Ccommandline Argument" 'limitToCPU' (only on Windows)
    5756    */
    5857    class _UtilExport Clock
  • code/trunk/src/libraries/util/Math.cc

    r11071 r11099  
    291291    /**
    292292                @brief Gets the new vector after a coordinate transformation
    293                 @param distance Vector which will be transformed
    294                 @param mydirection New x basevector
    295                 @param myorthonormal New y basevector
    296                 @param otherposition New z basevector
    297                 @return direction in the new coordinates
     293                @param totransform Vector which will be transformed
     294                @param newx New x basevector
     295                @param newy New y basevector
     296                @param newz New z basevector
     297                @return Vector in the new coordinates
    298298
    299299                x is vector in old coordinates
     
    307307                y = T^(-1)*x
    308308            */
    309     orxonox::Vector3 getTransformedVector(const orxonox::Vector3& distance, const orxonox::Vector3& mydirection, const orxonox::Vector3& myorthonormal, const orxonox::Vector3& myside)
     309    orxonox::Vector3 getTransformedVector(const orxonox::Vector3& totransform, const orxonox::Vector3& newx, const orxonox::Vector3& newy, const orxonox::Vector3& newz)
    310310    {
    311311        // inverse of the transform matrix
    312         float determinant = +mydirection.x * (myorthonormal.y*myside.z - myside.y*myorthonormal.z)
    313                             -mydirection.y * (myorthonormal.x*myside.z - myorthonormal.z*myside.x)
    314                             +mydirection.z * (myorthonormal.x*myside.y - myorthonormal.y*myside.x);
     312        float determinant = +newx.x * (newy.y*newz.z - newz.y*newy.z)
     313                            -newx.y * (newy.x*newz.z - newy.z*newz.x)
     314                            +newx.z * (newy.x*newz.y - newy.y*newz.x);
    315315        float invdet = 1/determinant;
    316316
     
    320320        orxonox::Vector3 zinvtransform;
    321321
    322         xinvtransform.x = (myorthonormal.y * myside.z        - myside.y        * myorthonormal.z)*invdet;
    323         xinvtransform.y = (mydirection.z   * myside.y        - mydirection.y   * myside.z       )*invdet;
    324         xinvtransform.z = (mydirection.y   * myorthonormal.z - mydirection.z   * myorthonormal.y)*invdet;
    325         yinvtransform.x = (myorthonormal.z * myside.x        - myorthonormal.x * myside.z       )*invdet;
    326         yinvtransform.y = (mydirection.x   * myside.z        - mydirection.z   * myside.x       )*invdet;
    327         yinvtransform.z = (myorthonormal.x * mydirection.z   - mydirection.x   * myorthonormal.z)*invdet;
    328         zinvtransform.x = (myorthonormal.x * myside.y        - myside.x        * myorthonormal.y)*invdet;
    329         zinvtransform.y = (myside.x        * mydirection.y   - mydirection.x   * myside.y       )*invdet;
    330         zinvtransform.z = (mydirection.x   * myorthonormal.y - myorthonormal.x * mydirection.y  )*invdet;
     322        xinvtransform.x = (newy.y * newz.z        - newz.y        * newy.z)*invdet;
     323        xinvtransform.y = (newx.z   * newz.y        - newx.y   * newz.z       )*invdet;
     324        xinvtransform.z = (newx.y   * newy.z - newx.z   * newy.y)*invdet;
     325        yinvtransform.x = (newy.z * newz.x        - newy.x * newz.z       )*invdet;
     326        yinvtransform.y = (newx.x   * newz.z        - newx.z   * newz.x       )*invdet;
     327        yinvtransform.z = (newy.x * newx.z   - newx.x   * newy.z)*invdet;
     328        zinvtransform.x = (newy.x * newz.y        - newz.x        * newy.y)*invdet;
     329        zinvtransform.y = (newz.x        * newx.y   - newx.x   * newz.y       )*invdet;
     330        zinvtransform.z = (newx.x   * newy.y - newy.x * newx.y  )*invdet;
    331331
    332332        // coordinate transformation
    333333        orxonox::Vector3 distanceShip;
    334         distanceShip.x = xinvtransform.x * distance.x + yinvtransform.x * distance.y + zinvtransform.x * distance.z;
    335         distanceShip.y = xinvtransform.y * distance.x + yinvtransform.y * distance.y + zinvtransform.y * distance.z;
    336         distanceShip.z = xinvtransform.z * distance.x + yinvtransform.z * distance.y + zinvtransform.z * distance.z;
     334        distanceShip.x = xinvtransform.x * totransform.x + yinvtransform.x * totransform.y + zinvtransform.x * totransform.z;
     335        distanceShip.y = xinvtransform.y * totransform.x + yinvtransform.y * totransform.y + zinvtransform.y * totransform.z;
     336        distanceShip.z = xinvtransform.z * totransform.x + yinvtransform.z * totransform.y + zinvtransform.z * totransform.z;
    337337
    338338        return distanceShip;
  • code/trunk/src/modules/docking/DockingAnimation.h

    r9667 r11099  
    5353    /**
    5454    @brief
    55         Base class for docking animations used by @ref orxonox::Docking "Docks".
     55        Base class for docking animations used by @ref orxonox::Dock "Docks".
    5656
    5757    @author
  • code/trunk/src/modules/docking/DockingEffect.h

    r9667 r11099  
    5151    /**
    5252    @brief
    53         Handles DockingEffects for @ref orxonox::Docking "Docks".
     53        Handles DockingEffects for @ref orxonox::Dock "Docks".
    5454
    5555    @author
  • code/trunk/src/modules/docking/DockingTarget.h

    r11071 r11099  
    4545    /**
    4646    @brief
    47         DockingTargets for @ref orxonox::Docking "Docks".
     47        DockingTargets for @ref orxonox::Dock "Docks".
    4848
    4949    @author
  • code/trunk/src/modules/docking/MoveToDockingTarget.h

    r11071 r11099  
    4646    /**
    4747    @brief
    48         Base class for docking animations used by @ref orxonox::Docking "Docks".
     48        Base class for docking animations used by @ref orxonox::Dock "Docks".
    4949
    5050    @author
  • code/trunk/src/modules/gametypes/SpaceRaceController.cc

    r11083 r11099  
    2424 */
    2525
    26 /**
    27  * Conventions:
    28  * -first Checkpoint has index 0
    29  * -staticCheckPoint= static Point (see def over = constructor)
    30  */
    31 
    32 /*TODO:
    33  * tICK KORRIGIEREN
    34  *
    35  *
    36  */
    3726#include <gametypes/SpaceRaceController.h>
    3827#include "core/CoreIncludes.h"
  • code/trunk/src/modules/gametypes/SpaceRaceController.h

    r11071 r11099  
    3636namespace orxonox
    3737{
     38    /**
     39     * Conventions:
     40     * -first Checkpoint has index 0
     41     * -staticCheckPoint= static Point (see def over = constructor)
     42     *@todo:
     43     *  tICK KORRIGIEREN
     44     */
    3845    class _GametypesExport SpaceRaceController: public ArtificialController,
    3946            public Tickable
  • code/trunk/src/modules/hover/HoverFlag.cc

    r11071 r11099  
    8080    @param yCoordinate
    8181        Y-Coordinate of the flage, 0-9, origin is bottom left
     82    @param cellSize
     83        The size of the cells
    8284    */
    8385    void HoverFlag::init(int xCoordinate, int yCoordinate, int cellSize)
  • code/trunk/src/modules/hover/HoverOrigin.h

    r11071 r11099  
    4141        The HoverOrigin implements the playing field @ref orxonox::Hover "Hover" takes place in and allows for many parameters of the minigame to be set.
    4242        The playing field resides in the x,z-plane, with the x-axis being the horizontal axis and the z-axis being the vertical axis.
    43        
    44         Various parameters can be set:
    45         - The <b>dimension</b> is a vector, that defines the width and height of the playing field. The default is <em>(200, 120)</em>.
    46         - The <b>balltemplate</b> is a template that is applied to the @ref orxonox::HoverPlatform "HoverPlatform", it can be used to attach different things to it, e.g. its @ref orxonox::Model "Model". See below for a usage example.
    47         - The <b>battemplate</b> is a template that is applied to the @ref orxonox::HoverPlatform "HoverFigure", it can be used to attach different things to it, e.g. its @ref orxonox::Model "Model". See below for a usage example.
    48         - The <b>ballspeed</b> is the speed with which the @ref orxonox::HoverPlatform "HoverPlatform" moves. The default is <em>100</em>.
    49         - The <b>ballaccfactor</b> is the acceleration factor for the @ref orxonox::HoverPlatform "HoverPlatform". The default is <em>1.0</em>.
    50         - The <b>batspeed</b> is the speed with which the @ref orxonox::HoverFigure "HoverFigures" move. The default is <em>60</em>.
    51         - The <b>batlength</b> is the length of the @ref orxonox::HoverFigure "HoverFigures" as the percentage of the height of the playing field. The default is <em>0.25</em>.
    52        
    53         An example in XML of the HoverOrigin would be:
    54        
    55         First the needed templates:
    56         The template for the @ref orxonox::HoverPlatform "HoverPlatform".
    57         @code
    58         <Template name="Hoverball">
    59           <HoverPlatform>
    60             <attached>
    61               <Model mesh="sphere.mesh" scale="2" />
    62               <ParticleSpawner name="hiteffect" position="0,0,0" source="Orxonox/sparks2" lifetime="0.01" autostart="0" mainstate="spawn" />
    63             </attached>
    64             <eventlisteners>
    65               <EventTarget target="hiteffect" />
    66             </eventlisteners>
    67           </HoverPlatform>
    68         </Template>
    69         @endcode
    70         As can be seen, a sphere is attached as the @ref orxonox::Model "Model" for the @ref orxonox::HoverPlatform "HoverPlatform", and also an @ref orxonox::EventListener "EventListener" that triggers a @ref orxonox::ParticleSpawner "ParticleSpawner", whenever the ball hits the boundaries is attached.
    71        
    72         Additionally the template for the @ref orxonox::HoverFigure "HoverFigure".
    73         @code
    74         <Template name="Hoverbatcameras" defaults="0">
    75           <HoverFigure>
    76             <camerapositions>
    77               <CameraPosition position="0,200,0" pitch="-90" absolute="true" />
    78             </camerapositions>
    79           </HoverFigure>
    80         </Template>
    81 
    82         <Template name="Hoverbat">
    83           <HoverFigure camerapositiontemplate=Hoverbatcameras>
    84             <attached>
    85               <Model position="0,0,3" mesh="cube.mesh" scale3D="14,2,2" />
    86             </attached>
    87           </HoverFigure>
    88         </Template>
    89         @endcode
    90         As can be seen, there are actually two templates. The first template is needed to set the camera for the @ref orxonox::HoverFigure "HoverFigure". The second template ist the actual template for the @ref orxonox::HoverFigure "HoverFigure", the template for the camera position is added and a @ref orxonox::Model "Model" for the @ref orxonox::HoverFigure "HoverFigure" is attached.
    91         propellerTemplate_
    92         Finally the HoverOrigin is created.
    93         @code
    94         <HoverOrigin name="Hovercenter" dimension="200,120" balltemplate="Hoverball" battemplate="Hoverbat" ballspeed="200" ballaccfactor="1.0" batspeed="130" batlength="0.25">
    95           <attached>
    96             <Model position="0,0,60" mesh="cube.mesh" scale3D="105,1,1" />
    97             <Model position="0,0,-60" mesh="cube.mesh" scale3D="105,1,1" />
    98           </attached>
    99         </HoverOrigin>
    100         @endcode
    101         All parameters are specified. And also two @ref orxonox::Model "Models" (for the upper and lower boundary) are attached.
    102        
    103         For a more elaborate example, have a look at the <code>Hover.oxw</code> level file.
     43        For an example, have a look at the <code>Hover.oxw</code> level file.
    10444
    10545    */
  • code/trunk/src/modules/hover/HoverWall.cc

    r11071 r11099  
    7676    @param y
    7777        y-Coordinate of the Square that the Wall is attached to, 0-9, Origin is Bottom left
     78    @param cellSize
     79        The size of a cell
     80    @param cellHeight
     81        The height of a cell
    7882    @param orientation
    7983            Wall on the right side (1) or on top (2) of this square, 0-1       
  • code/trunk/src/modules/jump/JumpEnemy.cc

    r11071 r11099  
    139139    }
    140140
    141     /**
    142     @brief
    143         Set the bats for the ball.
    144     @param bats
    145         An array (of size 2) of weak pointers, to be set as the new bats.
    146     */
    147141    void JumpEnemy::setFigure(JumpFigure* newFigure)
    148142    {
  • code/trunk/src/modules/mini4dgame/Mini4DgameBoard.cc

    r11071 r11099  
    7272
    7373    /**
    74         @brief checks if the move is valid
    75         @param the position where to put the stone plus the player who makes the move
     74        @brief Checks if the move is valid
     75        @param move The position where to put the stone
    7676    */
    7777    bool Mini4DgameBoard::isValidMove(const Mini4DgamePosition& move)
     
    9898    /**
    9999    @brief makes a move on the logic playboard
    100     @param the position where to put the stone plus the player who makes the move
     100    @param move The position where to put the stone
    101101    */
    102102    void Mini4DgameBoard::makeMove(const Mini4DgamePosition& move)
  • code/trunk/src/modules/notifications/NotificationDispatcher.h

    r11071 r11099  
    103103            /**
    104104            @brief Set the NotificationDispatcher to broadcast.
    105             @param broadcast Whether the NotificationDispatcher is set to broadcast or singlecast.
     105            @param v Whether the NotificationDispatcher is set to broadcast or singlecast.
    106106            */
    107107            void setBroadcasting(bool v)
  • code/trunk/src/modules/notifications/NotificationQueue.cc

    r11071 r11099  
    4949    @brief
    5050        Default constructor. Registers and initializes the object.
    51     @param creator
    52         The creator of the NotificationQueue.
    5351    */
    5452    NotificationQueue::NotificationQueue(Context* context) : BaseObject(context), Synchronisable(context), registered_(false)
     
    6563        this->registerVariables();
    6664    }
    67 
    68     // TODO move to docu.
    69     /**
    70     @brief
    71         Constructor. Registers and initializes the object.
    72     @param creator
    73         The creator of the NotificationQueue
    74     @param name
    75         The name of the new NotificationQueue. It needs to be unique
    76     @param senders
    77         The senders that are targets of this NotificationQueue, i.e. the names of senders whose Notifications this NotificationQueue displays.
    78         The senders need to be seperated by commas.
    79     @param size
    80         The size (the maximum number of displayed Notifications) of this NotificationQueue.
    81     @param displayTime
    82         The time during which a Notification is (at most) displayed.
    83     */
    8465
    8566    /**
  • code/trunk/src/modules/objects/Script.cc

    r11071 r11099  
    5858    @brief
    5959        Constructor. Registers and initializes the object.
    60     @param creator
    61         The creator of this object.
    6260    */
    6361    Script::Script(Context* context) : BaseObject(context)
  • code/trunk/src/modules/objects/Turret.h

    r11071 r11099  
    2828
    2929/**
     30    @file Turret.h
    3031    @brief Definition of the Turret class.
    3132    @ingroup Objects
  • code/trunk/src/modules/objects/controllers/TurretController.h

    r10262 r11099  
    2626 *
    2727 */
    28 
    29 /**
    30     @brief Definition for the controller for turrets.
    31 */
    3228
    3329#ifndef _TurretController_H__
  • code/trunk/src/modules/objects/triggers/DistanceTrigger.cc

    r11071 r11099  
    5454    @brief
    5555        Constructor. Registers and initializes the object.
    56     @param creator
    57         The creator of this trigger.
    5856    */
    5957    DistanceTrigger::DistanceTrigger(Context* context) : Trigger(context)
  • code/trunk/src/modules/objects/triggers/DistanceTriggerBeacon.cc

    r9667 r11099  
    4545    @brief
    4646        Constructor. Registers the object.
    47     @param creator
    48         The creator of this object.
    4947    */
    5048    DistanceTriggerBeacon::DistanceTriggerBeacon(Context* context) : StaticEntity(context)
  • code/trunk/src/modules/objects/triggers/EventTrigger.cc

    r11071 r11099  
    4545    @brief
    4646        Constructor. Registers and initializes the object.
    47     @param creator
    48         The creator of the EventTrigger.
    4947    */
    5048    EventTrigger::EventTrigger(Context* context) : Trigger(context)
  • code/trunk/src/modules/objects/triggers/MultiTrigger.cc

    r11071 r11099  
    4848    @brief
    4949        Constructor. Registers the objects and initializes default values.
    50     @param creator
    51         The creator.
    5250    */
    5351    MultiTrigger::MultiTrigger(Context* context) : TriggerBase(context)
  • code/trunk/src/modules/objects/triggers/MultiTriggerContainer.cc

    r11071 r11099  
    4747    @brief
    4848        Default constructor. Registers the object and creates an empty container.
    49     @param creator
    50         The creator.
    5149    */
    5250    MultiTriggerContainer::MultiTriggerContainer(Context* context) : BaseObject(context), originator_(nullptr), data_(nullptr)
     
    5856    @brief
    5957        Constructor. Registers the object and sets the input values.
    60     @param creator
    61         The creator.
     58    @param context
     59        The context.
    6260    @param originator
    6361        A pointer to the originator of the Event, i.e. the MultiTrigger that fired the Event. (or is about to fire)
  • code/trunk/src/modules/objects/triggers/Trigger.cc

    r11071 r11099  
    5151    @brief
    5252        Constructor. Registers and initializes the object.
    53     @param creator
    54         The creator of the Trigger.
    5553    */
    5654    Trigger::Trigger(Context* context) : TriggerBase(context)
  • code/trunk/src/modules/pickup/Pickup.cc

    r11071 r11099  
    5353    @brief
    5454        Constructor. Registers and initializes the object.
    55     @param creator
    56         The objects creator.
    5755    */
    5856    Pickup::Pickup(Context* context) : BaseObject(context)
  • code/trunk/src/modules/pickup/PickupCollection.cc

    r11071 r11099  
    5050    @brief
    5151        Default Constructor.
    52     @param creator
    53         The creator of the object.
    5452    */
    5553    PickupCollection::PickupCollection(Context* context) : BaseObject(context)
  • code/trunk/src/modules/pickup/PickupManager.cc

    r11071 r11099  
    335335    @param representationObjectId
    336336        The objectId identifying (over the network) the PickupRepresentation that represents this Pickupable.
     337    @param representationName
     338        The name of the associated PickupRepresentation
    337339    @param pickedUp
    338340        The pickedUp status the Pickupable changed to.
  • code/trunk/src/modules/pickup/PickupSpawner.cc

    r11071 r11099  
    5252    @brief
    5353        Constructor. Creates a blank PickupSpawner.
    54     @param creator
    55         Pointer to the object which created this item.
    5654    */
    5755    PickupSpawner::PickupSpawner(Context* context) : StaticEntity(context), pickup_(nullptr), representation_(nullptr), pickupTemplate_(nullptr)
     
    9088    @brief
    9189        Factory method, Creates a fully functional PickupSpawner.
    92     @param creator
    93         The creator of this PickupSpawner.
     90    @param context
     91        The context of this PickupSpawner.
    9492    @param pickup
    9593        The Pickupable to be spawned by this PickupSpawner.
  • code/trunk/src/modules/pickup/items/DamageBoostPickup.h

    r9667 r11099  
    6868
    6969            /**
    70              @brief set Damage multiplier
    71              @param multiplier The default damage multiplier to set
     70             @brief Get Damage multiplier
    7271             */
    7372            inline float getDamageMultiplier()
  • code/trunk/src/modules/tetris/TetrisCenterpoint.h

    r11071 r11099  
    105105            /**
    106106            @brief Set the template for the stones.
    107             @param template The template name to be applied to each stone.
     107            @param templateName The template name to be applied to each stone.
    108108            */
    109109            void setStoneTemplate(const std::string& templateName)
     
    118118            /**
    119119            @brief Set the template for the bricks.
    120             @param template The template name to be applied to each brick.
     120            @param templateName The template name to be applied to each brick.
    121121            */
    122122            void setBrickTemplate(const std::string& templateName)
  • code/trunk/src/modules/towerdefense/TowerDefense.h

    r11071 r11099  
    2727 */
    2828
    29  /**
    30     @brief
    31         GameType class for TowerDefense. See TowerDefenseReadme.txt for Information.
    32 
    33     @ingroup TowerDefense
    34  */
    35 
    3629
    3730#ifndef _TowerDefense_H__
     
    4740namespace orxonox
    4841{
     42    /**
     43    @brief
     44    GameType class for TowerDefense. See TowerDefenseReadme.txt for Information.
     45
     46    @ingroup TowerDefense
     47    */
    4948    class _TowerDefenseExport TowerDefense : public TeamDeathmatch
    5049    {
  • code/trunk/src/modules/towerdefense/TowerDefenseCenterpoint.h

    r11071 r11099  
    2727 */
    2828
    29 /**
    30  @brief
    31  See TowerDefenseReadme.txt for Information.
    32  @ingroup TowerDefense
    33  */
    34 
    3529
    3630#ifndef _TowerDefenseCenterpoint_H__
     
    4640namespace orxonox
    4741{
     42    /**
     43    @brief
     44    See TowerDefenseReadme.txt for Information.
     45    @ingroup TowerDefense
     46    */
    4847    class _TowerDefenseExport TowerDefenseCenterpoint : public MobileEntity
    4948    {
  • code/trunk/src/modules/towerdefense/TowerDefenseEnemy.cc

    r11071 r11099  
    55//  Created by Jonas Erb on 22.10.14.
    66
    7 /**
    8 @brief
    9 See TowerDefenseReadme.txt for Information.
    10 
    11 @ingroup TowerDefense
    12 */
    137#include "TowerDefenseEnemy.h"
    148#include "core/CoreIncludes.h"
  • code/trunk/src/modules/towerdefense/TowerDefenseEnemy.h

    r11071 r11099  
    55//  Created by Jonas Erb on 22.10.14.
    66
    7 /**
    8 @brief
    9 See TowerDefenseReadme.txt for Information.
    107
    11 @ingroup TowerDefense
    12 */
    138
    149
     
    2621namespace orxonox
    2722{
    28 /* Class to give the TowerDefenseEnemy spaceships waypoints and
    29  *
    30  */
     23    /**
     24    @brief
     25    See TowerDefenseReadme.txt for Information.
     26
     27    @ingroup TowerDefense
     28    */
    3129    class _TowerDefenseExport TowerDefenseEnemy : public SpaceShip
    3230    {
  • code/trunk/src/modules/towerdefense/TowerDefenseField.h

    r11071 r11099  
    2727 */
    2828
    29 /**
    30  @brief
    31  See TowerDefenseReadme.txt for Information.
    32  @ingroup TowerDefense
    33  */
    3429
    3530
     
    5651    };
    5752
    58 
     53    /**
     54    @brief
     55    See TowerDefenseReadme.txt for Information.
     56    @ingroup TowerDefense
     57    */
    5958    class _TowerDefenseExport TowerDefenseField : public MovableEntity
    6059    {
  • code/trunk/src/modules/towerdefense/TowerDefenseHUDController.h

    r11071 r11099  
    2727 */
    2828
    29  /**
    30     @brief
    31         This subclass of OverlayText is used to display the stats of the player in the HUD
    32 
    33     @ingroup TowerDefense
    34  */
    35 
    3629
    3730#ifndef _TowerDefenseHUDController_H__
     
    4639namespace orxonox
    4740{
     41    /**
     42    @brief
     43    This subclass of OverlayText is used to display the stats of the player in the HUD
     44
     45    @ingroup TowerDefense
     46    */
    4847    class _TowerDefenseExport TowerDefenseHUDController : public OverlayText, public Tickable
    4948    {
  • code/trunk/src/modules/towerdefense/TowerDefenseTower.h

    r10629 r11099  
    66//  Copyright (c) 2012 __MyCompanyName__. All rights reserved.
    77//
    8 
    9 /**
    10 @brief
    11 See TowerDefenseTowerDefenseReadme.txt for Information.
    12 
    13 @ingroup TowerDefenseTowerDefense
    14 */
    158
    169
     
    2417namespace orxonox
    2518{
     19    /**
     20    @brief
     21    See TowerDefenseTowerDefenseReadme.txt for Information.
     22
     23    @ingroup TowerDefenseTowerDefense
     24    */
    2625    class _TowerDefenseExport TowerDefenseTower : public Turret
    2726    {
  • code/trunk/src/modules/weapons/projectiles/BasicProjectile.cc

    r11071 r11099  
    7474    @param contactPoint
    7575        A btManifoldPoint indicating the point of contact/impact.
     76    @param cs
     77        The btCollisionShape of the other object
    7678    @return
    7779        Returns true if the collision resulted in a successful hit.
  • code/trunk/src/modules/weapons/projectiles/BasicProjectile.h

    r10293 r11099  
    9797            /**
    9898            @brief Get the shield-damage done by this projectile.
    99                    Shield-damage only reduces shield health.
    100             @param shielddamage The amount of damage. Is non-negative.
    10199            */
    102100            inline float getShieldDamage() const
  • code/trunk/src/modules/weapons/projectiles/GravityBombField.h

    r11071 r11099  
    5050     * @date    23.05.2015
    5151     *
    52      * @param [in,out] the Pawn that created the field.
     52     * @param [in,out] shooter the Pawn that created the field.
    5353     */
    5454    void setShooter(Pawn* shooter)
  • code/trunk/src/modules/weapons/projectiles/SplitGunProjectile.cc

    r11052 r11099  
    8080    /**
    8181    @brief
    82         This function starts a timer that will cause the projectile to split after a time defined by the argument @param splitTime.       
     82        This function starts a timer that will cause the projectile to split after a time defined by the argument @p splitTime.
     83    @param splitTime The time
    8384    */
    8485    void SplitGunProjectile::setSplitTime(float splitTime)
  • code/trunk/src/modules/weapons/weaponmodes/HsW01.h

    r11071 r11099  
    7676            /**
    7777            @brief Set the sound.
    78             @param mesh The Sound name.
     78            @param sound The Sound name.
    7979            */
    8080            void setSound(const std::string& sound)
  • code/trunk/src/orxonox/LevelInfo.cc

    r11071 r11099  
    115115    @brief
    116116        Set the starting ship models of the level
    117     @param tags
     117    @param ships
    118118        A comma-seperated string of all the allowed ship models for the shipselection.
    119119    */
     
    244244    RegisterClass(LevelInfo);
    245245
    246     /**
    247     @brief
    248 
    249     @param creator
    250         The creator of this object.
    251     */
    252246    LevelInfo::LevelInfo(Context* context) : BaseObject(context)
    253247    {
  • code/trunk/src/orxonox/LevelInfo.h

    r11071 r11099  
    197197    @author
    198198        Damian 'Mozork' Frick
    199     @edit
    200199        Matthias Hutter
    201200    @ingroup Orxonox
     
    247246            /**
    248247            @brief Set the starting ship models of the level
    249             @param A comma-seperated string of all the allowed ship models for the shipselection.
     248            @param ships A comma-seperated string of all the allowed ship models for the shipselection.
    250249            */
    251250            inline void setStartingShips(const std::string& ships)
  • code/trunk/src/orxonox/chat/ChatHistory.h

    r11071 r11099  
    8080       *
    8181       * \param message The incoming message
    82        * \param senderID Identification number of the sender
     82       * \param name Name of the sender
    8383       */
    8484      virtual void incomingChat(const std::string& message, const std::string& name) override;
  • code/trunk/src/orxonox/chat/ChatInputHandler.h

    r11071 r11099  
    120120
    121121      /** \param message the message text
    122        * \param senderID ID of the player who sent the message
     122       * \param name Name of the player who sent the message
    123123       *
    124124       * Deal with incoming chat (which means in our case: Add it to the
  • code/trunk/src/orxonox/controllers/ActionpointController.h

    r11071 r11099  
    9494            @brief
    9595                XML method, example XML usage:
     96
     97                @code
    9698                <SpaceShip position="-2000, 1500, -1000" lookat="0,0,0" team=0 name="ss2">
    9799                  <templates>
     
    110112                  </controller>
    111113                </SpaceShip>
     114                @endcode
    112115               
    113116                Full description:
     
    116119                If any WorldEntity that is not Actionpoint or its child being sent to actionpoints through XML,
    117120                action would be assumed to be Action::FLY and target position to be position of the entity. Also, if not Actionpoint
    118                 is passed, it is assumed to be in a loop. How it works is: in <actionpoints> first all Actionpoints between
     121                is passed, it is assumed to be in a loop. How it works is: in \<actionpoints\> first all Actionpoints between
    119122                first Actionpoint with loopStart=true and first following Actionpoint with loopEnd=true are included in a single loop.
    120123                If they are adjacent (in the input array) with WorldEntity, then WorldEntity is also in a loop.
     
    122125               
    123126                Loop example:
     127
     128                @code
    124129                <SpaceShip position="-1500, 1500, -1000" lookat="0,0,0" team=0 name="ss1">
    125130                  <templates>
     
    137142                  </controller>
    138143                </SpaceShip>
     144                @endcode
    139145               
    140146                other loop example:
     147
     148                @code
    141149                <SpaceShip position="-1500, -1500, -1500" lookat="0,0,0" team=0 name="ss1">
    142150                  <templates>
     
    153161                    </DivisionController>
    154162                  </controller>
    155                 </SpaceShip>
     163                </SpaceShip>
     164                @endcode
    156165
    157166            @note
    158                 Don't use several loops, and don't use WorldEntities as input to <actionpoints> as I didn't test it well, but you
     167                Don't use several loops, and don't use WorldEntities as input to \<actionpoints\> as I didn't test it well, but you
    159168                can try if feeling lucky. 
    160169            */
  • code/trunk/src/orxonox/controllers/ArtificialController.cc

    r11071 r11099  
    255255        @brief Adds first waypoint of type name to the waypoint stack, which is within the searchDistance
    256256        @param name object-name of a point of interest (e.g. "PickupSpawner", "ForceField")
     257        @param searchDistance The maximum distance to search
    257258    */
    258259    void ArtificialController::updatePointsOfInterest(std::string name, float searchDistance)
  • code/trunk/src/orxonox/controllers/MasterController.h

    r11071 r11099  
    4444      If no MasterController is initialized, none of ActionpointControllers will work.
    4545      Example:
     46
     47      @code
    4648      <Pawn position = "100000, 100000, 100000">
    4749        <controller>
     
    5052        </controller>
    5153      </Pawn>
     54      @endcode
    5255    */
    5356    class _OrxonoxExport MasterController : public Controller, public Tickable
  • code/trunk/src/orxonox/gametypes/Dynamicmatch.cc

    r11071 r11099  
    2626 *
    2727 */
    28 //TODO:
    29 //pig punkte vergeben pro Zeit!
    30 //killerfarbe schwarz; evtl. eigenes Raumfahrzeug;
    31 //Low; Codeoptimierung und Dokumentation
    32 
    33 /**
    34 @brief
    35     Short Gaming Manual:
    36     There are three different parties a player can belong to: victim, chaser or killer
    37     Every player starts as chaser. As long as there are not enough victims and killers, you can change your and other player's parties by shooting them.
    38     In order to win you have to earn as much points as possible:
    39     - as victim by escaping the chasers
    40     - as chaser by shooting the victim
    41     - as killer by killing the chasers
    42 
    43 
    44     What you shouldn't do is shooting at players of your own party. By doing so your score will decrease.
    45     P.S: If you don't want to be a victim: Get rid of your part by shooting a chaser.
    46 */
     28
    4729#include "Dynamicmatch.h"
    4830
  • code/trunk/src/orxonox/gametypes/Dynamicmatch.h

    r11071 r11099  
    4242namespace orxonox
    4343{
     44    /**
     45    @brief
     46        Short Gaming Manual:
     47        There are three different parties a player can belong to: victim, chaser or killer
     48        Every player starts as chaser. As long as there are not enough victims and killers, you can change your and other player's parties by shooting them.
     49        In order to win you have to earn as much points as possible:
     50        - as victim by escaping the chasers
     51        - as chaser by shooting the victim
     52        - as killer by killing the chasers
     53
     54
     55        What you shouldn't do is shooting at players of your own party. By doing so your score will decrease.
     56        P.S: If you don't want to be a victim: Get rid of your part by shooting a chaser.
     57
     58        @todo:
     59        pig punkte vergeben pro Zeit!
     60        killerfarbe schwarz; evtl. eigenes Raumfahrzeug;
     61        Low; Codeoptimierung und Dokumentation
     62    */
    4463    class _OrxonoxExport Dynamicmatch : public Gametype
    4564    {
  • code/trunk/src/orxonox/infos/GametypeInfo.cc

    r11071 r11099  
    378378    @param player
    379379        The player that has changed its spawned status.
    380     @param ready
     380    @param spawned
    381381        The new spawned status.
    382382    */
  • code/trunk/src/orxonox/interfaces/NotificationListener.cc

    r11071 r11099  
    102102    @param isCommand
    103103        Whether the message is a command or a notification.
    104     @param messageType
     104    @param type
    105105        The type of the notification.
    106106    */
  • code/trunk/src/orxonox/interfaces/PlayerTrigger.h

    r10624 r11099  
    8282        /**
    8383        @brief Set the player that triggered the PlayerTrigger. This is normally done by classes inheriting vom PlayerTrigger.
    84         @param player A pointer to the Pawn that triggered the PlayerTrigger.
     84        @param pawn A pointer to the Pawn that triggered the PlayerTrigger.
    8585        */
    8686        void setTriggeringPawn(Pawn* pawn);
  • code/trunk/src/orxonox/items/Engine.h

    r11071 r11099  
    4545        There are many parameters that can be specified:
    4646        - The <b>relativePosition</b>, specifies the position relative to the center of the SpaceShip the Engine is mounted on.
    47         - The <b>maximal speed</b>, there are four maximal speeds that can be specified: The <b>speedfront</b>, the maximal forward speed. The <b>speedback>, the maximal backward speed. The <b>speedleftright</b>, the maximal speed in y-direction of the SpaceShip coordinate frame. The <b>speedupdown</b>, the maximal speed in z-direction of the SpaceShip coordinate frame. All maximal speeds (naturally) have to be non-negative.
     47        - The <b>maximal speed</b>, there are four maximal speeds that can be specified: The <b>speedfront</b>, the maximal forward speed. The <b>speedback</b>, the maximal backward speed. The <b>speedleftright</b>, the maximal speed in y-direction of the SpaceShip coordinate frame. The <b>speedupdown</b>, the maximal speed in z-direction of the SpaceShip coordinate frame. All maximal speeds (naturally) have to be non-negative.
    4848        - The <b>acceleration</b>, there are five types of acceleration that can be specified: The <b>accelerationfront</b>, the forward acceleration. The <b>accelerationbrake</b>, the braking acceleration. The <b>accelerationback</b>, the backward acceleration. The <b>accelerationleftright</b>, the acceleration in y-direction. The <b>accelerationupdown</b>, the acceleration in z-direction. All accelerations have to be non-negative.
    4949        - The <b>boostfactor</b>, specifies the factor by which boosting increases the speed. This has to be non-negative, as well. Beware that maximal speeds can be overcome through boosting.
     
    213213            /**
    214214            @brief Add to the additional forward speed factor.
    215             @param factor The speed that is added to the additional forward speed. Must be non-negative.
     215            @param speed The speed that is added to the additional forward speed. Must be non-negative.
    216216            */
    217217            inline void addSpeedAdd(float speed)
  • code/trunk/src/orxonox/items/PartDestructionEvent.cc

    r11071 r11099  
    164164    @brief
    165165        Set type of the target
    166     @param param
     166    @param type
    167167        The desired target-type as string. Valid target-types: ship engine weapon
    168168    */
     
    197197        Set the operation to be applied.
    198198    @param param
    199         The desired parameter as string. Valid parameters: c.f. @ref orxnox::PartDestructionEvent::TargetParam
     199        The desired parameter as string. Valid parameters: c.f. @ref TargetParam
    200200    */
    201201    void PartDestructionEvent::setTargetParam(std::string param)
  • code/trunk/src/orxonox/items/PartDestructionEvent.h

    r11071 r11099  
    8181                @brief
    8282                    List of all allowed parameters.
    83                 */
     83            */
    8484            enum class TargetParam
    8585            {
  • code/trunk/src/orxonox/items/ShipPart.cc

    r11071 r11099  
    116116    @brief
    117117        Add a StaticEntity to the ShipPart.
    118     @param engine
     118    @param entity
    119119        A pointer to the StaticEntity to be added.
    120120    */
     
    158158    @brief
    159159        Add a PartDestructionEvent to the ShipPart.
    160     @param engine
     160    @param event
    161161        A pointer to the PartDestructionEvent to be added.
    162162    */
  • code/trunk/src/orxonox/overlays/OrxonoxOverlay.cc

    r11071 r11099  
    126126        This has to be called before usage, otherwise strange behaviour is
    127127        guaranteed! (there should be no segfaults however).
    128     @copydoc
    129         BaseObject::XMLPort()
     128    @copydoc BaseObject::XMLPort()
    130129    */
    131130    void OrxonoxOverlay::XMLPort(Element& xmlelement, XMLPort::Mode mode)
  • code/trunk/src/orxonox/overlays/OverlayGroup.cc

    r11071 r11099  
    8585    @brief
    8686        Loads the group and all its children OrxonoxOverlays.
    87     @copydoc
    88         BaseObject::XMLPort()
     87    @copydoc BaseObject::XMLPort()
    8988    */
    9089    void OverlayGroup::XMLPort(Element& xmlelement, XMLPort::Mode mode)
  • code/trunk/src/orxonox/weaponsystem/WeaponSlot.h

    r11071 r11099  
    4848          <WeaponSlot position="    0,   0,0" />
    4949        </weaponslots>
     50        @endcode
    5051
    5152        A WeaponSlot can be attached to a @ref orxonox::Pawn because WeaponSlot inherits from @ref orxonox::StaticEntity.
  • code/trunk/src/orxonox/weaponsystem/WeaponSystem.cc

    r11071 r11099  
    285285    /**
    286286    @brief
    287         Fires the @ref Orxonox::WeaponSet with the specified firemode.
     287        Fires the @ref orxonox::WeaponSet with the specified firemode.
    288288    */
    289289    void WeaponSystem::fire(unsigned int firemode)
  • code/trunk/src/orxonox/worldentities/Actionpoint.h

    r11071 r11099  
    4949        Example XML code:
    5050
     51        @code
    5152        <SpaceShip position="-2000, 1500, -1000" lookat="0,0,0" team=0 name="thisShipName">
    5253          <templates>
     
    6566          </controller>
    6667        </SpaceShip>
    67        
     68        @endcode
     69
    6870        Example with loops:
    6971
     72        @code
    7073        <SpaceShip position="-1500, 1500, -1000" lookat="0,0,0" team=0 name="thisShipName">
    7174          <templates>
     
    8386          </controller>
    8487        </SpaceShip>
     88        @endcode
    8589       
    8690        One can also use other Worldentities instead of Actionpoints just like Waypoints, but those points
  • code/trunk/src/orxonox/worldentities/WorldEntity.h

    r11071 r11099  
    400400            @param otherObject
    401401                The object this one has collided into.
     402            @param ownCollisionShape
     403                The collision shape of the other object
    402404            @param contactPoint
    403405                Contact point provided by Bullet. Holds more information and can me modified. See return value.
  • code/trunk/src/orxonox/worldentities/pawns/ModularSpaceShip.cc

    r11071 r11099  
    207207    @brief
    208208        Add a ShipPart to the SpaceShip.
    209     @param engine
     209    @param part
    210210        A pointer to the ShipPart to be added.
    211211    */
  • code/trunk/src/orxonox/worldentities/pawns/ModularSpaceShip.h

    r11071 r11099  
    5858
    5959        As mentioned @ref orxonox::Engine Engines can be mounted on the ModularSpaceShip.
    60         In order to assign attached entities to a ShipPart, a ShipPart with the same name as the corresponding entity needs to be created in the <parts> tag.
     60        In order to assign attached entities to a ShipPart, a ShipPart with the same name as the corresponding entity needs to be created in the \<parts\> tag.
    6161        Here is a (primitive) example of a ModularSpaceShip defined in XML:
    6262        @code
  • code/trunk/src/orxonox/worldentities/pawns/Pawn.cc

    r11071 r11099  
    425425    /**
    426426    @brief
    427         Check whether the Pawn has a @ref Orxonox::WeaponSystem and fire it with the specified firemode if it has one.
     427        Check whether the Pawn has a @ref orxonox::WeaponSystem and fire it with the specified firemode if it has one.
    428428    */
    429429
Note: See TracChangeset for help on using the changeset viewer.