Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Ignore:
Timestamp:
May 25, 2011, 9:07:17 PM (14 years ago)
Author:
dafrick
Message:

Cleanup. Adding shield and boost shaking to Assff.

Location:
code/branches/gameimmersion/src/orxonox/worldentities/pawns
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • code/branches/gameimmersion/src/orxonox/worldentities/pawns/Pawn.cc

    r8575 r8577  
    130130        XMLPortParam(Pawn, "reloadrate", setReloadRate, getReloadRate, xmlelement, mode).defaultValues(0);
    131131        XMLPortParam(Pawn, "reloadwaittime", setReloadWaitTime, getReloadWaitTime, xmlelement, mode).defaultValues(1.0f);
    132 
    133         //TODO: DEFINES fuer defaultwerte (hier und weiter oben dieselben)
    134132    }
    135133
    … …  
    227225    }
    228226
    229     /* Old damage function.
    230      * For effects causing only damage not specifically to shield or health
    231      */
    232     void Pawn::damage(float damage, Pawn* originator)
    233     {
    234         if (this->getGametype() && this->getGametype()->allowPawnDamage(this, originator))
    235         {
    236             //share the dealt damage to the shield and the Pawn.
    237             float shielddamage = damage*this->shieldAbsorption_;
    238             float healthdamage = damage*(1-this->shieldAbsorption_);
    239 
    240             // In case the shield can not take all the shield damage.
    241             if (shielddamage > this->getShieldHealth())
    242             {
    243                 healthdamage += shielddamage-this->getShieldHealth();
    244                 this->setShieldHealth(0);
    245             }
    246 
    247             this->setHealth(this->health_ - healthdamage);
    248 
    249             if (this->getShieldHealth() > 0)
    250             {
    251                 this->setShieldHealth(this->shieldHealth_ - shielddamage);
    252             }
    253 
    254             this->lastHitOriginator_ = originator;
    255 
    256             // play damage effect
    257         }
    258     }
    259 
    260     /* Does damage to the pawn, splits it up to shield and health.
    261      * Sets lastHitOriginator.
    262      */
    263227    void Pawn::damage(float damage, float healthdamage, float shielddamage, Pawn* originator)
    264228    {
    … …  
    284248
    285249            this->lastHitOriginator_ = originator;
    286 
    287             // play damage effect
    288         }
    289     }
    290 
    291 
     250        }
     251    }
     252
     253// TODO: Still valid?
    292254/* HIT-Funktionen
    293255    Die hit-Funktionen muessen auch in src/orxonox/controllers/Controller.h angepasst werden! (Visuelle Effekte)
    … …  
    295257*/
    296258
    297     /* Old hit function, calls the old damage function and changes velocity vector
    298      */
    299     void Pawn::hit(Pawn* originator, const Vector3& force, float damage)
    300     {
    301         if (this->getGametype() && this->getGametype()->allowPawnHit(this, originator) && (!this->getController() || !this->getController()->getGodMode()) )
    302         {
    303             this->damage(damage, originator);
    304             this->setVelocity(this->getVelocity() + force);
    305 
    306             // play hit effect
    307         }
    308     }
    309 
    310     /* calls the damage function and adds the force that hit the pawn to the velocity vector
    311      */
    312259    void Pawn::hit(Pawn* originator, const Vector3& force, float damage, float healthdamage, float shielddamage)
    313260    {
    … …  
    316263            this->damage(damage, healthdamage, shielddamage, originator);
    317264            this->setVelocity(this->getVelocity() + force);
    318 
    319             // play hit effect
    320         }
    321     }
    322 
    323     /* Old hit (2) function, calls the old damage function and hits controller
    324      */
    325     void Pawn::hit(Pawn* originator, btManifoldPoint& contactpoint, float damage)
    326     {
    327         if (this->getGametype() && this->getGametype()->allowPawnHit(this, originator) && (!this->getController() || !this->getController()->getGodMode()) )
    328         {
    329             this->damage(damage, originator);
    330 
    331             if ( this->getController() )
    332                 this->getController()->hit(originator, contactpoint, damage);
    333 
    334             // play hit effect
    335         }
    336     }
    337 
    338     /* Hit (2) function, calls the damage function and hits controller
    339      */
     265        }
     266    }
     267
     268
    340269    void Pawn::hit(Pawn* originator, btManifoldPoint& contactpoint, float damage, float healthdamage, float shielddamage)
    341270    {
    … …  
    346275            if ( this->getController() )
    347276                this->getController()->hit(originator, contactpoint, damage); // changed to damage, why shielddamage?
    348 
    349             // play hit effect
    350277        }
    351278    }

  • code/branches/gameimmersion/src/orxonox/worldentities/pawns/Pawn.h

    r8386 r8577  
    5353            inline bool isAlive() const
    5454                { return this->bAlive_; }
    55 
    56 ///////////////////////////////// me
    57             virtual void setReloadRate(float reloadrate);
    58             inline float getReloadRate() const
    59                 { return this->reloadRate_; }
    60 
    61             inline void addShieldHealth(float amount)
    62             { this->setShieldHealth(this->shieldHealth_ + amount); }
    63 
    64             inline bool hasShield()
    65             { return (this->getShieldHealth() > 0); }
    66 
    67             virtual void setReloadWaitTime(float reloadwaittime);
    68             inline float getReloadWaitTime() const
    69                 { return this->reloadWaitTime_; }
    70 
    71             inline void resetReloadCountdown()
    72             { this->reloadWaitCountdown_ = 0; }
    73 
    74             inline void startReloadCountdown()
    75             { this->reloadWaitCountdown_ = this->getReloadWaitTime(); } //in projectile.cc einbauen!!!!!!1111!!111!
    76 
    77             virtual void decreaseReloadCountdownTime(float dt);
    78 
    79             virtual void setMaxShieldHealth(float maxshieldhealth);
    80             inline float getMaxShieldHealth() const
    81                 { return this->maxShieldHealth_; }
    82 
    83             inline void setInitialShieldHealth(float initialshieldhealth)
    84                 { this->initialShieldHealth_ = initialshieldhealth; this->setShieldHealth(initialshieldhealth); }
    85             inline float getInitialShieldHealth() const
    86                 { return this->initialShieldHealth_; }
    87 
    88             inline void restoreInitialShieldHealth()
    89                 { this->setShieldHealth(this->initialShieldHealth_); }
    90             inline void restoreMaxShieldHealth()
    91                 { this->setShieldHealth(this->maxShieldHealth_); }
    92 
    93 
    94 ///////////////////////////////// end me
    9555
    9656            virtual void setHealth(float health);
    … …  
    11777            { return this->shieldHealth_; }
    11878
     79            inline void addShieldHealth(float amount)
     80            { this->setShieldHealth(this->shieldHealth_ + amount); }
     81
     82            inline bool hasShield()
     83            { return (this->getShieldHealth() > 0); }
     84
     85            virtual void setMaxShieldHealth(float maxshieldhealth);
     86            inline float getMaxShieldHealth() const
     87                { return this->maxShieldHealth_; }
     88
     89            inline void setInitialShieldHealth(float initialshieldhealth)
     90                { this->initialShieldHealth_ = initialshieldhealth; this->setShieldHealth(initialshieldhealth); }
     91            inline float getInitialShieldHealth() const
     92                { return this->initialShieldHealth_; }
     93
     94            inline void restoreInitialShieldHealth()
     95                { this->setShieldHealth(this->initialShieldHealth_); }
     96            inline void restoreMaxShieldHealth()
     97                { this->setShieldHealth(this->maxShieldHealth_); }
     98
    11999            inline void setShieldAbsorption(float shieldAbsorption)
    120100            { this->shieldAbsorption_ = shieldAbsorption; }
    … …  
    122102            { return this->shieldAbsorption_; }
    123103
     104            // TODO: Rename to shieldRechargeRate
     105            virtual void setReloadRate(float reloadrate);
     106            inline float getReloadRate() const
     107                { return this->reloadRate_; }
     108
     109            virtual void setReloadWaitTime(float reloadwaittime);
     110            inline float getReloadWaitTime() const
     111                { return this->reloadWaitTime_; }
     112
     113            inline void resetReloadCountdown()
     114            { this->reloadWaitCountdown_ = 0; }
     115
     116            inline void startReloadCountdown()
     117            { this->reloadWaitCountdown_ = this->getReloadWaitTime(); } // TODO: Implement in Projectile.cc
     118
     119            virtual void decreaseReloadCountdownTime(float dt);
     120
    124121            inline ControllableEntity* getLastHitOriginator() const
    125122                { return this->lastHitOriginator_; }
    126123
    127             virtual void hit(Pawn* originator, const Vector3& force, float damage);
    128             virtual void hit(Pawn* originator, btManifoldPoint& contactpoint, float damage);
    129 /////////me
    130             virtual void hit(Pawn* originator, const Vector3& force, float damage, float healthdamage, float shielddamage);
    131             virtual void hit(Pawn* originator, btManifoldPoint& contactpoint, float damage, float healthdamage, float shielddamage);
    132 ////////end me
     124            //virtual void hit(Pawn* originator, const Vector3& force, float damage);
     125            //virtual void hit(Pawn* originator, btManifoldPoint& contactpoint, float damage);
     126            virtual void hit(Pawn* originator, const Vector3& force, float damage, float healthdamage = 0.0f, float shielddamage = 0.0f);
     127            virtual void hit(Pawn* originator, btManifoldPoint& contactpoint, float damage, float healthdamage = 0.0f, float shielddamage = 0.0f);
     128
    133129            virtual void kill();
    134130
    … …  
    186182            virtual void spawneffect();
    187183
    188             virtual void damage(float damage, Pawn* originator = 0);
    189 //////////me
    190             virtual void damage(float damage, float healthdamage, float shielddamage, Pawn* originator);
    191 /////////end me
     184            //virtual void damage(float damage, Pawn* originator = 0);
     185            virtual void damage(float damage, float healthdamage = 0.0f, float shielddamage = 0.0f, Pawn* originator = NULL);
    192186
    193187            bool bAlive_;
    … …  
    198192                { return NULL; }
    199193
    200 /////////////////////////// me
     194            float health_;
     195            float maxHealth_;
     196            float initialHealth_;
     197           
     198            float shieldHealth_;
     199            float maxShieldHealth_;
     200            float initialShieldHealth_;
     201            float shieldAbsorption_; // Has to be between 0 and 1
    201202            float reloadRate_;
    202203            float reloadWaitTime_;
    203204            float reloadWaitCountdown_;
    204 
    205             float maxShieldHealth_;
    206             float initialShieldHealth_;
    207 
    208 ////////////////////////// end me
    209 
    210             float health_;
    211             float maxHealth_;
    212             float initialHealth_;
    213             float shieldHealth_;
    214             float shieldAbsorption_; // Has to be between 0 and 1
    215205
    216206            WeakPtr<Pawn> lastHitOriginator_;

  • code/branches/gameimmersion/src/orxonox/worldentities/pawns/SpaceShip.cc

    r8575 r8577  
    107107        XMLPortParamVariable(SpaceShip, "boostCooldownDuration", boostCooldownDuration_, xmlelement, mode);
    108108        XMLPortParamVariable(SpaceShip, "shakeFrequency", shakeFrequency_, xmlelement, mode);
     109        XMLPortParamVariable(SpaceShip, "shakeAmplitude", shakeAmplitude_, xmlelement, mode);
    109110    }
    110111
    … …  
    114115        registerVariable(this->auxilaryThrust_, VariableDirection::ToClient);
    115116        registerVariable(this->rotationThrust_, VariableDirection::ToClient);
     117        // TODO: Synchronization of boost needed?
    116118        registerVariable(this->boostPower_, VariableDirection::ToClient);
    117119        registerVariable(this->boostPowerRate_, VariableDirection::ToClient);
    … …  
    119121        registerVariable(this->boostCooldownDuration_, VariableDirection::ToClient);
    120122        registerVariable(this->shakeFrequency_, VariableDirection::ToClient);
     123        registerVariable(this->shakeAmplitude_, VariableDirection::ToClient);
    121124    }
    122125
Note: See TracChangeset for help on using the changeset viewer.