Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Ignore:
Timestamp:
Jul 3, 2011, 5:42:19 PM (13 years ago)
Author:
dafrick
Message:

Cleaning up in SpaceShip and Engine. Fixed several bugs.
Kicked localLinearAcceleration, primaryThrust and auxiliaryThrust out of the SpaceShip, since it wasn't used anymore.
Moved the trail lights back a bit.
Added some documentation to SpaceShip and Engine.
SpeedPickup is working again, will need some further tuning.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • code/trunk/src/orxonox/items/Engine.h

    r8706 r8727  
    3232#include "OrxonoxPrereqs.h"
    3333
    34 #include "tools/interfaces/Tickable.h"
     34#include "util/OrxAssert.h"
     35
    3536#include "Item.h"
    36 
    37 #include "interfaces/PickupCarrier.h"
    3837
    3938namespace orxonox
    4039{
    41     class _OrxonoxExport Engine : public Item, public Tickable, public PickupCarrier
     40
     41    /**
     42    @brief
     43        The Engine class provides propulsion to the SpaceShip.
     44       
     45        There are many parameters that can be specified:
     46        - 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.
     48        - 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.
     49        - 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.
     50        - The <b>template</b>, the name of the engine template. Allows for parameters of the Engine be set trough a template.
     51       
     52    @author
     53        Fabian 'x3n' Landau
     54    */
     55    class _OrxonoxExport Engine : public Item
    4256    {
    4357        public:
    … …  
    4862            void setConfigValues();
    4963
    50             virtual void tick(float dt);
    51             virtual void changedActivity();
    52 
    53             virtual void addToSpaceShip(SpaceShip* ship);
     64            virtual void run(float dt); // Run the engine for a given time interval.
     65
     66            virtual void addToSpaceShip(SpaceShip* ship); // Adds the Engine to the input SpaceShip.
     67            /**
     68            @brief Get the SpaceShip this Engine is mounted on.
     69            @return Returns a pointer to the SpaceShip. NULL if it isn't mounted on any ship.
     70            */
    5471            inline SpaceShip* getShip() const
    5572                { return this->ship_; }
    5673
     74            /**
     75            @brief Set the relative position of the Engine.
     76            @param position The relative position with respect to the SpaceShip it is mounted on.
     77            */
    5778            inline void setRelativePosition(const Vector3 &position)
    5879                { this->relativePosition_ = position; }
    59             inline Vector3& getRelativePosition()
     80            /**
     81            @brief Get the relative position of the Engine.
     82            @return Returns the relative position with respect to the SpaceShip it is mounted on.
     83            */
     84            inline const Vector3& getRelativePosition() const
    6085                { return this->relativePosition_; }
    6186
     87            /**
     88            @brief Set the maximal forward speed of the Engine.
     89            @param speed The speed to be set. Must be non-negative.
     90            */
     91            //TODO: Better OrxVerify()?
     92            inline void setMaxSpeedFront(float speed)
     93                { OrxAssert(speed >= 0.0f, "The input speed must be non-negative."); this->maxSpeedFront_ = speed; }
     94            /**
     95            @brief Set the maximal backward speed of the Engine.
     96            @param speed The speed to be set. Must be non-negative.
     97            */
     98            inline void setMaxSpeedBack(float speed)
     99                { OrxAssert(speed >= 0.0f, "The input speed must be non-negative."); this->maxSpeedBack_ = speed; }
     100            /**
     101            @brief Set the maximal left-right speed of the Engine.
     102            @param speed The speed to be set. Must be non-negative.
     103            */
     104            inline void setMaxSpeedLeftRight(float speed)
     105                { OrxAssert(speed >= 0.0f, "The input speed must be non-negative."); this->maxSpeedLeftRight_ = speed; }
     106            /**
     107            @brief Set the maximal up-down speed of the Engine.
     108            @param speed The speed to be set. Must be non-negative.
     109            */
     110            inline void setMaxSpeedUpDown(float speed)
     111                { OrxAssert(speed >= 0.0f, "The input speed must be non-negative."); this->maxSpeedUpDown_ = speed; }
     112
     113            /**
     114            @brief Get the maximal forward speed of the Engine.
     115            @return Returns the maximal forward speed of the Engine. Is non-negative.
     116            */
     117            inline float getMaxSpeedFront() const
     118                { return this->maxSpeedFront_; }
     119            /**
     120            @brief Get the maximal backward speed of the Engine.
     121            @return Returns the maximal backward speed of the Engine. Is non-negative.
     122            */
     123            inline float getMaxSpeedBack() const
     124                { return this->maxSpeedBack_; }
     125            /**
     126            @brief Get the maximal left-right speed of the Engine.
     127            @return Returns the maximal left-right speed of the Engine. Is non-negative.
     128            */
     129            inline float getMaxSpeedLeftRight() const
     130                { return this->maxSpeedLeftRight_; }
     131            /**
     132            @brief Get the maximal up-down speed of the Engine.
     133            @return Returns the maximal up-down speed of the Engine. Is non-negative.
     134            */
     135            inline float getMaxSpeedUpDown() const
     136                { return this->maxSpeedUpDown_; }
     137
     138            /**
     139            @brief Set the forward acceleration produced by the Engine.
     140            @param acceleration The forward acceleration produced by the Engine. Must be non-negative.
     141            */
     142            inline void setAccelerationFront(float acceleration)
     143                { OrxAssert(acceleration >= 0.0f, "The input acceleration must be non-negative."); this->accelerationFront_ = acceleration; }
     144            /**
     145            @brief Set the breaking acceleration produced by the Engine.
     146            @param acceleration The breaking acceleration produced by the engine. Must be non-negative.
     147            */
     148            inline void setAccelerationBrake(float acceleration)
     149                { OrxAssert(acceleration >= 0.0f, "The input acceleration must be non-negative."); this->accelerationBrake_ = acceleration; }
     150            /**
     151            @brief Set the backward acceleration produced by the Engine.
     152            @param acceleration The backward acceleration produced by the Engine.
     153            */
     154            inline void setAccelerationBack(float acceleration)
     155                { OrxAssert(acceleration >= 0.0f, "The input acceleration must be non-negative."); this->accelerationBack_ = acceleration; }
     156            /**
     157            @brief Set the left-right acceleration produced by the Engine.
     158            @param acceleration The left-right acceleration produced by the Engine.
     159            */
     160            inline void setAccelerationLeftRight(float acceleration)
     161                { OrxAssert(acceleration >= 0.0f, "The input acceleration must be non-negative."); this->accelerationLeftRight_ = acceleration; }
     162            /**
     163            @brief Set the up-down acceleration produced by the Engine.
     164            @param acceleration The
     165            */
     166            inline void setAccelerationUpDown(float acceleration)
     167                { OrxAssert(acceleration >= 0.0f, "The input acceleration must be non-negative."); this->accelerationUpDown_ = acceleration; }
     168
     169            /**
     170            @brief Get the forward acceleration produced by the Engine.
     171            @return Returns the forward acceleration produced by the Engine. Is non-negative.
     172            */
     173            inline float getAccelerationFront() const
     174                { return this->accelerationFront_; }
     175            /**
     176            @brief Get the breaking acceleration produced by the Engine.
     177            @return Returns the breaking acceleration produced by the Engine. Is non-negative.
     178            */
     179            inline float getAccelerationBrake() const
     180                { return this->accelerationBrake_; }
     181            /**
     182            @brief Get the backward acceleration produced by the Engine.
     183            @return Returns the backward acceleration produced by the Engine. Is non-negative.
     184            */
     185            inline float getAccelerationBack() const
     186                { return this->accelerationBack_; }
     187            /**
     188            @brief Get the left-right acceleration produced by the Engine.
     189            @return Returns the left-right acceleration produced by the Engine. Is non-negative.
     190            */
     191            inline float getAccelerationLeftRight() const
     192                { return this->accelerationLeftRight_; }
     193            /**
     194            @brief Get the up-down acceleration produced by the Engine.
     195            @return Returns the up-down acceleration produced by the Engine. Is non-negative.
     196            */
     197            inline float getAccelerationUpDown() const
     198                { return this->accelerationUpDown_; }
     199
     200            /**
     201            @brief Set the factor by which boosting increases the forward acceleration of the Engine.
     202            @param factor The boost factor. Needs to be positive.
     203            */
    62204            inline void setBoostFactor(float factor)
    63                 { this->boostFactor_ = factor; }
     205                { OrxAssert(factor > 0.0f, "The input factor must be positive."); this->boostFactor_ = factor; }
     206            /**
     207            @brief Get the boost factor of the Engine.
     208            @return Returns the factor by which boosting increases the forward acceleration of the Engine. Is positive.
     209            */
    64210            inline float getBoostFactor() const
    65211                { return this->boostFactor_; }
    66212
    67             inline void setSpeedFactor(float factor)
    68                 { this->speedFactor_ = factor; }
    69             inline float getSpeedFactor() const
    70                 { return this->speedFactor_; }
    71 
    72             inline void setMaxSpeedFront(float speed)
    73                 { this->maxSpeedFront_ = speed; }
    74             inline void setMaxSpeedBack(float speed)
    75                 { this->maxSpeedBack_ = speed; }
    76             inline void setMaxSpeedLeftRight(float speed)
    77                 { this->maxSpeedLeftRight_ = speed; }
    78             inline void setMaxSpeedUpDown(float speed)
    79                 { this->maxSpeedUpDown_ = speed; }
    80 
    81             inline float getMaxSpeedFront() const
    82                 { return this->maxSpeedFront_; }
    83             inline float getMaxSpeedBack() const
    84                 { return this->maxSpeedBack_; }
    85             inline float getMaxSpeedLeftRight() const
    86                 { return this->maxSpeedLeftRight_; }
    87             inline float getMaxSpeedUpDown() const
    88                 { return this->maxSpeedUpDown_; }
    89 
    90             inline void setAccelerationFront(float acceleration)
    91                 { this->accelerationFront_ = acceleration; }
    92             inline void setAccelerationBrake(float acceleration)
    93                 { this->accelerationBrake_ = acceleration; }
    94             inline void setAccelerationBack(float acceleration)
    95                 { this->accelerationBack_ = acceleration; }
    96             inline void setAccelerationLeftRight(float acceleration)
    97                 { this->accelerationLeftRight_ = acceleration; }
    98             inline void setAccelerationUpDown(float acceleration)
    99                 { this->accelerationUpDown_ = acceleration; }
    100 
    101             inline float getAccelerationFront() const
    102                 { return this->accelerationFront_; }
    103             inline float getAccelerationBrake() const
    104                 { return this->accelerationBrake_; }
    105             inline float getAccelerationBack() const
    106                 { return this->accelerationBack_; }
    107             inline float getAccelerationLeftRight() const
    108                 { return this->accelerationLeftRight_; }
    109             inline float getAccelerationUpDown() const
    110                 { return this->accelerationUpDown_; }
    111 
     213            /**
     214            @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.
     216            */
     217            inline void addSpeedAdd(float speed)
     218                { this->speedAdd_ += speed; }
     219            /**
     220            @brief Add to the forward speed multiplication factor.
     221            @param factor The factor by which the forward speed multiplication factor is multiplied. Must be non-negative.
     222            */
     223            inline void addSpeedMultiply(float factor)
     224                { OrxAssert(factor >= 0.0f, "The factor must be non-negative."); this->speedMultiply_ *= factor; }
     225
     226            /**
     227            @brief Get the additional forward speed.
     228            @return Returns the additional forward speed.
     229            */
    112230            inline float getSpeedAdd(void)
    113231                { return this->speedAdd_; }
     232            /**
     233            @brief Get the forward speed multiplication factor.
     234            @return Returns the forward speed multiplication factor.
     235            */
    114236            inline float getSpeedMultiply(void)
    115237                { return this->speedMultiply_; }
    116238
    117             virtual const Vector3& getDirection() const;
    118 
    119             virtual const Vector3& getCarrierPosition(void) const;
    120 
    121             inline void setSpeedAdd(float speedAdd)
    122                 { this->speedAdd_=speedAdd; }
    123             inline void setSpeedMultiply(float speedMultiply)
    124                 { this->speedMultiply_=speedMultiply; }
    125 
    126            
     239            /**
     240            @brief Set the engine template, that specifies the parameters for the Engine.
     241            @param temp The name of the engine template.
     242            */
    127243            inline void setEngineTemplate(const std::string& temp)
    128244                { this->engineTemplate_ = temp; this->loadEngineTemplate(); }
     245            /**
     246            @brief Get the engine template, that specifies the parameters for the Engine.
     247            @return Returns the name of the engine template.
     248            */
    129249            inline const std::string& getEngineTemplate() const
    130250                { return this->engineTemplate_; }
    131251
    132252        protected:
    133             virtual std::vector<PickupCarrier*>* getCarrierChildren(void) const
    134                 { return new std::vector<PickupCarrier*>(); }
    135             virtual PickupCarrier* getCarrierParent(void) const;
    136            
    137             void loadEngineTemplate();
     253            void loadEngineTemplate(); // Load the engine template.
     254
     255            virtual const Vector3& getSteering() const; // Get the steering direction imposed upon the Engine.
    138256
    139257        private:
    … …  
    141259            void networkcallback_shipID();
    142260
    143             std::string engineTemplate_;
    144 
    145             SpaceShip* ship_;
    146             unsigned int shipID_;
    147             Vector3 relativePosition_;
    148 
    149             float boostFactor_;
    150             float speedFactor_;
    151 
    152             float speedAdd_;
    153             float speedMultiply_;
    154 
    155             float maxSpeedFront_;
    156             float maxSpeedBack_;
    157             float maxSpeedLeftRight_;
    158             float maxSpeedUpDown_;
    159 
    160             float accelerationFront_;
    161             float accelerationBrake_;
    162             float accelerationBack_;
    163             float accelerationLeftRight_;
    164             float accelerationUpDown_;
     261            std::string engineTemplate_; //!< The template that specifies the Engine's parameters.
     262
     263            SpaceShip* ship_; //!< A pointer to the SpaceShip the Engine is mounted on.
     264            unsigned int shipID_; //!< Object ID of the SpaceShip the Engine is mounted on.
     265            Vector3 relativePosition_; //!< The relative position of the Engine with respect to the SpaceShip it is mounted on.
     266
     267            float boostFactor_; //!< The factor by which boosting increases the forward acceleration.
     268
     269            float speedAdd_; //!< Additional forward speed. Is not bounded by the maximal forward speed.
     270            float speedMultiply_; //!< Forward speed multiplication factor. Is not bounded by the maximal forward speed.
     271
     272            float maxSpeedFront_; //!< The maximal forward speed.
     273            float maxSpeedBack_; //!< The maximal backward speed.
     274            float maxSpeedLeftRight_; //!< The maximal left-right speed.
     275            float maxSpeedUpDown_; //!< The maximal up-down speed.
     276
     277            float accelerationFront_; //!< Forward acceleration produced by the Engine.
     278            float accelerationBrake_; //!< Breaking acceleration produced by the Engine.
     279            float accelerationBack_; //!< Backward acceleration produced by the Engine.
     280            float accelerationLeftRight_; //!< Left-right acceleration produced by the Engine.
     281            float accelerationUpDown_; //!< Up-down acceleration produced by the Engine.
     282
    165283    };
    166284}
Note: See TracChangeset for help on using the changeset viewer.