Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Changeset 11052 for code/trunk/src


Ignore:
Timestamp:
Jan 9, 2016, 6:26:20 PM (8 years ago)
Author:
landauf
Message:

merged branch presentationHS15 back to trunk

Location:
code/trunk
Files:
4 deleted
122 edited
49 copied

Legend:

Unmodified
Added
Removed

  • code/trunk

  • code/trunk/src/libraries/core/CoreConfig.cc

    • Property svn:eol-style set to native

  • code/trunk/src/libraries/core/CoreConfig.h

    • Property svn:eol-style set to native

  • code/trunk/src/libraries/core/GUIManager.cc

    r10624 r11052  
    3636#include <OgreRenderWindow.h>
    3737
     38extern "C" {
     39#include <lua.h>
     40}
     41
    3842#if CEGUI_VERSION >= 0x000800
    3943#   include <CEGUI/DefaultLogger.h>
    … …  
    251255    /*static*/ const std::string GUIManager::defaultScheme_ = "TaharezGreen"; //Alternative: Orxonox (not fully complete yet, see the graphics menu)
    252256
    253     SetConsoleCommand("showGUI", &GUIManager::showGUI).defaultValue(1, false).defaultValue(2, false);
    254     SetConsoleCommand("hideGUI", &GUIManager::hideGUI);
    255     SetConsoleCommand("toggleGUI", &GUIManager::toggleGUI).defaultValue(1, false).defaultValue(2, false);
     257    namespace autocompletion
     258    {
     259        /**
     260            @brief Returns the names of all currently existing OverlayGroups.
     261        */
     262        ARGUMENT_COMPLETION_FUNCTION_DECLARATION(guinames)();
     263        ARGUMENT_COMPLETION_FUNCTION_IMPLEMENTATION(guinames)()
     264        {
     265            ArgumentCompletionList names;
     266            const std::vector<std::string> guis = GUIManager::getInstance().getLoadedGUIs();
     267            for (size_t i = 0; i < guis.size(); ++i)
     268                names.push_back(ArgumentCompletionListElement(guis[i], getLowercase(guis[i])));
     269            return names;
     270        }
     271    }
     272
     273    SetConsoleCommand("showGUI", &GUIManager::showGUI).defaultValue(1, false).defaultValue(2, false)
     274            .argumentCompleter(0, autocompletion::guinames());
     275    SetConsoleCommand("hideGUI", &GUIManager::hideGUI)
     276            .argumentCompleter(0, autocompletion::guinames());
     277    SetConsoleCommand("toggleGUI", &GUIManager::toggleGUI).defaultValue(1, false).defaultValue(2, false)
     278            .argumentCompleter(0, autocompletion::guinames());
    256279
    257280    RegisterAbstractClass(GUIManager).inheritsFrom<WindowEventListener>();
    … …  
    489512    {
    490513        this->luaState_->doString(str, rootFileInfo_);
     514    }
     515
     516    std::vector<std::string> GUIManager::getLoadedGUIs()
     517    {
     518        // TODO: is there a better way to read back a return value from lua? i.e. by using LuaState?
     519        lua_State* L = this->luaState_->getInternalLuaState();
     520
     521        // push function
     522        lua_getglobal(L, "getLoadedSheets");
     523
     524        // do the call (0 arguments, 1 result)
     525        if (lua_pcall(L, 0, 1, 0) != 0)
     526          orxout(internal_error) << "error running function: " << lua_tostring(L, -1) << endl;
     527
     528        // retrieve result
     529        if (!lua_isstring(L, -1))
     530          orxout(internal_error) << "function must return a string" << endl;
     531        std::string value = lua_tostring(L, -1);
     532        lua_pop(L, 1);
     533
     534        SubString tokens(value, ",");
     535        return tokens.getAllStrings();
    491536    }
    492537

  • code/trunk/src/libraries/core/GUIManager.h

    r9675 r11052  
    107107        void preUpdate(const Clock& time);
    108108
     109        std::vector<std::string> getLoadedGUIs();
     110
    109111        void loadGUI(const std::string& name);
    110112        static void showGUI(const std::string& name, bool bHidePrevious = false, bool bNoInput = false);

  • code/trunk/src/libraries/core/GameConfig.cc

    • Property svn:eol-style set to native

  • code/trunk/src/libraries/core/GameConfig.h

    • Property svn:eol-style set to native

  • code/trunk/src/libraries/core/command/ArgumentCompletionFunctions.h

    r7401 r11052  
    161161*/
    162162#define ARGUMENT_COMPLETION_FUNCTION_DECLARATION(functionname) \
    163     _CoreExport ArgumentCompleter* functionname(); \
    164     _CoreExport ArgumentCompletionList acf_##functionname
     163    ArgumentCompleter* functionname(); \
     164    ArgumentCompletionList acf_##functionname
    165165
    166166/**
    … …  
    196196    namespace autocompletion
    197197    {
    198         ARGUMENT_COMPLETION_FUNCTION_DECLARATION(fallback)();
    199         ARGUMENT_COMPLETION_FUNCTION_DECLARATION(groupsandcommands)(const std::string& fragment);
    200         ARGUMENT_COMPLETION_FUNCTION_DECLARATION(subcommands)(const std::string& fragment, const std::string& group);
    201         ARGUMENT_COMPLETION_FUNCTION_DECLARATION(command)(const std::string& fragment);
    202         ARGUMENT_COMPLETION_FUNCTION_DECLARATION(hiddencommand)(const std::string& fragment);
    203         ARGUMENT_COMPLETION_FUNCTION_DECLARATION(files)(const std::string& fragment);
    204         ARGUMENT_COMPLETION_FUNCTION_DECLARATION(settingssections)();
    205         ARGUMENT_COMPLETION_FUNCTION_DECLARATION(settingsentries)(const std::string& fragment, const std::string& section);
    206         ARGUMENT_COMPLETION_FUNCTION_DECLARATION(settingsvalue)(const std::string& fragment, const std::string& entry, const std::string& section);
    207         ARGUMENT_COMPLETION_FUNCTION_DECLARATION(tclthreads)();
     198        _CoreExport ARGUMENT_COMPLETION_FUNCTION_DECLARATION(fallback)();
     199        _CoreExport ARGUMENT_COMPLETION_FUNCTION_DECLARATION(groupsandcommands)(const std::string& fragment);
     200        _CoreExport ARGUMENT_COMPLETION_FUNCTION_DECLARATION(subcommands)(const std::string& fragment, const std::string& group);
     201        _CoreExport ARGUMENT_COMPLETION_FUNCTION_DECLARATION(command)(const std::string& fragment);
     202        _CoreExport ARGUMENT_COMPLETION_FUNCTION_DECLARATION(hiddencommand)(const std::string& fragment);
     203        _CoreExport ARGUMENT_COMPLETION_FUNCTION_DECLARATION(files)(const std::string& fragment);
     204        _CoreExport ARGUMENT_COMPLETION_FUNCTION_DECLARATION(settingssections)();
     205        _CoreExport ARGUMENT_COMPLETION_FUNCTION_DECLARATION(settingsentries)(const std::string& fragment, const std::string& section);
     206        _CoreExport ARGUMENT_COMPLETION_FUNCTION_DECLARATION(settingsvalue)(const std::string& fragment, const std::string& entry, const std::string& section);
     207        _CoreExport ARGUMENT_COMPLETION_FUNCTION_DECLARATION(tclthreads)();
    208208    }
    209209}

  • code/trunk/src/libraries/core/command/ConsoleCommandIncludes.cc

    • Property svn:eol-style set to native

  • code/trunk/src/libraries/core/command/ConsoleCommandManager.cc

    • Property svn:eol-style set to native

  • code/trunk/src/libraries/core/commandline/CMakeLists.txt

    • Property svn:eol-style set to native

  • code/trunk/src/libraries/core/input/KeyBinder.cc

    r10624 r11052  
    359359    /**
    360360    @brief
     361        Return the first key name for a specific command in a human readable form
     362    */
     363    const std::string& KeyBinder::getBindingReadable(const std::string& commandName)
     364    {
     365        const std::string& binding = this->getBinding(commandName);
     366
     367        SubString substring = SubString(binding, ".");
     368        std::string name;
     369        std::string group;
     370        switch(substring.size())
     371        {
     372            case 0:
     373                return binding;
     374            case 1:
     375                return binding;
     376            case 2:
     377                group = substring[0];
     378            default:
     379                name = substring.subSet(1).join(".");
     380        }
     381
     382        std::stringstream stream;
     383        if(group.compare("Keys") == 0)
     384            stream << "Key " << name.substr(3);
     385        else if(group.compare("MouseButtons") == 0)
     386            stream << "Mouse " << name;
     387        else if(group.compare("JoyStickButtons") == 0)
     388            stream << "Joystick " << name;
     389        else if(group.compare("JoyStickAxes") == 0)
     390            stream << "Joystick Axis" << name.substr(5, 6) << name.substr(name.find("Axis")+6);
     391        else if(group.compare("MouseAxes") == 0)
     392            stream << "Mouse " << name.substr(1,3) << " " << name.substr(0, 1) << "-Axis";
     393        else
     394            return binding;
     395
     396        return *(new std::string(stream.str()));
     397    }
     398
     399    /**
     400    @brief
    361401        Get the number of different key bindings of a specific command.
    362402    @param commandName

  • code/trunk/src/libraries/core/input/KeyBinder.h

    r9978 r11052  
    6868        const std::string& getBinding(const std::string& commandName); //tolua_export
    6969        const std::string& getBinding(const std::string& commandName, unsigned int index); //tolua_export
     70        const std::string& getBindingReadable(const std::string& commandName); //tolua_export
    7071        unsigned int getNumberOfBindings(const std::string& commandName); //tolua_export
    7172

  • code/trunk/src/libraries/core/singleton/ScopedSingletonIncludes.cc

    • Property svn:eol-style set to native

  • code/trunk/src/libraries/core/singleton/ScopedSingletonIncludes.h

    • Property svn:eol-style set to native

  • code/trunk/src/libraries/network/NetworkFunctionIncludes.cc

    • Property svn:eol-style set to native

  • code/trunk/src/libraries/network/NetworkFunctionIncludes.h

    • Property svn:eol-style set to native

  • code/trunk/src/libraries/network/NetworkFunctionManager.cc

    • Property svn:eol-style set to native

  • code/trunk/src/libraries/network/NetworkFunctionManager.h

    • Property svn:eol-style set to native

  • code/trunk/src/libraries/tools/ParticleInterface.cc

    r10624 r11052  
    233233            this->particleSystem_->setKeepParticlesInLocalSpace(keep);
    234234    }
     235
     236    void ParticleInterface::setDimensions(float scale)
     237    {
     238        this->particleSystem_->setDefaultDimensions(scale * this->particleSystem_->getDefaultWidth(), scale * this->particleSystem_->getDefaultHeight());
     239    }
    235240}

  • code/trunk/src/libraries/tools/ParticleInterface.h

    r10624 r11052  
    7575            void setDetailLevel(unsigned int level);
    7676
     77            void setDimensions(float scale);
     78
    7779        protected:
    7880            virtual void changedTimeFactor(float factor_new, float factor_old);

  • code/trunk/src/libraries/util/Math.cc

    r10630 r11052  
    161161         - If the other object is exactly above me, the function returns <tt>Vector2(0, 0.5)</tt>.
    162162    */
    163     orxonox::Vector2 get2DViewcoordinates(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& myorthonormal, const orxonox::Vector3& otherposition)
     163    orxonox::Vector2 get2DViewCoordinates(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& myorthonormal, const orxonox::Vector3& otherposition)
    164164    {
    165165        orxonox::Vector3 distance = otherposition - myposition;

  • code/trunk/src/libraries/util/Math.h

    r9939 r11052  
    9191    _UtilExport float getAngle(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& otherposition);
    9292    _UtilExport orxonox::Vector2 get2DViewdirection(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& myorthonormal, const orxonox::Vector3& otherposition);
    93     _UtilExport orxonox::Vector2 get2DViewcoordinates(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& myorthonormal, const orxonox::Vector3& otherposition);
     93    _UtilExport orxonox::Vector2 get2DViewCoordinates(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& myorthonormal, const orxonox::Vector3& otherposition);
    9494    _UtilExport orxonox::Vector2 get3DProjection(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& myorthonormal, const orxonox::Vector3& otherposition, const float mapangle, const float detectionlimit);
    9595    _UtilExport bool isObjectHigherThanShipOnMap(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& myorthonormal, const orxonox::Vector3& otherposition, const float mapangle);

  • code/trunk/src/modules/CMakeLists.txt

    r10258 r11052  
    4343ADD_SUBDIRECTORY(mini4dgame)
    4444ADD_SUBDIRECTORY(dodgerace)
     45ADD_SUBDIRECTORY(hover)

  • code/trunk/src/modules/docking/DockingController.cc

    r9667 r11052  
    6161
    6262        float distance = (this->dock_->getWorldPosition() - entity->getPosition()).length();
    63         Vector2 coord = get2DViewcoordinates(     // I don't understand this too
     63        Vector2 coord = get2DViewCoordinates(     // I don't understand this too
    6464            entity->getPosition(),
    6565            entity->getOrientation() * WorldEntity::FRONT,

  • code/trunk/src/modules/dodgerace/DodgeRace.cc

    r10624 r11052  
    7171            for (int i = 0; i < 7; i++)
    7272            {
    73                 BigExplosion* chunk = new BigExplosion(this->center_->getContext());
    74                 chunk->setPosition(Vector3(600, 0, 100.f * i - 300));
    75                 chunk->setVelocity(Vector3(1000, 0, 0));  //player->getVelocity()
    76                 chunk->setScale(20);
     73                WeakPtr<ExplosionPart> chunk5 = new ExplosionPart(this->center_->getContext());
     74                chunk5->setPosition(Vector3(600, 0, 100.f * i - 300));
     75                chunk5->setVelocity(Vector3(1000, 0, 0));  //player->getVelocity()
     76                chunk5->setScale(10);
     77                chunk5->setEffect1("Orxonox/explosion2b");
     78                chunk5->setEffect2("Orxonox/smoke6");
     79                chunk5->Explode();
     80
    7781            }
    7882        }

  • code/trunk/src/modules/dodgerace/DodgeRace.h

    r10624 r11052  
    5656
    5757#include "core/command/ConsoleCommand.h"
    58 #include "worldentities/BigExplosion.h"
    5958
    6059#include "gametypes/Deathmatch.h"

  • code/trunk/src/modules/invader/Invader.cc

    r10624 r11052  
    5151
    5252#include "core/command/ConsoleCommand.h"
    53 #include "worldentities/BigExplosion.h"
     53#include "worldentities/ExplosionPart.h"
    5454
    5555namespace orxonox
    … …  
    8282            for (int i = 0; i < 7; i++)
    8383            {
    84                 BigExplosion* chunk = new BigExplosion(this->center_->getContext());
    85                 chunk->setPosition(Vector3(600, 0, 100.f * i - 300));
    86                 chunk->setVelocity(Vector3(1000, 0, 0));  //player->getVelocity()
    87                 chunk->setScale(20);
     84
     85                WeakPtr<ExplosionPart> chunk5 = new ExplosionPart(this->center_->getContext());
     86                chunk5->setPosition(this->center_->getPosition());
     87                chunk5->setVelocity(Vector3(1000, 0, 0));  //player->getVelocity()
     88                chunk5->setScale(10);
     89                chunk5->setEffect1("Orxonox/explosion2b");
     90                chunk5->setEffect2("Orxonox/smoke6");
     91                chunk5->setMinSpeed(0);
     92                chunk5->setMaxSpeed(0);
     93                chunk5->Explode();
     94
    8895            }
    8996        }

  • code/trunk/src/modules/notifications/dispatchers/CommandNotification.cc

    r9667 r11052  
    101101        std::stringstream stream;
    102102        stream << this->getPreMessage();
    103         stream << this->bindingNiceifyer(KeyBinderManager::getInstance().getCurrent()->getBinding(this->getCommand()));
     103        stream << KeyBinderManager::getInstance().getCurrent()->getBindingReadable(this->getCommand());
    104104        stream << this->getPostMessage();
    105105        return *(new std::string(stream.str()));
    106106    }
    107 
    108     /**
    109     @brief
    110         Transforms the input binding into a human readable form.
    111     @param binding
    112         The binding to be transformed
    113     @return
    114         Returns a human readable version of the input binding.
    115     */
    116     //TODO: Move to KeyBinderManager...
    117     const std::string& CommandNotification::bindingNiceifyer(const std::string& binding)
    118     {
    119         SubString substring = SubString(binding, ".");
    120         std::string name;
    121         std::string group;
    122         switch(substring.size())
    123         {
    124             case 0:
    125                 return binding;
    126             case 1:
    127                 return binding;
    128             case 2:
    129                 group = substring[0];
    130             default:
    131                 name = substring.subSet(1).join(".");
    132         }
    133 
    134         std::stringstream stream;
    135         if(group.compare("Keys") == 0)
    136             stream << "Key " << name.substr(3);
    137         else if(group.compare("MouseButtons") == 0)
    138             stream << "Mouse " << name;
    139         else if(group.compare("JoyStickButtons") == 0)
    140             stream << "Joystick " << name;
    141         else if(group.compare("JoyStickAxes") == 0)
    142             stream << "Joystick Axis" << name.substr(5, 6) << name.substr(name.find("Axis")+6);
    143         else if(group.compare("MouseAxes") == 0)
    144             stream << "Mouse " << name.substr(1,3) << " " << name.substr(0, 1) << "-Axis";
    145         else
    146             return binding;
    147 
    148         return *(new std::string(stream.str()));
    149     }
    150 
    151107}

  • code/trunk/src/modules/notifications/dispatchers/CommandNotification.h

    r9667 r11052  
    122122            void setPostMessage(const std::string& message)
    123123                 { this->postMessage_ = message; }
    124 
    125             const std::string& bindingNiceifyer(const std::string& binding); //!< Transforms the input binding into a human readable form.
    126 
    127124    };
    128125

  • code/trunk/src/modules/objects/Turret.h

    r10622 r11052  
    103103
    104104            inline void setRotationThrust(float rotationthrust)
    105                 { this->rotationThrust_ = rotationthrust; }
     105                { this->rotationThrust_ = rotationthrust; }
    106106
    107107            inline float getRotationThrust()
    108                 { return this->rotationThrust_; }
     108                { return this->rotationThrust_; }
    109109
    110110        protected:

  • code/trunk/src/modules/overlays/OverlaysPrereqs.h

    r9939 r11052  
    9090    class HUDRadar;
    9191    class HUDSpeedBar;
     92    class HUDShieldBar;
    9293    class HUDBoostBar;
     94    class HUDRocketFuelBar;
     95    class HUDEnemyHealthBar;
     96    class HUDEnemyShieldBar;
     97    class HUDWeaponSystem;
     98    class HUDWeapon;
     99    class HUDWeaponMode;
    93100    class HUDTimer;
    94101    class HUDAimAssistant;

  • code/trunk/src/modules/overlays/hud/CMakeLists.txt

    r9939 r11052  
    55  HUDSpeedBar.cc
    66  HUDBoostBar.cc
     7  HUDShieldBar.cc
    78  HUDHealthBar.cc
     9  HUDRocketFuelBar.cc
    810  HUDTimer.cc
    911  HUDEnemyHealthBar.cc
     12  HUDEnemyShieldBar.cc
     13  HUDWeaponMode.cc
     14  HUDWeapon.cc
     15  HUDWeaponSystem.cc
    1016  ChatOverlay.cc
    1117  AnnounceMessage.cc

  • code/trunk/src/modules/overlays/hud/HUDBar.cc

    r9667 r11052  
    4747    RegisterClass(BarColour);
    4848
    49     BarColour::BarColour(Context* context)
    50         : BaseObject(context)
     49    BarColour::BarColour(Context* context) : BaseObject(context)
    5150    {
    5251        RegisterObject(BarColour);
    53 
     52       
    5453        this->setColour(ColourValue(1.0, 1.0, 1.0, 1.0));
    5554        this->setPosition(0.0);
    … …  
    6968    RegisterClass(HUDBar);
    7069
    71     HUDBar::HUDBar(Context* context)
    72         : OrxonoxOverlay(context), right2Left_(false), autoColour_(false)
     70    HUDBar::HUDBar(Context* context) : OrxonoxOverlay(context), right2Left_(false), autoColour_(false)
    7371    {
    7472        RegisterObject(HUDBar);
    … …  
    8886        this->bar_->setMaterialName(materialname);
    8987
     88        this->bar_->setPosition(0.0f,0.0f);
     89        this->bar_->setDimensions(1.0f,1.0f);
     90
     91        this->bUseIcon_ = false;
    9092        this->value_ = 1.0f;  // initialize with 1.0f to trigger a change when calling setValue(0.0f) on the line below
    9193        this->setAutoColour(true);
    … …  
    9597
    9698        this->background_->addChild(bar_);
     99
     100        this->icon_ = static_cast<Ogre::PanelOverlayElement* >(Ogre::OverlayManager::getSingleton().createOverlayElement("Panel", "HUDBar_icon_" + getUniqueNumberString()));
     101        this->icon_->setPosition(0.06f,0.0f);
     102        this->icon_->setDimensions(0.1f,1.0f);
     103        this->background_->addChild(this->icon_);
    97104    }
    98105
    … …  
    115122        XMLPortParam(HUDBar, "autocolour",   setAutoColour,  getAutoColour,  xmlelement, mode);
    116123        XMLPortParam(HUDBar, "bartexture",   setBarTexture,  getBarTexture, xmlelement, mode);
     124        XMLPortParam(HUDBar, "iconmaterial", setIconMaterial, getIconMaterial, xmlelement, mode);
    117125        XMLPortObject(HUDBar, BarColour, "", addColour, getColour, xmlelement, mode);
    118126    }
    … …  
    161169        }
    162170
     171        float height = this->bar_->getHeight();
     172        float top = this->bar_->getTop();
     173
    163174        // set value
    164175        if (this->right2Left_)
    165176        {
    166177            // backward case
    167             this->bar_->setPosition(0.06f + 0.88f * (1 - this->value_), 0.0f);
    168             this->bar_->setDimensions(0.88f * this->value_, 1.0f);
     178            if (this->bUseIcon_)
     179            {
     180                this->bar_->setPosition(0.16f + 0.78f * (1 - this->value_), top);
     181                this->bar_->setDimensions(0.78f * this->value_, height);
     182            }
     183            else
     184            {
     185                this->bar_->setPosition(0.06f + 0.88f * (1 - this->value_), top);
     186                this->bar_->setDimensions(0.88f * this->value_, height);
     187            }
    169188        }
    170189        else
    171190        {
    172191            // default case
    173             this->bar_->setPosition(0.06f, 0.0f);
    174             this->bar_->setDimensions(0.88f * this->value_, 1.0f);
    175         }
     192            if (this->bUseIcon_)
     193            {
     194                this->bar_->setPosition(0.16f, top);
     195                this->bar_->setDimensions(0.78f * this->value_, height);
     196            }
     197            else
     198            {
     199                this->bar_->setPosition(0.06f, top);
     200                this->bar_->setDimensions(0.88f * this->value_, height);
     201            }
     202        }
     203
    176204        if (this->value_ != 0)
    177205            this->bar_->setTiling(this->value_, 1.0);
    … …  
    208236        return this->textureUnitState_->getTextureName();
    209237    }
     238
     239    void HUDBar::setIconMaterial(const std::string& iconMaterial)
     240    {
     241        this->bUseIcon_ = true;
     242        this->icon_->setMaterialName(iconMaterial);
     243        valueChanged();
     244    }
     245
     246    const std::string& HUDBar::getIconMaterial() const
     247    {
     248        return this->icon_->getMaterialName();
     249    }
    210250}

  • code/trunk/src/modules/overlays/hud/HUDBar.h

    r9667 r11052  
    3737#include <map>
    3838#include <vector>
     39#include <OgrePanelOverlayElement.h>
    3940
    4041#include "util/Math.h"
    … …  
    5152        virtual ~BarColour() { }
    5253
    53         virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
     54        virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);     
    5455
    5556        void setColour(const ColourValue& colour) { this->colour_ = colour; }
    … …  
    115116        const std::string& getBarTexture() const;
    116117
     118        void setIconMaterial(const std::string& iconMaterial);
     119        const std::string& getIconMaterial() const;
     120
    117121        inline const ColourValue& getCurrentBarColour() const
    118122            { return this->currentColour_; }
    119123
     124        inline void setIconPosition(Vector2 position)
     125            { this->icon_->setPosition(position.x, position.y); }
     126        inline void setIconDimensions(Vector2 dimensions)
     127            { this->icon_->setDimensions(dimensions.x, dimensions.y); }
     128
    120129    protected:
    121130        virtual void valueChanged();
    122 
    123131    private:
    124132        void addColour(BarColour* colour);
    … …  
    129137        float value_;                       //!< progress of bar
    130138        ColourValue currentColour_;
     139        bool bUseIcon_;
    131140
    132141        Ogre::PanelOverlayElement* bar_;
    133142        Ogre::TextureUnitState* textureUnitState_;
     143        Ogre::PanelOverlayElement* icon_;
    134144        std::map<float, ColourValue> colours_;
    135145        std::vector<BarColour*> barColours_;

  • code/trunk/src/modules/overlays/hud/HUDBoostBar.cc

    r9667 r11052  
    5959            if (this->owner_->isBoostCoolingDown())
    6060            {
    61                 this->setBackgroundColour(ColourValue(0.7f, 0.2f, 0.2f));
     61                //this->setBackgroundColour(ColourValue(0.7f, 0.2f, 0.2f));
    6262                if (this->flashDt_ <= 0.0f)
    6363                {
    … …  
    7272                this->flashDt_ = 0.0f;
    7373                this->show();
    74                 this->setBackgroundColour(ColourValue(0.2f, 0.7f, 0.2f));
     74                //this->setBackgroundColour(ColourValue(0.2f, 0.7f, 0.2f));
    7575            }
    7676

  • code/trunk/src/modules/overlays/hud/HUDHealthBar.cc

    r9667 r11052  
    4545        this->owner_ = 0;
    4646        this->bUseBarColour_ = false;
     47        this->textOffset_ = Vector2(0.0f, 0.0f);
     48        this->textScale_ = 1.0f;
     49
     50        this->setIconPosition(Vector2(0.05f,0.5f));
     51        this->setIconDimensions(Vector2(0.1f,0.5f));
    4752
    4853        this->textoverlay_ = new OverlayText(this->getContext());
    … …  
    5156
    5257        this->textoverlay_->setCaption("");
     58        this->textoverlay_->setAspectCorrection(false);
     59
     60        positionText();
    5361    }
    5462
    … …  
    5866        {
    5967            this->textoverlay_->destroy();
    60             this->textoverlay_ = 0;
     68            this->textoverlay_ = NULL;
    6169        }
    6270    }
    … …  
    7078        XMLPortParam(HUDHealthBar, "textusebarcolour",  setTextUseBarColour,     getTextUseBarColour,     xmlelement, mode).defaultValues(false);
    7179        XMLPortParam(HUDHealthBar, "textcolour",        setTextColour,           getTextColour,           xmlelement, mode).defaultValues(ColourValue(1.0, 1.0, 1.0, 1.0));
    72         XMLPortParam(HUDHealthBar, "textsize",          setTextSize,             getTextSize,             xmlelement, mode).defaultValues(1.0f);
    7380        XMLPortParam(HUDHealthBar, "textalign",         setTextAlignmentString,  getTextAlignmentString,  xmlelement, mode).defaultValues("left");
    7481        XMLPortParam(HUDHealthBar, "textoffset",        setTextOffset,           getTextOffset,           xmlelement, mode).defaultValues(Vector2::ZERO);
     82        XMLPortParam(HUDHealthBar, "textscale",         setTextScale,            getTextScale,            xmlelement, mode).defaultValues(1.0f);
    7583        XMLPortParam(HUDHealthBar, "textpickpoint",     setTextPickPoint,        getTextPickPoint,        xmlelement, mode).defaultValues(Vector2::ZERO);
    7684        XMLPortParam(HUDHealthBar, "textrotation",      setTextRotation,         getTextRotation,         xmlelement, mode).defaultValues(0.0f);
    77         XMLPortParam(HUDHealthBar, "textcorrectaspect", setTextAspectCorrection, getTextAspectCorrection, xmlelement, mode).defaultValues(true);
    7885        XMLPortParam(HUDHealthBar, "textspacewidth",    setTextSpaceWidth,       getTextSpaceWidth,       xmlelement, mode).defaultValues(true);
    7986    }
    … …  
    139146            this->textoverlay_->setColour(this->textColour_);
    140147    }
     148
     149    void HUDHealthBar::positionText()
     150    {
     151        this->textoverlay_->setPosition(this->getPosition() + this->textOffset_*this->getActualSize());
     152        this->textoverlay_->setTextSize(this->getActualSize().y*this->textScale_);
     153    }
     154
     155    void HUDHealthBar::positionChanged()
     156    {
     157        HUDBar::positionChanged();
     158        positionText();
     159    }
     160
     161    void HUDHealthBar::sizeChanged()
     162    {
     163        HUDBar::sizeChanged();
     164        positionText();
     165    }   
    141166}

  • code/trunk/src/modules/overlays/hud/HUDHealthBar.h

    r10624 r11052  
    7575                { return this->textoverlay_->getAlignmentString(); }
    7676
    77             inline void setTextSize(float size)
    78                 { this->textoverlay_->setTextSize(size); }
    79             inline float getTextSize() const
    80                 { return this->textoverlay_->getTextSize(); }
    81 
    8277            inline void setTextVisible(bool bVisible)
    8378                { this->textoverlay_->setVisible(bVisible); }
    8479            inline bool getTextVisible() const
    8580                { return this->textoverlay_->isVisible(); }
     81
     82            inline void setTextScale(float scale)
     83                { this->textScale_ = scale;
     84                  positionText();
     85                }
     86            inline float getTextScale() const
     87                { return this->textScale_; }
    8688
    8789            inline void setTextPickPoint(const Vector2& pickpoint)
    … …  
    9193
    9294            inline void setTextOffset(const Vector2& position)
    93                 { this->textoverlay_->setPosition(this->getPosition() + (position - this->getPickPoint()) * this->getSize()); }
     95                { this->textOffset_ = position;
     96                  this->positionText();
     97                }
    9498            inline Vector2 getTextOffset() const
    95                 { return (this->textoverlay_->getPosition() - this->getPosition()) / this->getSize() + this->getPickPoint(); }
    96 
    97             inline void setTextAspectCorrection(bool correct)
    98                 { this->textoverlay_->setAspectCorrection(correct); }
    99             inline bool getTextAspectCorrection() const
    100                 { return this->textoverlay_->getAspectCorrection(); }
     99                { return this->textOffset_; }
    101100
    102101            inline void setTextRotation(const Degree& angle)
    … …  
    112111            inline void setHealthBarOwner(Pawn* owner)
    113112                { this->owner_ = owner; }
    114 
     113        protected:
     114            virtual void positionChanged();
     115            virtual void sizeChanged();
    115116        private:
     117            virtual void positionText();
    116118            WeakPtr<Pawn> owner_;
    117119            StrongPtr<OverlayText> textoverlay_;
    118120            bool bUseBarColour_;
    119121            ColourValue textColour_;
     122            Vector2 textOffset_;
     123            float textScale_;
    120124    };
    121125}

  • code/trunk/src/modules/overlays/hud/HUDRadar.cc

    r9945 r11052  
    240240            }
    241241            else
    242                 coord = get2DViewcoordinates(this->owner_->getPosition(), this->owner_->getOrientation() * WorldEntity::FRONT, this->owner_->getOrientation() * WorldEntity::UP, wePointer->getWorldPosition());
     242                coord = get2DViewCoordinates(this->owner_->getPosition(), this->owner_->getOrientation() * WorldEntity::FRONT, this->owner_->getOrientation() * WorldEntity::UP, wePointer->getWorldPosition());
    243243
    244244            coord *= math::pi / 3.5f; // small adjustment to make it fit the texture

  • code/trunk/src/modules/pickup/PickupPrereqs.h

    r9348 r11052  
    8585    class ShrinkPickup;
    8686    class DamageBoostPickup;
     87    class MunitionPickup;
     88    class MunitionContainer;
    8789}
    8890

  • code/trunk/src/modules/pickup/PickupRepresentation.cc

    r9667 r11052  
    187187        Billboard* icon = new Billboard(spawner->getContext());
    188188        icon->setColour(ColourValue(0.89f, 0.79f, 0.08f));
    189         icon->setMaterial("asterisk");
     189        icon->setMaterial("Unknown");
    190190        icon->setScale(0.5);
    191191        sphere->attach(icon);

  • code/trunk/src/modules/pickup/items/CMakeLists.txt

    r9348 r11052  
    88  ShrinkPickup.cc
    99  DamageBoostPickup.cc
     10  BoostPickup.cc
     11  MunitionPickup.cc
     12  MunitionContainer.cc
    1013)

  • code/trunk/src/modules/pickup/items/DronePickup.h

    r9667 r11052  
    4343#include "tools/interfaces/Tickable.h"
    4444
    45 namespace orxonox {
     45namespace orxonox
     46{
    4647
    4748    /**
    … …  
    8081            std::string droneTemplate_; //!< The name of the template, based upon which the Drone is created.
    8182            Pawn* carrierToPawnHelper(void); //!< Helper to transform the PickupCarrier to a Pawn, and throw an error message if the conversion fails.
    82 
    83 
    84 
    8583    };
    8684}

  • code/trunk/src/modules/towerdefense/TowerDefenseField.cc

    • Property svn:eol-style set to native

  • code/trunk/src/modules/towerdefense/TowerDefenseField.h

    • Property svn:eol-style set to native

  • code/trunk/src/modules/towerdefense/TowerDefenseSelecter.cc

    r10629 r11052  
    8888            {
    8989                moveDownPressed_ = false;
    90                 selectedPos_->Set(selecterPosX, selecterPosY - 1);
     90                selectedPos_->Set(selecterPosX, selecterPosY - 1);
    9191                updatePosition();
    9292            }
    … …  
    100100            {
    101101                moveRightPressed_ = false;
    102                 selectedPos_->Set(selecterPosX + 1, selecterPosY);
     102                selectedPos_->Set(selecterPosX + 1, selecterPosY);
    103103                updatePosition();
    104104            }

  • code/trunk/src/modules/towerdefense/TowerDefenseTower.cc

    r10727 r11052  
    6161        {
    6262            upgrade++;
    63             float reloadrate = getReloadRate();
    64             float reloadwaittime = getReloadWaitTime();
    6563            this->setDamageMultiplier((upgrade+1)*2.0f);
     64
    6665            //this->setRotationThrust(2*this->getRotationThrust());
    67             reloadrate = 0.5f*reloadrate;
    68             reloadwaittime = 0.5f*reloadwaittime;
    69             setReloadRate(reloadrate);
    70             setReloadWaitTime(reloadwaittime);
    7166            //this->addTemplate("towerturret1");
    7267        }

  • code/trunk/src/modules/weapons/IceGunFreezer.cc

    • Property svn:eol-style set to native

  • code/trunk/src/modules/weapons/IceGunFreezer.h

    • Property svn:eol-style set to native

  • code/trunk/src/modules/weapons/WeaponsPrereqs.h

    r10622 r11052  
    6969{
    7070    class MuzzleFlash;
     71    class IceGunFreezer;
     72    class RocketController;
    7173
    7274    // munitions
    7375    class FusionMunition;
    7476    class LaserMunition;
    75     class ReplenishingMunition;
    7677    class RocketMunition;
    7778    class GravityBombMuntion;
     79    class IceMunition;
     80    class LightningMunition;
     81    class SplitMunition;
    7882
    7983    // projectiles
    … …  
    8185    class LightningGunProjectile;
    8286    class ParticleProjectile;
     87    class IceProjectile;
     88    class SplitProjectile;
    8389    class Projectile;
     90    class BasicProjectile;
    8491    class Rocket;
    8592    class RocketOld;
    … …  
    9198    class FusionFire;
    9299    class HsW01;
     100    class IceGun;
     101    class SplitGun;
    93102    class LaserFire;
    94103    class LightningGun;
     104    class MineGun;
    95105    class RocketFire;
    96106    class RocketFireOld;

  • code/trunk/src/modules/weapons/munitions/CMakeLists.txt

    r10629 r11052  
    11ADD_SOURCE_FILES(WEAPONS_SRC_FILES
    2   ReplenishingMunition.cc
    32  LaserMunition.cc
     3  LightningMunition.cc
    44  FusionMunition.cc
    55  RocketMunition.cc
    … …  
    77  IceMunition.cc
    88  SplitMunition.cc
     9  MineMunition.cc
    910)

  • code/trunk/src/modules/weapons/munitions/FusionMunition.cc

    r9667 r11052  
    2828
    2929/**
    30     @file FusionMunition.h
     30    @file FusionMunition.cc
    3131    @brief Implementation of the FusionMunition class.
    3232*/
    … …  
    3434#include "FusionMunition.h"
    3535#include "core/CoreIncludes.h"
     36#include "core/XMLPort.h"
    3637
    3738namespace orxonox
    … …  
    4546        this->maxMunitionPerMagazine_ = 10;
    4647        this->maxMagazines_ = 10;
    47         this->magazines_ = 10;
     48        this->unassignedMagazines_ = 10;
    4849
    49         this->bUseSeparateMagazines_ = true;
    50         this->bStackMunition_ = false;
     50        this->deployment_ = MunitionDeployment::Separate;
     51
    5152        this->reloadTime_ = 1.0f;
    5253
    5354        this->bAllowMunitionRefilling_ = true;
    5455        this->bAllowMultiMunitionRemovementUnderflow_ = true;
     56
     57        this->reloadTime_ = 0.5f;
     58    }
     59
     60    void FusionMunition::XMLPort(Element& xmlelement, XMLPort::Mode mode)
     61    {
     62        SUPER(FusionMunition, XMLPort, xmlelement, mode);
    5563    }
    5664}

  • code/trunk/src/modules/weapons/munitions/FusionMunition.h

    r9667 r11052  
    5353            FusionMunition(Context* context);
    5454            virtual ~FusionMunition() {}
     55            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
    5556    };
    5657}

  • code/trunk/src/modules/weapons/munitions/GravityBombMunition.cc

    r10622 r11052  
    77#include "GravityBombMunition.h"
    88#include "core/CoreIncludes.h"
     9#include "core/XMLPort.h"
    910
    1011namespace orxonox
    … …  
    1718        this->maxMunitionPerMagazine_ = 1;
    1819        this->maxMagazines_ = 30;
    19         this->magazines_ = 15;
     20        this->unassignedMagazines_ = 15;
    2021
    21         this->bUseSeparateMagazines_ = false;
    22         this->bStackMunition_ = true;
     22        this->deployment_ = MunitionDeployment::Stack;
    2323
    2424        this->bAllowMunitionRefilling_ = true;
    2525        this->bAllowMultiMunitionRemovementUnderflow_ = false;
     26
     27        this->reloadTime_ = 0.0f;
    2628    }
    2729
     30    void GravityBombMunition::XMLPort(Element& xmlelement, XMLPort::Mode mode)
     31    {
     32        SUPER(GravityBombMunition, XMLPort, xmlelement, mode);
     33    }
    2834}
    2935

  • code/trunk/src/modules/weapons/munitions/GravityBombMunition.h

    r10622 r11052  
    2828            GravityBombMunition(Context* context);
    2929            virtual ~GravityBombMunition() {}
     30            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
    3031    };
    3132

  • code/trunk/src/modules/weapons/munitions/IceMunition.cc

    • Property svn:eol-style set to native
    r10629 r11052  
    2828
    2929/**
    30     @file IceMunition.h
     30    @file IceMunition.cc
    3131    @brief Implementation of the IceMunition class.
    3232*/
    … …  
    3434#include "IceMunition.h"
    3535#include "core/CoreIncludes.h"
     36#include "core/XMLPort.h"
    3637
    3738namespace orxonox
    … …  
    4546        this->maxMunitionPerMagazine_ = 1;
    4647        this->maxMagazines_ = 50;
    47         this->magazines_ = 25;
     48        this->unassignedMagazines_ = 25;
    4849
    49         this->bUseSeparateMagazines_ = false;
    50         this->bStackMunition_ = true;
     50        this->deployment_ = MunitionDeployment::Stack;
    5151
    52         this->bAllowMunitionRefilling_ = false;
     52        this->bAllowMunitionRefilling_ = true;
    5353        this->bAllowMultiMunitionRemovementUnderflow_ = false;
     54
     55        this->reloadTime_ = 0.5f;
     56    }
     57
     58    void IceMunition::XMLPort(Element& xmlelement, XMLPort::Mode mode)
     59    {
     60        SUPER(IceMunition, XMLPort, xmlelement, mode);
    5461    }
    5562}

  • code/trunk/src/modules/weapons/munitions/IceMunition.h

    • Property svn:eol-style set to native
    r10629 r11052  
    5353            IceMunition(Context* context);
    5454            virtual ~IceMunition() {}
     55            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
    5556    };
    5657}

  • code/trunk/src/modules/weapons/munitions/LaserMunition.cc

    r9667 r11052  
    2828
    2929/**
    30     @file LaserMunition.h
     30    @file LaserMunition.cc
    3131    @brief Implementation of the LaserMunition class.
    3232*/
    … …  
    3434#include "LaserMunition.h"
    3535#include "core/CoreIncludes.h"
     36#include "core/XMLPort.h"
    3637
    3738namespace orxonox
    … …  
    4445
    4546        this->maxMunitionPerMagazine_ = 20;
    46         this->maxMagazines_ = 1;
    47         this->magazines_ = 1;
     47        this->maxMagazines_ = 10;
     48        this->unassignedMagazines_ = 10;
    4849
    49         this->bUseSeparateMagazines_ = false;
    50         this->bStackMunition_ = true;
     50        this->deployment_ = MunitionDeployment::Separate;
    5151
    5252        this->bAllowMunitionRefilling_ = true;
    5353        this->bAllowMultiMunitionRemovementUnderflow_ = true;
    5454
    55         this->replenishInterval_ = 0.5f;
    56         this->replenishMunitionAmount_ = 1;
     55        this->replenishInterval_ = 7.0f;
     56        this->replenishAmount_ = 1;
     57
     58        this->reloadTime_ = 0.5f;
     59    }
     60
     61    void LaserMunition::XMLPort(Element& xmlelement, XMLPort::Mode mode)
     62    {
     63        SUPER(LaserMunition, XMLPort, xmlelement, mode);
    5764    }
    5865}

  • code/trunk/src/modules/weapons/munitions/LaserMunition.h

    r9667 r11052  
    3636
    3737#include "weapons/WeaponsPrereqs.h"
    38 #include "ReplenishingMunition.h"
     38#include "weaponsystem/ReplenishingMunition.h"
    3939
    4040namespace orxonox
    … …  
    5353            LaserMunition(Context* context);
    5454            virtual ~LaserMunition() {}
     55            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
    5556    };
    5657}

  • code/trunk/src/modules/weapons/munitions/RocketMunition.cc

    r9667 r11052  
    2828
    2929/**
    30     @file RocketMunition.h
     30    @file RocketMunition.cc
    3131    @brief Implementation of the RocketMunition class.
    3232*/
    … …  
    3434#include "RocketMunition.h"
    3535#include "core/CoreIncludes.h"
     36#include "core/XMLPort.h"
    3637
    3738namespace orxonox
    … …  
    4546        this->maxMunitionPerMagazine_ = 1;
    4647        this->maxMagazines_ = 30;
    47         this->magazines_ = 10;
     48        this->unassignedMagazines_ = 10;
    4849
    49         this->bUseSeparateMagazines_ = false;
    50         this->bStackMunition_ = true;
     50        this->deployment_ = MunitionDeployment::Stack;
    5151
    52         this->bAllowMunitionRefilling_ = false;
     52        this->bAllowMunitionRefilling_ = true;
    5353        this->bAllowMultiMunitionRemovementUnderflow_ = false;
     54
     55        this->reloadTime_ = 0.5f;
     56    }
     57
     58    void RocketMunition::XMLPort(Element& xmlelement, XMLPort::Mode mode)
     59    {
     60        SUPER(RocketMunition, XMLPort, xmlelement, mode);
    5461    }
    5562}

  • code/trunk/src/modules/weapons/munitions/RocketMunition.h

    r9667 r11052  
    5353            RocketMunition(Context* context);
    5454            virtual ~RocketMunition() {}
     55            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
    5556    };
    5657}

  • code/trunk/src/modules/weapons/munitions/SplitMunition.cc

    • Property svn:eol-style set to native
    r10629 r11052  
    2828
    2929/**
    30     @file SplitMunition.h
     30    @file SplitMunition.cc
    3131    @brief Implementation of the SplitMunition class.
    3232*/
    … …  
    3434#include "SplitMunition.h"
    3535#include "core/CoreIncludes.h"
     36#include "core/XMLPort.h"
    3637
    3738namespace orxonox
    … …  
    4344        RegisterObject(SplitMunition);
    4445
    45         this->maxMunitionPerMagazine_ = 1;
    46         this->maxMagazines_ = 100;
    47         this->magazines_ = 25;
     46        this->maxMunitionPerMagazine_ = 5;
     47        this->maxMagazines_ = 10;
     48        this->unassignedMagazines_ = 5;
    4849
    49         this->bUseSeparateMagazines_ = false;
    50         this->bStackMunition_ = true;
     50        this->deployment_ = MunitionDeployment::Share;
    5151
    5252        this->bAllowMunitionRefilling_ = true;
    5353        this->bAllowMultiMunitionRemovementUnderflow_ = false;
     54
     55        this->reloadTime_ = 0.5f;
     56    }
     57
     58    void SplitMunition::XMLPort(Element& xmlelement, XMLPort::Mode mode)
     59    {
     60        SUPER(SplitMunition, XMLPort, xmlelement, mode);
    5461    }
    5562}

  • code/trunk/src/modules/weapons/munitions/SplitMunition.h

    • Property svn:eol-style set to native
    r10629 r11052  
    5353            SplitMunition(Context* context);
    5454            virtual ~SplitMunition() {}
     55            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
    5556    };
    5657}

  • code/trunk/src/modules/weapons/projectiles/BasicProjectile.cc

    r10293 r11052  
    6868    @brief
    6969        The function called when a projectile hits another thing.
    70         Calls the hit-function, starts the reload countdown, displays visual hit effects defined in Pawn.
     70        Calls the hit-function, starts the shield recharge countdown, displays visual hit effects defined in Pawn.
    7171        Needs to be called in the collidesAgainst() function by every Class directly inheriting from BasicProjectile.
    7272    @param otherObject
    … …  
    9797            {
    9898                victim->hit(this->getShooter(), contactPoint, cs, this->getDamage(), this->getHealthDamage(), this->getShieldDamage());
    99                 victim->startReloadCountdown();
     99                victim->startShieldRechargeCountdown();
    100100            }
    101101

  • code/trunk/src/modules/weapons/projectiles/CMakeLists.txt

    r10629 r11052  
    1212  GravityBomb.cc
    1313  GravityBombField.cc
     14  MineProjectile.cc
    1415)

  • code/trunk/src/modules/weapons/projectiles/GravityBombField.cc

    r10622 r11052  
    164164        if (lifetime_ <= -4)
    165165        {
    166             orxout(debug_output) << "Timeout. Destroying field." << endl;
    167166            this->destroy();
    168167        }

  • code/trunk/src/modules/weapons/projectiles/IceGunProjectile.cc

    • Property svn:eol-style set to native
    r10629 r11052  
    3434#include "IceGunProjectile.h"
    3535
     36#include <OgreSceneManager.h>
     37#include <OgreSceneNode.h>
     38
    3639#include "core/CoreIncludes.h"
    3740#include "graphics/Model.h"
     41#include "graphics/ParticleSpawner.h"
     42#include "Scene.h"
     43#include "core/command/Executor.h"
     44#include "tools/ParticleInterface.h"
    3845
    3946namespace orxonox
    4047{
    4148    RegisterClass(IceGunProjectile);
     49
     50    const float IceGunProjectile::particleDestructionDelay_ = 15.0f;
    4251
    4352    IceGunProjectile::IceGunProjectile(Context* context) : Projectile(context)
    … …  
    5564        this->attach(model);
    5665        model->setPosition(Vector3(0,0,0));
     66
     67        // Add effect.
     68        spawner_ = new ParticleSpawner(this->getContext());
     69        this->attach(spawner_);
     70        spawner_->setOrientation(this->getOrientation());
     71        spawner_->setSource("Orxonox/ice");
     72        spawner_->setDeleteWithParent(false);
     73        spawner_->setDestroydelay(particleDestructionDelay_);
     74    }
     75
     76    IceGunProjectile::~IceGunProjectile()
     77    {
     78        if (this->isInitialized())
     79        {
     80            const Vector3& pos = spawner_->getWorldPosition();
     81            const Quaternion& rot = spawner_->getWorldOrientation();
     82            this->detach(spawner_);
     83            spawner_->setPosition(pos);
     84            spawner_->setOrientation(rot);
     85            this->getScene()->getRootSceneNode()->addChild(const_cast<Ogre::SceneNode*>(spawner_->getNode()));
     86            this->spawner_->stop(true);
     87        }
    5788    }
    5889

  • code/trunk/src/modules/weapons/projectiles/IceGunProjectile.h

    • Property svn:eol-style set to native
    r10629 r11052  
    5656        public:
    5757            IceGunProjectile(Context* context);
    58             virtual ~IceGunProjectile() {}
     58            virtual ~IceGunProjectile();
    5959
    6060            virtual void setFreezeTime(float freezeTime);
    … …  
    6363        protected:
    6464            virtual bool collidesAgainst(WorldEntity* otherObject, const btCollisionShape* cs, btManifoldPoint& contactPoint);
    65         private:         
     65            static const float particleDestructionDelay_;
     66        private:
     67            ParticleSpawner* spawner_;
    6668            float freezeTime_; //The duration of the freezing effect on a target
    6769            float freezeFactor_; //The strength of the freezing effect

  • code/trunk/src/modules/weapons/projectiles/Projectile.h

    r10629 r11052  
    6969        protected:
    7070            virtual void setCollisionShapeRadius(float radius);
     71            float lifetime_; //!< The time the projectile exists.
    7172
    7273        private:
    73             float lifetime_; //!< The time the projectile exists.
    7474            Timer destroyTimer_; //!< Timer to destroy the projectile after its lifetime has run out.
    75             WeakPtr<SphereCollisionShape> collisionShape_; // The collision shape of the projectile.           
     75            WeakPtr<SphereCollisionShape> collisionShape_; // The collision shape of the projectile.
    7676    };
    7777}

  • code/trunk/src/modules/weapons/projectiles/Rocket.cc

    r10622 r11052  
    6666
    6767        this->localAngularVelocity_ = 0;
    68         this->lifetime_ = 100.0f;
     68        this->lifetime_ = 20.0f;
    6969
    7070        if (GameMode::isMaster())
    … …  
    7676            Model* model = new Model(this->getContext());
    7777            model->setMeshSource("rocket.mesh");
    78             model->scale(0.7f);
     78            model->scale(1.0f);
    7979            this->attach(model);
    8080
    … …  
    100100            this->attachCollisionShape(collisionShape);
    101101
    102             this->destroyTimer_.setTimer(this->lifetime_, false, createExecutor(createFunctor(&BasicProjectile::destroyObject, this)));
    103 
    104102            // Add sound
    105103            this->defSndWpnEngine_ = new WorldSound(this->getContext());
    … …  
    114112            this->defSndWpnLaunch_->setVolume(1.0f);
    115113            this->attach(defSndWpnLaunch_);
     114
     115            this->setHudTemplate("rockethud");
    116116        }
    117117        else
    … …  
    320320    }
    321321
     322    float Rocket::getFuel() const
     323    {
     324        return this->destroyTimer_.getRemainingTime();
     325    }
     326
     327    void Rocket::setMaxFuel(float fuel)
     328    {
     329        this->lifetime_ = fuel;
     330        this->destroyTimer_.setTimer(this->lifetime_, false, createExecutor(createFunctor(&BasicProjectile::destroyObject, this)));
     331    }
    322332}

  • code/trunk/src/modules/weapons/projectiles/Rocket.h

    r10216 r11052  
    118118            virtual void fired(unsigned int firemode);
    119119
     120            /**
     121            @brief Set the maximum lifetime of the rocket.
     122            */
     123            virtual void setMaxFuel(float fuel);
     124            /**
     125            @brief Get the maximum lifetime of the rocket.
     126            */
     127            inline float getMaxFuel() const
     128                { return lifetime_; }
     129            virtual float getFuel() const;
     130
    120131        private:
    121132            Vector3 localAngularVelocity_; //!< Variable to temporarily store accumulated steering command input.

  • code/trunk/src/modules/weapons/projectiles/SimpleRocket.cc

    r10299 r11052  
    7676            Model* model = new Model(this->getContext());
    7777            model->setMeshSource("rocket.mesh");
    78             model->scale(0.7f);
     78            model->scale(1.0f);
    7979            this->attach(model);
    8080

  • code/trunk/src/modules/weapons/projectiles/SplitGunProjectile.cc

    • Property svn:eol-style set to native

  • code/trunk/src/modules/weapons/projectiles/SplitGunProjectile.h

    • Property svn:eol-style set to native

  • code/trunk/src/modules/weapons/weaponmodes/CMakeLists.txt

    r10629 r11052  
    1111  SimpleRocketFire.cc
    1212  GravityBombFire.cc
     13  MineGun.cc
    1314)

  • code/trunk/src/modules/weapons/weaponmodes/EnergyDrink.cc

    r10622 r11052  
    6363        this->delayTimer_.setTimer(1.0f, false, createExecutor(createFunctor(&EnergyDrink::shot, this)));
    6464        this->delayTimer_.stopTimer();
     65
     66        hudImageString_ = "Orxonox/WSHUD_WM_EnergyDrink";
    6567    }
    6668

  • code/trunk/src/modules/weapons/weaponmodes/FusionFire.cc

    r10622 r11052  
    5858
    5959        this->setMunitionName("FusionMunition");
     60
     61        hudImageString_ = "Orxonox/WSHUD_WM_FusionFire";
    6062    }
    6163

  • code/trunk/src/modules/weapons/weaponmodes/GravityBombFire.cc

    r10622 r11052  
    3131        this->setMunitionName("GravityBombMunition");
    3232        this->setDefaultSoundWithVolume("sounds/Rocket_launch.ogg",0.8);    ///< sets sound of the bomb as it is fired.
     33
     34        hudImageString_ = "Orxonox/WSHUD_WM_GravityBombFire";
    3335    }
    3436

  • code/trunk/src/modules/weapons/weaponmodes/HsW01.cc

    r10296 r11052  
    6969
    7070        this->setDefaultSound(this->sound_);
     71
     72        hudImageString_ = "Orxonox/WSHUD_WM_HsW01";
    7173    }
    7274

  • code/trunk/src/modules/weapons/weaponmodes/IceGun.cc

    • Property svn:eol-style set to native
    r10629 r11052  
    5959        this->setFreezeFactor(0.5);
    6060
    61         this->setMunitionName("LaserMunition");
     61        this->setMunitionName("IceMunition");
    6262        this->setDefaultSound("sounds/Weapon_LightningGun.ogg");
     63
     64        hudImageString_ = "Orxonox/WSHUD_WM_IceGun";
    6365    }
    6466

  • code/trunk/src/modules/weapons/weaponmodes/IceGun.h

    • Property svn:eol-style set to native

  • code/trunk/src/modules/weapons/weaponmodes/LaserFire.cc

    r10622 r11052  
    5656
    5757        this->setMunitionName("LaserMunition");
     58
     59        hudImageString_ = "Orxonox/WSHUD_WM_LaserFire";
    5860    }
    5961

  • code/trunk/src/modules/weapons/weaponmodes/LightningGun.cc

    r10296 r11052  
    5454        this->speed_ = 750.0f;
    5555
    56         this->setMunitionName("LaserMunition");
     56        this->setMunitionName("LightningMunition");
    5757        this->setDefaultSound("sounds/Weapon_LightningGun.ogg");
     58
     59        hudImageString_ = "Orxonox/WSHUD_WM_LightningGun";
    5860    }
    5961

  • code/trunk/src/modules/weapons/weaponmodes/RocketFire.cc

    r10296 r11052  
    4141#include "weaponsystem/WeaponSystem.h"
    4242#include "worldentities/pawns/Pawn.h"
    43 
     43#include "core/XMLPort.h"
    4444#include "weapons/projectiles/Rocket.h"
    4545
    … …  
    5656        this->damage_ = 0.0f;
    5757        this->speed_ = 500.0f;
     58        this->fuel_ = 10.0f;
    5859
    5960        this->setMunitionName("RocketMunition");
    6061        // The firing sound of the Rocket is played in Rocket.cc (because of OpenAl sound positioning)
     62
     63        hudImageString_ = "Orxonox/WSHUD_WM_RocketFire";
    6164    }
    6265
    6366    RocketFire::~RocketFire()
    6467    {
     68    }
     69
     70    /**
     71    @brief
     72        XMLPort for the RocketFire. You can define the maximum lifetime of the rockets
     73    */
     74    void RocketFire::XMLPort(Element& xmlelement, XMLPort::Mode mode)
     75    {
     76        SUPER(RocketFire, XMLPort, xmlelement, mode);
     77
     78        XMLPortParam(RocketFire, "fuel", setFuel, getFuel, xmlelement, mode);
    6579    }
    6680
    … …  
    7791        rocket->setPosition(this->getMuzzlePosition());
    7892        rocket->setVelocity(this->getMuzzleDirection() * this->speed_);
    79         rocket->scale(2);
     93        rocket->scale(1.0f);
    8094
    8195        rocket->setShooter(this->getWeapon()->getWeaponPack()->getWeaponSystem()->getPawn());
    … …  
    8397        rocket->setShieldDamage(this->getShieldDamage());
    8498        rocket->setHealthDamage(this->getHealthDamage());
     99        rocket->setMaxFuel(this->fuel_);
    85100    }
    86101}

  • code/trunk/src/modules/weapons/weaponmodes/RocketFire.h

    r9667 r11052  
    5454            virtual ~RocketFire();
    5555
     56            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
     57
    5658            virtual void fire();
     59            inline void setFuel(float fuel)
     60                { this->fuel_ = fuel; }
     61            inline float getFuel() const
     62                { return this->fuel_; }
    5763
    5864        private:
    5965            float speed_; //!< The speed of the Rocket.
     66            float fuel_; //!< The maximum lifetime of the rocket
    6067    };
    6168}

  • code/trunk/src/modules/weapons/weaponmodes/RocketFireOld.cc

    r10622 r11052  
    5959        this->setMunitionName("RocketMunition");
    6060        // The firing sound of the Rocket is played in Rocket.cc (because of OpenAl sound positioning)
     61
     62        hudImageString_ = "Orxonox/WSHUD_WM_SimpleRocketFire";
    6163    }
    6264

  • code/trunk/src/modules/weapons/weaponmodes/SimpleRocketFire.cc

    r9667 r11052  
    6464        this->setDefaultSoundWithVolume("sounds/Rocket_launch.ogg",0.4f);
    6565        // The firing sound of the Rocket is played in Rocket.cc (because of OpenAl sound positioning)
     66
     67        hudImageString_ = "Orxonox/WSHUD_WM_SimpleRocketFire";
    6668    }
    6769
    … …  
    8385        rocket->setVelocity(this->getMuzzleDirection()*this->speed_);
    8486        rocket->setShooter(this->getWeapon()->getWeaponPack()->getWeaponSystem()->getPawn());
     87        rocket->scale(1.0f);
    8588
    8689        rocket->setDamage(this->damage_);
    … …  
    8992
    9093        WorldEntity* pawn = static_cast<ControllableEntity*>(this->getWeapon()->getWeaponPack()->getWeaponSystem()->getPawn())->getTarget();
    91         if (pawn) controller->setTarget(pawn);
     94        if (pawn)
     95            controller->setTarget(pawn);
    9296    }
    9397}

  • code/trunk/src/modules/weapons/weaponmodes/SplitGun.cc

    • Property svn:eol-style set to native
    r10629 r11052  
    3535
    3636#include "core/CoreIncludes.h"
    37 #include "core/XMLPort.h"   
     37#include "core/XMLPort.h"
    3838#include "weaponsystem/Weapon.h"
    3939#include "weaponsystem/WeaponPack.h"
    … …  
    6262        this->setMunitionName("SplitMunition");
    6363        this->setDefaultSound("sounds/Weapon_LightningGun.ogg");
     64
     65        hudImageString_ = "Orxonox/WSHUD_WM_SplitGun";
    6466    }
    6567

  • code/trunk/src/modules/weapons/weaponmodes/SplitGun.h

    • Property svn:eol-style set to native

  • code/trunk/src/orxonox/OrxonoxPrereqs.h

    r10624 r11052  
    167167    class DefaultWeaponmodeLink;
    168168    class Munition;
     169    class ReplenishingMunition;
    169170    class Weapon;
    170171    class WeaponMode;
    … …  
    175176
    176177    // worldentities
    177     class BigExplosion;
    178178    class CameraPosition;
    179179    class ControllableEntity;

  • code/trunk/src/orxonox/controllers/ArtificialController.cc

    r10631 r11052  
    9494            return;
    9595
    96         static const float hardcoded_projectile_speed = 750;
    97 
    98         this->targetPosition_ = getPredictedPosition(this->getControllableEntity()->getWorldPosition(), hardcoded_projectile_speed, this->target_->getWorldPosition(), this->target_->getVelocity());
     96        static const float HARDCODED_PROJECTILE_SPEED = 750;
     97
     98        this->targetPosition_ = getPredictedPosition(this->getControllableEntity()->getWorldPosition(), HARDCODED_PROJECTILE_SPEED, this->target_->getWorldPosition(), this->target_->getVelocity());
    9999        this->bHasTargetPosition_ = (this->targetPosition_ != Vector3::ZERO);
    100100

  • code/trunk/src/orxonox/controllers/CMakeLists.txt

    r10216 r11052  
    1111  FormationController.cc
    1212  ControllerDirector.cc
     13  DivisionController.cc
     14  WingmanController.cc
     15  SectionController.cc
     16  CommonController.cc
     17  ActionpointController.cc
     18  FlyingController.cc
     19  FightingController.cc
     20  MasterController.cc
    1321)

  • code/trunk/src/orxonox/controllers/FormationController.cc

    r10631 r11052  
    277277        }
    278278
    279         Vector2 coord = get2DViewcoordinates(this->getControllableEntity()->getPosition(), this->getControllableEntity()->getOrientation() * WorldEntity::FRONT, this->getControllableEntity()->getOrientation() * WorldEntity::UP, target);
     279        Vector2 coord = get2DViewCoordinates(this->getControllableEntity()->getPosition(), this->getControllableEntity()->getOrientation() * WorldEntity::FRONT, this->getControllableEntity()->getOrientation() * WorldEntity::UP, target);
    280280        float distance = (target - this->getControllableEntity()->getPosition()).length();
    281281        float rotateX = clamp(coord.x * 10, -1.0f, 1.0f);
    … …  
    970970        if (controller)
    971971        {
     972            if (controller->getIdentifier()->getName() == "MasterController")
     973                return true;
    972974            FormationController* ac = orxonox_cast<FormationController*>(controller);
    973975            if (ac)
    … …  
    981983        if (controller)
    982984        {
     985            if (controller->getIdentifier()->getName() == "MasterController")
     986                return true;
    983987            FormationController* ac = orxonox_cast<FormationController*>(controller);
    984988            if (ac)
    … …  
    10691073            return;
    10701074
    1071         Vector2 coord = get2DViewcoordinates(this->getControllableEntity()->getPosition(), this->getControllableEntity()->getOrientation() * WorldEntity::FRONT, this->getControllableEntity()->getOrientation() * WorldEntity::UP, target);
     1075        Vector2 coord = get2DViewCoordinates(this->getControllableEntity()->getPosition(), this->getControllableEntity()->getOrientation() * WorldEntity::FRONT, this->getControllableEntity()->getOrientation() * WorldEntity::UP, target);
    10721076        float distance = (target - this->getControllableEntity()->getPosition()).length();
    10731077

  • code/trunk/src/orxonox/controllers/HumanController.cc

    r10624 r11052  
    199199    @brief
    200200        Starts the boosting mode.
    201         Resets the boosting timeout and ells the ControllableEntity to boost (or not boost anymore).
     201        Resets the boosting timeout and tells the ControllableEntity to boost (or not boost anymore).
    202202    */
    203203    void HumanController::startBoosting(void)

  • code/trunk/src/orxonox/gametypes/Dynamicmatch.cc

    r10624 r11052  
    8686    }
    8787
     88    Dynamicmatch::~Dynamicmatch()
     89    {
     90        for (std::set<Timer*>::iterator it = this->piggyTimers_.begin(); it != this->piggyTimers_.end(); ++it)
     91            delete (*it);
     92    }
     93
    8894    void Dynamicmatch::setConfigValues()
    8995    {
    … …  
    312318            spaceship->addSpeedFactor(5);
    313319            ExecutorPtr executor = createExecutor(createFunctor(&Dynamicmatch::resetSpeedFactor, this));
    314             executor->setDefaultValue(0, spaceship);
    315             new Timer(10, false, executor, true);
     320            Timer* timer = new Timer(10, false, executor);
     321            executor->setDefaultValue(0, spaceship); // TODO: use WeakPtr because spaceship can be destroyed in the meantime
     322            executor->setDefaultValue(1, timer);
     323            this->piggyTimers_.insert(timer);
    316324        }
    317325    }
    … …  
    590598    }
    591599
    592     void Dynamicmatch::resetSpeedFactor(SpaceShip* spaceship)// helper function
     600    void Dynamicmatch::resetSpeedFactor(SpaceShip* spaceship, Timer* timer)// helper function
    593601    {
    594602        if (spaceship)
    … …  
    596604            spaceship->addSpeedFactor(1.0f/5.0f);
    597605        }
     606
     607        this->piggyTimers_.erase(timer);
     608        delete timer;
    598609    }
    599610

  • code/trunk/src/orxonox/gametypes/Dynamicmatch.h

    r10624 r11052  
    3333
    3434#include <map>
     35#include <set>
    3536#include <vector>
    3637
    … …  
    4546        public:
    4647            Dynamicmatch(Context* context);
    47             virtual ~Dynamicmatch() {}
     48            virtual ~Dynamicmatch();
    4849
    4950            bool notEnoughPigs;
    … …  
    7778            virtual void rewardPig();
    7879            void grantPigBoost(SpaceShip* spaceship); // Grant the piggy a boost.
    79             void resetSpeedFactor(SpaceShip* spaceship);
     80            void resetSpeedFactor(SpaceShip* spaceship, Timer* timer);
    8081            void tick (float dt);// used to end the game
    8182            SpawnPoint* getBestSpawnPoint(PlayerInfo* player) const;
    … …  
    8889            std::map< PlayerInfo*, int > playerParty_; //player's parties are recorded here
    8990            std::vector<ColourValue> partyColours_; //aus TeamDeathmatch
     91            std::set<Timer*> piggyTimers_;
    9092            unsigned int numberOf[3]; //array to count number of chasers, pigs, killers
    9193            float pointsPerTime;

  • code/trunk/src/orxonox/infos/PlayerInfo.cc

    r10624 r11052  
    202202
    203203        this->changedControllableEntity();
     204
     205         // HACK-ish
     206        if(this->isHumanPlayer())
     207            entity->createHud();
    204208    }
    205209
    … …  
    252256        if( !entity || this->previousControllableEntity_.size() == 0 )
    253257            return;
     258
     259        entity->destroyHud(); // HACK-ish
    254260
    255261        this->controllableEntity_->setController(0);

  • code/trunk/src/orxonox/items/ShipPart.cc

    r10624 r11052  
    4141#include "worldentities/StaticEntity.h"
    4242#include "items/PartDestructionEvent.h"
    43 #include "worldentities/BigExplosion.h"
    4443#include "chat/ChatManager.h"
    4544
    … …  
    105104    void ShipPart::explode()
    106105    {
    107         BigExplosion* chunk = new BigExplosion(this->getContext());
    108         chunk->setPosition(this->parent_->getPosition() + this->parent_->getOrientation() * (this->explosionPosition_));
    109         //chunk->setPosition(this->parent_->getPosition() + this->parent_->getOrientation() * Vector3(this->entityList_[0]->getLocalInertia()));
    110         chunk->setVelocity(this->parent_->getVelocity());
     106        // BigExplosion* chunk = new BigExplosion(this->getContext());
     107        // chunk->setPosition(this->parent_->getPosition() + this->parent_->getOrientation() * (this->explosionPosition_));
     108        // //chunk->setPosition(this->parent_->getPosition() + this->parent_->getOrientation() * Vector3(this->entityList_[0]->getLocalInertia()));
     109        // chunk->setVelocity(this->parent_->getVelocity());
    111110
    112111        // this->explosionSound_->setPosition(this->parent_->getPosition());

  • code/trunk/src/orxonox/overlays/OrxonoxOverlay.cc

    r10624 r11052  
    450450        tempTx->setColourOperationEx(Ogre::LBX_MODULATE, Ogre::LBS_MANUAL, Ogre::LBS_CURRENT, colour);
    451451    }
     452
     453    void OrxonoxOverlay::setZOrder(unsigned short order)
     454    {
     455        if (this->overlay_)
     456        {
     457            this->overlay_->setZOrder(order);
     458        }
     459    }
    452460}

  • code/trunk/src/orxonox/overlays/OrxonoxOverlay.h

    r9667 r11052  
    6565          only for displaying a picture).
    6666        - Reacts to changes of the window aspect
    67         - Last but not least: On demand you can tell the overlay to automatically resale to correct for
     67        - Last but not least: On demand you can tell the overlay to automatically rescale to correct for
    6868          aspect distortion. E.g. if you play 1024x768 you wouldn't want a round object to be oval.
    6969          Remark: This can (due to the Ogre::Overlay transformation order) only work for angle that are
    … …  
    186186        virtual void changedOverlayGroup()
    187187            { this->changedVisibility(); }
     188        virtual void setZOrder(unsigned short order);
    188189
    189190    protected:

  • code/trunk/src/orxonox/overlays/OverlayGroup.cc

    r10624 r11052  
    4242namespace orxonox
    4343{
     44    namespace autocompletion
     45    {
     46        /**
     47            @brief Returns the names of all currently existing OverlayGroups.
     48        */
     49        ARGUMENT_COMPLETION_FUNCTION_DECLARATION(overlaygroupnames)();
     50        ARGUMENT_COMPLETION_FUNCTION_IMPLEMENTATION(overlaygroupnames)()
     51        {
     52            ArgumentCompletionList names;
     53            for (ObjectList<OverlayGroup>::iterator it = ObjectList<OverlayGroup>::begin(); it; ++it)
     54                names.push_back(ArgumentCompletionListElement(it->getName(), getLowercase(it->getName())));
     55            return names;
     56        }
     57    }
     58
     59    SetConsoleCommand("OverlayGroup", "toggleVisibility", &OverlayGroup::toggleVisibility).argumentCompleter(0, autocompletion::overlaygroupnames());
     60    SetConsoleCommand("OverlayGroup", "show",             &OverlayGroup::show            ).argumentCompleter(0, autocompletion::overlaygroupnames());
     61    SetConsoleCommand("OverlayGroup", "scaleGroup",       &OverlayGroup::scaleGroup      ).argumentCompleter(0, autocompletion::overlaygroupnames());
     62    SetConsoleCommand("OverlayGroup", "scrollGroup",      &OverlayGroup::scrollGroup     ).argumentCompleter(0, autocompletion::overlaygroupnames());
     63
    4464    RegisterClass(OverlayGroup);
    45 
    46     SetConsoleCommand("OverlayGroup", "toggleVisibility", &OverlayGroup::toggleVisibility);
    47     SetConsoleCommand("OverlayGroup", "show", &OverlayGroup::show);
    48     SetConsoleCommand("OverlayGroup", "scaleGroup",       &OverlayGroup::scaleGroup);
    49     SetConsoleCommand("OverlayGroup", "scrollGroup",      &OverlayGroup::scrollGroup);
    5065
    5166    OverlayGroup::OverlayGroup(Context* context)

  • code/trunk/src/orxonox/weaponsystem/CMakeLists.txt

    r5781 r11052  
    11ADD_SOURCE_FILES(ORXONOX_SRC_FILES
    22  Munition.cc
     3  ReplenishingMunition.cc
    34  Weapon.cc
    45  WeaponMode.cc

  • code/trunk/src/orxonox/weaponsystem/Munition.cc

    r9667 r11052  
    2424 *      Fabian 'x3n' Landau
    2525 *   Co-authors:
    26  *      ...
     26 *      Fabien Vultier
    2727 *
    2828 */
    … …  
    3232#include "core/CoreIncludes.h"
    3333#include "core/command/Executor.h"
     34#include "core/XMLPort.h"
    3435
    3536namespace orxonox
    … …  
    4344        this->maxMunitionPerMagazine_ = 10;
    4445        this->maxMagazines_ = 10;
    45         this->magazines_ = 10;
    46 
    47         this->bUseSeparateMagazines_ = false;
    48         this->bStackMunition_ = true;
     46        this->unassignedMagazines_ = 10;
     47
     48        this->deployment_ = MunitionDeployment::Stack;
    4949        this->bAllowMunitionRefilling_ = true;
    5050        this->bAllowMultiMunitionRemovementUnderflow_ = true;
    5151
    52         this->reloadTime_ = 0;
     52        this->reloadTime_ = 0.5f;
     53
     54        this->lastFilledWeaponMode_ = NULL;
    5355    }
    5456
    5557    Munition::~Munition()
    5658    {
    57         for (std::map<WeaponMode*, Magazine*>::iterator it = this->currentMagazines_.begin(); it != this->currentMagazines_.end(); ++it)
     59        for (std::map<WeaponMode*, Magazine*>::iterator it = this->assignedMagazines_.begin(); it != this->assignedMagazines_.end(); ++it)
    5860            delete it->second;
    5961    }
    6062
     63    void Munition::XMLPort(Element& xmlelement, XMLPort::Mode mode)
     64    {
     65        SUPER(Munition, XMLPort, xmlelement, mode);
     66
     67        XMLPortParam(Munition, "initialmagazines", setNumMagazines, getNumMagazines, xmlelement, mode);
     68        XMLPortParam(Munition, "maxmagazines", setMaxMagazines, getMaxMagazines, xmlelement, mode);
     69        XMLPortParam(Munition, "munitionpermagazine", setMaxMunitionPerMagazine, getMaxMunitionPerMagazine, xmlelement, mode);
     70    }
     71
    6172    Munition::Magazine* Munition::getMagazine(WeaponMode* user) const
    6273    {
    63         if (this->bUseSeparateMagazines_)
     74        if (deployment_ == MunitionDeployment::Separate)
    6475        {
    6576            // For separated magazines we definitively need a given user
    … …  
    6879
    6980            // Use the map to get the magazine assigned to the given user
    70             std::map<WeaponMode*, Magazine*>::const_iterator it = this->currentMagazines_.find(user);
    71             if (it != this->currentMagazines_.end())
     81            std::map<WeaponMode*, Magazine*>::const_iterator it = this->assignedMagazines_.find(user);
     82            if (it != this->assignedMagazines_.end())
    7283                return it->second;
    7384        }
    … …  
    7586        {
    7687            // We don't use separate magazines for each user, so just take the first magazine
    77             if (this->currentMagazines_.size() > 0)
    78                 return this->currentMagazines_.begin()->second;
     88            if (this->assignedMagazines_.size() > 0)
     89                return this->assignedMagazines_.begin()->second;
    7990        }
    8091
    … …  
    8798        if (magazine)
    8899        {
    89             if (this->bStackMunition_)
     100            if (deployment_ == MunitionDeployment::Stack)
    90101                // With stacked munition every magazine contributes to the total amount
    91                 return this->maxMunitionPerMagazine_ * this->magazines_ + magazine->munition_;
     102                return this->maxMunitionPerMagazine_ * this->unassignedMagazines_ + magazine->munition_;
    92103            else
    93104                // Wihtout stacked munition we just consider the current magazine
    … …  
    109120    unsigned int Munition::getNumMagazines() const
    110121    {
    111         if (this->bStackMunition_)
     122        if (deployment_ == MunitionDeployment::Stack)
    112123        {
    113124            // If we stack munition and the current magazine is still full, it counts too
    114125            Magazine* magazine = this->getMagazine(0);
    115126            if (magazine && magazine->munition_ == this->maxMunitionPerMagazine_)
    116                 return this->magazines_ + 1;
    117         }
    118 
    119         return this->magazines_;
     127                return this->unassignedMagazines_ + 1;
     128        }
     129
     130        return this->unassignedMagazines_;
     131    }
     132
     133    void Munition::setNumMagazines(unsigned int numMagazines)
     134    {
     135        this->unassignedMagazines_ = numMagazines;
    120136    }
    121137
    122138    unsigned int Munition::getMaxMunition() const
    123139    {
    124         if (this->bStackMunition_)
     140        if (deployment_ == MunitionDeployment::Stack)
    125141            return this->maxMunitionPerMagazine_ * this->maxMagazines_;
    126142        else
    … …  
    135151            unsigned int munition = magazine->munition_;
    136152
    137             // If we stack munition, we con't care about the current magazine - we just need enough munition in total
    138             if (this->bStackMunition_)
    139                 munition += this->maxMunitionPerMagazine_ * this->magazines_;
     153            // If we stack munition, we don't care about the current magazine - we just need enough munition in total
     154            if (deployment_ == MunitionDeployment::Stack)
     155            {
     156                munition += this->maxMunitionPerMagazine_ * this->unassignedMagazines_;
     157            }
    140158
    141159            if (munition == 0)
     160            {
    142161                // Absolutely no munition - no chance to take munition
    143162                return false;
     163            }
    144164            else if (this->bAllowMultiMunitionRemovementUnderflow_)
     165            {
    145166                // We're not empty AND we allow underflow, so this will always work
    146167                return true;
     168            }
    147169            else
     170            {
    148171                // We don't allow underflow, so we have to check the amount
    149172                return (munition >= amount);
     173            }
     174
    150175        }
    151176        return false;
    … …  
    169194            {
    170195                // Not enough munition
    171                 if (this->bStackMunition_)
     196                if (deployment_ == MunitionDeployment::Stack)
    172197                {
    173198                    // We stack munition, so just take what we can and then load the next magazine
    … …  
    175200                    magazine->munition_ = 0;
    176201
    177                     if (this->reload(0))
     202                    if (this->reload(NULL))
    178203                        // Successfully reloaded, continue recursively
    179204                        return this->takeMunition(amount, 0);
    … …  
    199224    {
    200225        // As long as we have enough magazines (and don't stack munition) we can reload
    201         return (this->magazines_ > 0 && !this->bStackMunition_);
     226        return (this->unassignedMagazines_ > 0 && deployment_ != MunitionDeployment::Stack);
    202227    }
    203228
    … …  
    207232        if (magazine)
    208233        {
    209             if (this->bStackMunition_)
     234            if (deployment_ == MunitionDeployment::Stack)
    210235                // With stacked munition, we never have to reload
    211236                return false;
    … …  
    227252
    228253        // Check if we actually can reload
    229         if (this->magazines_ == 0)
     254        if (this->unassignedMagazines_ == 0)
    230255            return false;
    231256
    232257        // If we use separate magazines for each user, we definitively need a user given
    233         if (this->bUseSeparateMagazines_ && !user)
     258        if (deployment_ == MunitionDeployment::Separate && !user)
    234259            return false;
    235260
    236261        // If we don't use separate magazines, set user to 0
    237         if (!this->bUseSeparateMagazines_)
    238             user = 0;
     262        if (deployment_ != MunitionDeployment::Separate)
     263        {
     264            user = NULL;
     265        }
    239266
    240267        // Remove the current magazine for the given user
    241         std::map<WeaponMode*, Magazine*>::iterator it = this->currentMagazines_.find(user);
    242         if (it != this->currentMagazines_.end())
    243         {
     268        std::map<WeaponMode*, Magazine*>::iterator it = this->assignedMagazines_.find(user);
     269        if (it != this->assignedMagazines_.end())
     270        {
     271            if (it->first == lastFilledWeaponMode_)
     272            {
     273                lastFilledWeaponMode_ = NULL;
     274            }           
    244275            delete it->second;
    245             this->currentMagazines_.erase(it);
     276            this->assignedMagazines_.erase(it);
    246277        }
    247278
    248279        // Load a new magazine
    249         this->currentMagazines_[user] = new Magazine(this, bUseReloadTime);
    250         this->magazines_--;
     280        this->assignedMagazines_[user] = new Magazine(this, bUseReloadTime);
     281        this->unassignedMagazines_--;
    251282
    252283        return true;
    … …  
    260291            return false;
    261292
    262         if (this->bStackMunition_)
     293        if (deployment_ == MunitionDeployment::Stack)
    263294        {
    264295            // If we stack munition, we can always add munition until we reach the limit
    … …  
    268299        {
    269300            // Return true if any of the current magazines is not full (loading counts as full although it returns 0 munition)
    270             for (std::map<WeaponMode*, Magazine*>::const_iterator it = this->currentMagazines_.begin(); it != this->currentMagazines_.end(); ++it)
     301            for (std::map<WeaponMode*, Magazine*>::const_iterator it = this->assignedMagazines_.begin(); it != this->assignedMagazines_.end(); ++it)
    271302                if (it->second->munition_ < this->maxMunitionPerMagazine_ && it->second->bLoaded_)
    272303                    return true;
    … …  
    281312            return false;
    282313
    283         if (this->bStackMunition_)
     314        if (deployment_ == MunitionDeployment::Stack)
    284315        {
    285316            // Stacking munition means, if a magazine gets full, the munition adds to a new magazine
    286             Magazine* magazine = this->getMagazine(0);
     317            Magazine* magazine = this->getMagazine(NULL);
    287318            if (magazine)
    288319            {
    … …  
    294325                {
    295326                    magazine->munition_ -= this->maxMunitionPerMagazine_;
    296                     this->magazines_++;
     327                    this->unassignedMagazines_++;
    297328                }
    298329
    299                 // If we reached the limit, reduze both magazines and munition to the maximum
    300                 if (this->magazines_ >= this->maxMagazines_)
    301                 {
    302                     this->magazines_ = this->maxMagazines_ - 1;
     330                // If we reached the limit, reduce both magazines and munition to the maximum
     331                if (this->unassignedMagazines_ >= this->maxMagazines_)
     332                {
     333                    this->unassignedMagazines_ = this->maxMagazines_;
    303334                    magazine->munition_ = this->maxMunitionPerMagazine_;
    304335                }
    … …  
    312343        else
    313344        {
     345            std::map<WeaponMode*, Magazine*>::iterator it;
     346
     347            // If the pointer to the weapon mode whose magazine got munition added to is NULL, then set the iterator to the beginning of the map
     348            // Otherwise set it to the next weapon mode
     349            if (lastFilledWeaponMode_ == NULL)
     350            {
     351                it = this->assignedMagazines_.begin();
     352            }
     353            else
     354            {
     355                it = this->assignedMagazines_.find(lastFilledWeaponMode_);
     356                ++ it;
     357            }
     358
    314359            // Share the munition equally to the current magazines
     360            bool firstLoop = true;
    315361            while (amount > 0)
    316362            {
    317363                bool change = false;
    318                 for (std::map<WeaponMode*, Magazine*>::iterator it = this->currentMagazines_.begin(); it != this->currentMagazines_.end(); ++it)
     364                while (it != this->assignedMagazines_.end())
    319365                {
    320366                    // Add munition if the magazine isn't full (but only to loaded magazines)
    … …  
    323369                        it->second->munition_++;
    324370                        amount--;
     371                        lastFilledWeaponMode_ = it->first;
    325372                        change = true;
    326373                    }
     374
     375                    ++it;
    327376                }
    328377
    329378                // If there was no change in a loop, all magazines are full (or locked due to loading)
    330                 if (!change)
     379                // Because the first loop does not start at the beginning of the map we have to treat is separately
     380                if (!change && !firstLoop)
     381                {
    331382                    break;
     383                }                   
     384
     385                it = this->assignedMagazines_.begin();
     386                firstLoop = false;
    332387            }
    333388
    … …  
    340395        // TODO: 'amount' is not used
    341396
    342         if (this->bStackMunition_)
     397        if (deployment_ == MunitionDeployment::Stack)
    343398            // If we stack munition, we can always add new magazines because they contribute directly to the munition
    344399            return (this->getNumMunition(0) < this->getMaxMunition());
    345400        else
    346401            // If we don't stack munition, we're more limited
    347             return ((this->currentMagazines_.size() + this->magazines_) < this->maxMagazines_);
    348     }
    349 
    350     bool Munition::addMagazines(unsigned int amount)
    351     {
     402            return ((this->assignedMagazines_.size() + this->unassignedMagazines_) < this->maxMagazines_);
     403    }
     404
     405    unsigned int Munition::addMagazines(unsigned int amount)
     406    {
     407        unsigned int addedMagazines = 0;
     408
    352409        if (!this->canAddMagazines(amount))
    353             return false;
     410            return 0;
    354411
    355412        // Calculate how many magazines are needed
    356         int needed_magazines = this->maxMagazines_ - this->magazines_ - this->currentMagazines_.size();
     413        int needed_magazines = this->maxMagazines_ - this->unassignedMagazines_ - this->assignedMagazines_.size();
    357414
    358415        // If zero or less magazines are needed, we definitively don't need more magazines (unless we stack munition - then a magazine contributes directly to the munition)
    359         if (needed_magazines <= 0 && !this->bStackMunition_)
    360             return false;
     416        if (needed_magazines <= 0 && deployment_ != MunitionDeployment::Stack)
     417            return 0;
    361418
    362419        if (amount <= static_cast<unsigned int>(needed_magazines))
    363420        {
    364421            // We need more magazines than we get, so just add them
    365             this->magazines_ += amount;
     422            this->unassignedMagazines_ += amount;
     423            addedMagazines = amount;
    366424        }
    367425        else
    368426        {
    369427            // We get more magazines than we need, so just add the needed amount
    370             this->magazines_ += needed_magazines;
    371             if (this->bStackMunition_)
     428            this->unassignedMagazines_ += needed_magazines;
     429            addedMagazines = needed_magazines;
     430            if (deployment_ == MunitionDeployment::Stack)
    372431            {
    373432                // We stack munition, so the additional amount contributes directly to the munition of the current magazine
    … …  
    378437        }
    379438
    380         return true;
     439        // Reload as many empty magazines as possible
     440        // Double loop and break is needed because the reload function changes the assigned magazines. This may confuse the iterator.
     441        for (unsigned int i = 0; i < addedMagazines; ++i)
     442        {
     443            for (std::map<WeaponMode*, Magazine*>::iterator it = this->assignedMagazines_.begin(); it != this->assignedMagazines_.end(); ++it)
     444            {
     445                if (needReload(it->first))
     446                {
     447                    reload(it->first);
     448                    break;
     449                }
     450            }
     451        }
     452
     453        return addedMagazines;
    381454    }
    382455
    383456    bool Munition::canRemoveMagazines(unsigned int amount) const
    384457    {
    385         if (this->bStackMunition_)
    386         {
    387             if (this->magazines_ >= amount)
     458        if (deployment_ == MunitionDeployment::Stack)
     459        {
     460            if (this->unassignedMagazines_ >= amount)
    388461            {
    389462                // We have enough magazines
    390463                return true;
    391464            }
    392             else if (this->magazines_ == amount - 1)
     465            else if (this->unassignedMagazines_ == amount - 1)
    393466            {
    394467                // We lack one magazine, check if the current magazine is still full, if yes we're fine
    … …  
    406479        {
    407480            // In case we're not stacking munition, just check the number of magazines
    408             return (this->magazines_ >= amount);
     481            return (this->unassignedMagazines_ >= amount);
    409482        }
    410483
    … …  
    417490            return false;
    418491
    419         if (this->magazines_ >= amount)
     492        if (this->unassignedMagazines_ >= amount)
    420493        {
    421494            // We have enough magazines, just remove the amount
    422             this->magazines_ -= amount;
    423         }
    424         else if (this->bStackMunition_)
     495            this->unassignedMagazines_ -= amount;
     496        }
     497        else if (deployment_ == MunitionDeployment::Stack)
    425498        {
    426499            // We don't have enough magazines, but we're stacking munition, so additionally remove the bullets from the current magazine
    427             this->magazines_ = 0;
     500            this->unassignedMagazines_ = 0;
    428501            Magazine* magazine = this->getMagazine(0);
    429502            if (magazine)
    … …  
    437510    {
    438511        // If we use separate magazines, we need a user
    439         if (this->bUseSeparateMagazines_ && !user)
     512        if (deployment_ == MunitionDeployment::Separate && !user)
    440513            return false;
    441514
    442515        // If we don't use separate magazines, set user to 0
    443         if (!this->bUseSeparateMagazines_)
    444             user = 0;
     516        if (deployment_ != MunitionDeployment::Separate)
     517            user = NULL;
    445518
    446519        // Remove the current magazine for the given user
    447         std::map<WeaponMode*, Magazine*>::iterator it = this->currentMagazines_.find(user);
    448         if (it != this->currentMagazines_.end())
    449         {
     520        std::map<WeaponMode*, Magazine*>::iterator it = this->assignedMagazines_.find(user);
     521        if (it != this->assignedMagazines_.end())
     522        {
     523            if (it->first == lastFilledWeaponMode_)
     524            {
     525                lastFilledWeaponMode_ = NULL;
     526            }
    450527            delete it->second;
    451             this->currentMagazines_.erase(it);
     528            this->assignedMagazines_.erase(it);           
    452529            return true;
    453530        }
    … …  
    465542        this->bLoaded_ = false;
    466543
    467         if (bUseReloadTime && munition->reloadTime_ > 0 && !munition->bStackMunition_)
     544        if (bUseReloadTime && munition->reloadTime_ > 0 && munition->deployment_ != MunitionDeployment::Stack)
    468545        {
    469546            const ExecutorPtr& executor = createExecutor(createFunctor(&Magazine::loaded, this));

  • code/trunk/src/orxonox/weaponsystem/Munition.h

    r9667 r11052  
    2424 *      Fabian 'x3n' Landau
    2525 *   Co-authors:
    26  *      ...
     26 *      Fabien Vultier
    2727 *
    2828 */
    … …  
    3939namespace orxonox
    4040{
     41    namespace MunitionDeployment
     42    {
     43        enum Value
     44        {
     45            Separate, // Every comsuming weapon mode has its own magazine. It is possible that one weapon mode is out of ammo while another still has some.
     46            Share, // All comsuming weapon modes take their munition from the same magazine. If this magazine is empty a new one is loaded.
     47            Stack // There is only one magazine where all the munition is stored. Use this deployment mode for heavy weapons loke rockets, bombs, ...
     48        };
     49    }
     50
    4151    class _OrxonoxExport Munition : public BaseObject
    42     {
     52    {       
    4353        struct Magazine
    4454        {
    … …  
    5969            virtual ~Munition();
    6070
     71            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
     72
    6173            unsigned int getNumMunition(WeaponMode* user) const;
    6274            unsigned int getNumMunitionInCurrentMagazine(WeaponMode* user) const;
    … …  
    6880            inline unsigned int getMaxMunitionPerMagazine() const
    6981                { return this->maxMunitionPerMagazine_; }
     82            inline MunitionDeployment::Value getMunitionDeployment() const
     83                { return deployment_; }
     84
    7085
    7186            bool canTakeMunition(unsigned int amount, WeaponMode* user) const;
    … …  
    8297
    8398            bool canAddMagazines(unsigned int amount) const;
    84             bool addMagazines(unsigned int amount);
     99            /**
     100            @brief Try to add magazines.
     101            @param amount The amount of magazines tried to add.
     102            @return The amount of magazines sucessfully added.
     103            */
     104            unsigned int addMagazines(unsigned int amount);
    85105
    86106            bool canRemoveMagazines(unsigned int amount) const;
    … …  
    92112            unsigned int maxMunitionPerMagazine_;
    93113            unsigned int maxMagazines_;
    94             unsigned int magazines_;
    95             std::map<WeaponMode*, Magazine*> currentMagazines_;
     114            unsigned int unassignedMagazines_; // Number of magazines that are not assigned to a weapon mode. These are alway treated as full.
     115            std::map<WeaponMode*, Magazine*> assignedMagazines_; // Maps weapon modes to magazines that are currently used.
    96116
    97             bool bUseSeparateMagazines_;
    98             bool bStackMunition_;
     117            MunitionDeployment::Value deployment_; // Defines the behaviour how munition and magazines are distributed to the consuming weapon modes.
     118
    99119            bool bAllowMunitionRefilling_;
    100120            bool bAllowMultiMunitionRemovementUnderflow_;
    101121
    102             float reloadTime_;
     122            float reloadTime_; // The time needed to replace a magazine by a new one.
     123            WeaponMode* lastFilledWeaponMode_; // Pointer to the weapon mode that got the last munition during the last call of addMunition.
    103124
    104125        private:
    105126            Magazine* getMagazine(WeaponMode* user) const;
     127            inline void setMaxMagazines(unsigned int maxMagazines)
     128                { this->maxMagazines_ = maxMagazines; }
     129            inline void setMaxMunitionPerMagazine(unsigned int maxMunitionPerMagazine)
     130                { this->maxMunitionPerMagazine_ = maxMunitionPerMagazine; }
     131            void setNumMagazines(unsigned int numMagazines);
    106132    };
    107133}

  • code/trunk/src/orxonox/weaponsystem/Weapon.cc

    r10650 r11052  
    134134    }
    135135
     136    /**
     137    @brief
     138        Reload all @ref orxonox::WeaponMode weapon modes of this weapon.
     139    */
    136140    void Weapon::reload()
    137141    {
    … …  
    151155            it->second->setWeapon(this);
    152156    }
     157
     158    void Weapon::updateMunition()
     159    {
     160        for (std::multimap<unsigned int, WeaponMode*>::iterator it = this->weaponmodes_.begin(); it != this->weaponmodes_.end(); ++it)
     161            it->second->updateMunition();
     162    }
    153163}

  • code/trunk/src/orxonox/weaponsystem/Weapon.h

    r10650 r11052  
    5757            void addWeaponmode(WeaponMode* weaponmode);
    5858            WeaponMode* getWeaponmode(unsigned int index) const;
     59            inline std::multimap<unsigned int, WeaponMode*>* getAllWeaponmodes()
     60                { return &weaponmodes_; }
     61            inline int getNumWeaponModes() const
     62                { return weaponmodes_.size(); }
    5963
    6064            /**
    … …  
    7579            inline WeaponSlot * getWeaponSlot() const
    7680                { return this->weaponSlot_; }
     81            void updateMunition();
    7782
    7883        private:

  • code/trunk/src/orxonox/weaponsystem/WeaponMode.cc

    r10650 r11052  
    7575        this->muzzleOrientation_ = Quaternion::IDENTITY;
    7676
     77        hudImageString_ = "Orxonox/WSHUD_WM_Unknown";
     78
    7779        if( GameMode::isMaster() )
    7880        {
    … …  
    125127            this->bSoundAttached_ = true;
    126128        }
    127 
     129       
     130        // Fireing is only possible if this weapon mode is not reloading and there is enough munition
    128131        if (!this->bReloading_ && this->munition_ && this->munition_->takeMunition(this->munitionPerShot_, this))
    129132        {
    … …  
    134137                if (this->munition_->reload(this))
    135138                {
     139                    // If true, the weapon reloads in parallel to the magazine reloading
    136140                    if (this->bParallelReload_)
     141                    {
     142                        // The time needed to reload is the maximum of the reload time of the weapon mode and the magazine.
    137143                        tempReloadtime = std::max(this->reloadTime_, this->munition_->getReloadTime());
     144                    }                       
    138145                    else
     146                    {
     147                        // The time needed to reload is the sum of the reload time of the weapon mode and the magazine.
    139148                        tempReloadtime = this->reloadTime_ + this->munition_->getReloadTime();
     149                    }                       
    140150                }
    141151            }
    142152
     153            // Mark this weapon mode as reloading and start the reload timer
    143154            this->bReloading_ = true;
    144155            this->reloadTimer_.setInterval(tempReloadtime);
    … …  
    232243        }
    233244        else
    234             this->munition_ = 0;
     245        {
     246            this->munition_ = NULL;
     247        }
    235248    }
    236249
    … …  
    283296    }
    284297
    285     void WeaponMode::setDefaultSoundWithVolume(const std::string& soundPath, const float soundVolume){
    286         if (this->defSndWpnFire_) {
     298    void WeaponMode::setDefaultSoundWithVolume(const std::string& soundPath, const float soundVolume)
     299    {
     300        if (this->defSndWpnFire_)
     301        {
    287302            this->defSndWpnFire_->setSource(soundPath);
    288303            this->defSndWpnFire_->setVolume(soundVolume);

  • code/trunk/src/orxonox/weaponsystem/WeaponMode.h

    r10650 r11052  
    3838#include "core/class/SubclassIdentifier.h"
    3939#include "tools/Timer.h"
     40#include "Munition.h"
    4041
    4142namespace orxonox
    … …  
    104105            inline bool getParallelReload() const
    105106                { return this->bParallelReload_; }
     107            inline bool getReloading() const
     108                { return this->bReloading_; }
    106109
    107110
    … …  
    147150            Vector3 getTarget();
    148151
     152            inline const std::string& getHUDImageString() const
     153                { return this->hudImageString_; }           
     154
     155            void updateMunition();
    149156        protected:
    150157            virtual void fire() = 0;
    … …  
    155162
    156163            float reloadTime_;
    157             bool bAutoReload_;
    158             bool bParallelReload_;
     164            bool bAutoReload_; // If true, the weapon reloads the magazine automatically.
     165            bool bParallelReload_; // If true, the weapon reloads in parallel to the magazine reloading.
    159166
    160167            float damage_;
    … …  
    163170            Vector3 muzzleOffset_;
    164171
    165         private:
    166             void updateMunition();
     172            std::string hudImageString_;
     173
     174        private:           
    167175            void reloaded();
    168176
    … …  
    175183
    176184            Timer reloadTimer_;
    177             bool bReloading_;
     185            bool bReloading_; // If true, this weapon mode is marked as reloading.
    178186
    179187            Vector3 muzzlePosition_;
    … …  
    181189
    182190            WorldSound* defSndWpnFire_;
    183             bool        bSoundAttached_;
     191            bool bSoundAttached_;
    184192    };
    185193}

  • code/trunk/src/orxonox/weaponsystem/WeaponPack.cc

    r10650 r11052  
    124124    }
    125125
     126    std::vector<Weapon*>* WeaponPack::getAllWeapons()
     127    {
     128        return &weapons_;       
     129    }   
     130
    126131    void WeaponPack::addDefaultWeaponmodeLink(DefaultWeaponmodeLink* link)
    127132    {
    … …  
    156161            (*it)->setWeaponPack(this);
    157162    }
     163
     164    void WeaponPack::updateMunition()
     165    {
     166        for (std::vector<Weapon *>::const_iterator it = this->weapons_.begin(); it != this->weapons_.end(); ++it)
     167            (*it)->updateMunition();
     168    }
    158169}

  • code/trunk/src/orxonox/weaponsystem/WeaponPack.h

    r9667 r11052  
    5252            void removeWeapon(Weapon * weapon);
    5353            Weapon * getWeapon(unsigned int index) const;
     54            std::vector<Weapon*>* getAllWeapons();
    5455
    5556            inline size_t getNumWeapons() const
    … …  
    6566            inline WeaponSystem * getWeaponSystem() const
    6667                { return this->weaponSystem_; }
     68            void updateMunition();
    6769
    6870        private:

  • code/trunk/src/orxonox/weaponsystem/WeaponSystem.cc

    r10650 r11052  
    240240    }
    241241
     242    std::vector<WeaponPack *> * WeaponSystem::getAllWeaponPacks()
     243    {
     244        return &weaponPacks_;
     245    }   
     246
    242247    bool WeaponSystem::swapWeaponSlots(WeaponSlot * wSlot1, WeaponSlot * wSlot2)
    243248    {
    … …  
    310315            return it->second;
    311316        }
    312         else if (identifier->getIdentifier()->isA(Class(Munition)))
    313         {
    314             Munition* munition = identifier->fabricate(this->getContext());
    315             this->munitions_[identifier->getIdentifier()] = munition;
    316             return munition;
    317         }
    318317        else
    319318        {
    320             return 0;
     319            return NULL;
     320        }
     321    }
     322
     323    void WeaponSystem::addMunition(Munition* munition)
     324    {
     325        if (munition == NULL)
     326        {
     327            return;
     328        }
     329
     330        SubclassIdentifier<Munition> identifier = munition->getIdentifier();
     331
     332        if (identifier)
     333        {
     334            this->munitions_[identifier] = munition;
     335            updateMunition();
     336        }
     337        else
     338        {
     339            orxout(internal_warning) << "Adding munition failed. identifier == NULL " << endl;
     340        }
     341    }
     342
     343    void WeaponSystem::updateMunition()
     344    {
     345        for (std::vector<WeaponPack*>::iterator it = this->weaponPacks_.begin(); it != this->weaponPacks_.end(); ++it)
     346        {
     347            (*it)->updateMunition();
    321348        }
    322349    }

  • code/trunk/src/orxonox/weaponsystem/WeaponSystem.h

    r10650 r11052  
    6767            void removeWeaponPack(WeaponPack * wPack);
    6868            WeaponPack * getWeaponPack(unsigned int index) const;
     69            std::vector<WeaponPack *> * getAllWeaponPacks();
    6970
    7071            // configure slots and firemodes
    … …  
    7677
    7778            Munition * getMunition(SubclassIdentifier<Munition> * identifier);
     79            void addMunition(Munition* munition);
    7880
    7981            inline void setPawn(Pawn * pawn)
    … …  
    9597
    9698        private:
     99            void updateMunition();
     100           
    97101            std::map<unsigned int, WeaponSet *> weaponSets_;
    98102            std::vector<WeaponSlot *> weaponSlots_;

  • code/trunk/src/orxonox/worldentities/CMakeLists.txt

    r8706 r11052  
    66  ControllableEntity.cc
    77  Drone.cc
    8   BigExplosion.cc
    98  EffectContainer.cc
    109  ExplosionChunk.cc
    … …  
    1211  SpawnPoint.cc
    1312  TeamSpawnPoint.cc
     13  ExplosionPart.cc
     14  Actionpoint.cc
    1415)
    1516

  • code/trunk/src/orxonox/worldentities/MobileEntity.h

    r10437 r11052  
    4747        linear velocity. Then the linear velocity is multiplied by the time since the last call of tick and then added to the position. The same happens with
    4848        the angular acceleration and velocity. With this procedure MobileEntities can change their position and orientation with time.
     49
     50        A MobileEntity can only have the collisition type WorldEntity::None, WorldEntity::Dynamic or WorldEntity::Kinematic. The collsion type WorldEntity::Static is illegal.
    4951    */
    5052

  • code/trunk/src/orxonox/worldentities/SpawnPoint.h

    r9667 r11052  
    5555                { return this->template_; }
    5656
    57             Pawn* spawn();
     57            virtual Pawn* spawn();
    5858            void spawn(ControllableEntity* entity);
    5959

  • code/trunk/src/orxonox/worldentities/StaticEntity.h

    r10437 r11052  
    4444        it is called StaticEntity. It will keep the same position (always with respect to its parent) forever unless you call the
    4545        function @see setPosition to changee it.
     46
     47        A StaticEntity can only have the collisition type WorldEntity::None or WorldEntity::Static. The collsion types WorldEntity::Dynamic and WorldEntity::Kinematic are illegal.
    4648    */
    4749

  • code/trunk/src/orxonox/worldentities/TeamSpawnPoint.cc

    r9667 r11052  
    4949        XMLPortParam(TeamSpawnPoint, "team", setTeamNumber, getTeamNumber, xmlelement, mode).defaultValues(0);
    5050    }
     51    Pawn* TeamSpawnPoint::spawn()
     52    {
     53        Pawn* entity = SpawnPoint::spawn();
     54        static_cast<ControllableEntity*>(entity)->setTeam (this->teamNumber_);
     55        return entity;
     56    }
    5157}

  • code/trunk/src/orxonox/worldentities/TeamSpawnPoint.h

    r9667 r11052  
    4949            unsigned int getTeamNumber() const
    5050                { return this->teamNumber_; }
     51            virtual Pawn* spawn();
    5152
    5253        private:
    53             unsigned int teamNumber_;
     54            int teamNumber_;
    5455    };
    5556}

  • code/trunk/src/orxonox/worldentities/pawns/Pawn.cc

    r10650 r11052  
    3434#include "core/GameMode.h"
    3535#include "core/XMLPort.h"
     36#include "core/EventIncludes.h"
    3637#include "network/NetworkFunction.h"
    3738
    … …  
    4142#include "graphics/ParticleSpawner.h"
    4243#include "worldentities/ExplosionChunk.h"
    43 #include "worldentities/BigExplosion.h"
     44#include "worldentities/ExplosionPart.h"
    4445#include "weaponsystem/WeaponSystem.h"
    4546#include "weaponsystem/WeaponSlot.h"
    4647#include "weaponsystem/WeaponPack.h"
    4748#include "weaponsystem/WeaponSet.h"
     49#include "weaponsystem/Munition.h"
    4850#include "sound/WorldSound.h"
    4951
    … …  
    6163
    6264        this->bAlive_ = true;
    63         this->bReload_ = false;
     65        this->bVulnerable_ = true;
    6466
    6567        this->health_ = 0;
    … …  
    7173        this->maxShieldHealth_ = 100; //otherwise shield might increase to float_max
    7274        this->shieldAbsorption_ = 0.5;
    73 
    74         this->reloadRate_ = 0;
    75         this->reloadWaitTime_ = 1.0f;
    76         this->reloadWaitCountdown_ = 0;
     75        this->shieldRechargeRate_ = 0;
     76        this->shieldRechargeWaitTime_ = 1.0f;
     77        this->shieldRechargeWaitCountdown_ = 0;
    7778
    7879        this->lastHitOriginator_ = 0;
    … …  
    8485
    8586        this->aimPosition_ = Vector3::ZERO;
     87
     88        //this->explosionPartList_ = NULL;
    8689
    8790        if (GameMode::isMaster())
    … …  
    135138        XMLPortParam(Pawn, "shieldabsorption", setShieldAbsorption, getShieldAbsorption, xmlelement, mode).defaultValues(0);
    136139
     140        XMLPortParam(Pawn, "vulnerable", setVulnerable, isVulnerable, xmlelement, mode).defaultValues(true);
     141
    137142        XMLPortParam(Pawn, "spawnparticlesource", setSpawnParticleSource, getSpawnParticleSource, xmlelement, mode);
    138143        XMLPortParam(Pawn, "spawnparticleduration", setSpawnParticleDuration, getSpawnParticleDuration, xmlelement, mode).defaultValues(3.0f);
    139         XMLPortParam(Pawn, "explosionchunks", setExplosionChunks, getExplosionChunks, xmlelement, mode).defaultValues(7);
     144        XMLPortParam(Pawn, "explosionchunks", setExplosionChunks, getExplosionChunks, xmlelement, mode).defaultValues(0);
    140145
    141146        XMLPortObject(Pawn, WeaponSlot, "weaponslots", addWeaponSlot, getWeaponSlot, xmlelement, mode);
    142147        XMLPortObject(Pawn, WeaponSet, "weaponsets", addWeaponSet, getWeaponSet, xmlelement, mode);
    143         XMLPortObject(Pawn, WeaponPack, "weapons", addWeaponPackXML, getWeaponPack, xmlelement, mode);
    144 
    145         XMLPortParam(Pawn, "reloadrate", setReloadRate, getReloadRate, xmlelement, mode).defaultValues(0);
    146         XMLPortParam(Pawn, "reloadwaittime", setReloadWaitTime, getReloadWaitTime, xmlelement, mode).defaultValues(1.0f);
     148        XMLPortObject(Pawn, WeaponPack, "weaponpacks", addWeaponPackXML, getWeaponPack, xmlelement, mode);
     149        XMLPortObject(Pawn, Munition, "munition", addMunitionXML, getMunitionXML, xmlelement, mode);
     150
     151        XMLPortObject(Pawn, ExplosionPart, "explosion", addExplosionPart, getExplosionPart, xmlelement, mode);
     152        XMLPortParam(Pawn, "shieldrechargerate", setShieldRechargeRate, getShieldRechargeRate, xmlelement, mode).defaultValues(0);
     153        XMLPortParam(Pawn, "shieldrechargewaittime", setShieldRechargeWaitTime, getShieldRechargeWaitTime, xmlelement, mode).defaultValues(1.0f);
    147154
    148155        XMLPortParam(Pawn, "explosionSound",  setExplosionSound,  getExplosionSound,  xmlelement, mode);
    … …  
    151158    }
    152159
     160    void Pawn::XMLEventPort(Element& xmlelement, XMLPort::Mode mode)
     161    {
     162        SUPER(Pawn, XMLEventPort, xmlelement, mode);
     163
     164        XMLPortEventState(Pawn, BaseObject, "vulnerability", setVulnerable, xmlelement, mode);
     165    }
     166
    153167    void Pawn::registerVariables()
    154168    {
    155         registerVariable(this->bAlive_,           VariableDirection::ToClient);
    156         registerVariable(this->health_,           VariableDirection::ToClient);
    157         registerVariable(this->maxHealth_,        VariableDirection::ToClient);
    158         registerVariable(this->shieldHealth_,     VariableDirection::ToClient);
    159         registerVariable(this->maxShieldHealth_,  VariableDirection::ToClient);
    160         registerVariable(this->shieldAbsorption_, VariableDirection::ToClient);
    161         registerVariable(this->bReload_,          VariableDirection::ToServer);
    162         registerVariable(this->aimPosition_,      VariableDirection::ToServer);  // For the moment this variable gets only transfered to the server
     169        registerVariable(this->bAlive_,            VariableDirection::ToClient);
     170        registerVariable(this->health_,            VariableDirection::ToClient);
     171        registerVariable(this->maxHealth_,         VariableDirection::ToClient);
     172        registerVariable(this->shieldHealth_,      VariableDirection::ToClient);
     173        registerVariable(this->maxShieldHealth_,   VariableDirection::ToClient);
     174        registerVariable(this->shieldAbsorption_,  VariableDirection::ToClient);
     175        registerVariable(this->aimPosition_,       VariableDirection::ToServer);  // For the moment this variable gets only transfered to the server
    163176    }
    164177
    165178    void Pawn::tick(float dt)
    166179    {
     180        //BigExplosion* chunk = new BigExplosion(this->getContext());
    167181        SUPER(Pawn, tick, dt);
    168182
    169         this->bReload_ = false;
    170 
     183        // Recharge the shield
    171184        // TODO: use the existing timer functions instead
    172         if(this->reloadWaitCountdown_ > 0)
    173         {
    174             this->decreaseReloadCountdownTime(dt);
    175         }
    176         else
    177         {
    178             this->addShieldHealth(this->getReloadRate() * dt);
    179             this->resetReloadCountdown();
     185        if(this->shieldRechargeWaitCountdown_ > 0)
     186        {
     187            this->decreaseShieldRechargeCountdownTime(dt);
     188        }
     189        else
     190        {
     191            this->addShieldHealth(this->getShieldRechargeRate() * dt);
     192            this->resetShieldRechargeCountdown();
    180193        }
    181194
    … …  
    229242    }
    230243
    231     void Pawn::setReloadRate(float reloadrate)
    232     {
    233         this->reloadRate_ = reloadrate;
    234     }
    235 
    236     void Pawn::setReloadWaitTime(float reloadwaittime)
    237     {
    238         this->reloadWaitTime_ = reloadwaittime;
    239     }
    240 
    241     void Pawn::decreaseReloadCountdownTime(float dt)
    242     {
    243         this->reloadWaitCountdown_ -= dt;
     244    void Pawn::setShieldRechargeRate(float shieldRechargeRate)
     245    {
     246        this->shieldRechargeRate_ = shieldRechargeRate;
     247    }
     248
     249    void Pawn::setShieldRechargeWaitTime(float shieldRechargeWaitTime)
     250    {
     251        this->shieldRechargeWaitTime_ = shieldRechargeWaitTime;
     252    }
     253
     254    void Pawn::decreaseShieldRechargeCountdownTime(float dt)
     255    {
     256        this->shieldRechargeWaitCountdown_ -= dt;
     257    }
     258
     259    void Pawn::changedVulnerability()
     260    {
     261
    244262    }
    245263
    246264    void Pawn::damage(float damage, float healthdamage, float shielddamage, Pawn* originator, const btCollisionShape* cs)
    247265    {
     266        // A pawn can only get damaged if it is vulnerable
     267        if (!isVulnerable())
     268        {
     269            return;
     270        }
     271
    248272        // Applies multiplier given by the DamageBoost Pickup.
    249273        if (originator)
    … …  
    252276        if (this->getGametype() && this->getGametype()->allowPawnDamage(this, originator))
    253277        {
     278            // Health-damage cannot be absorbed by shields.
     279            // Shield-damage only reduces shield health.
     280            // Normal damage can be (partially) absorbed by shields.
     281
    254282            if (shielddamage >= this->getShieldHealth())
    255283            {
    … …  
    366394            if (GameMode::isMaster())
    367395            {
    368                 this->deatheffect();
    369396                this->goWithStyle();
    370397            }
    … …  
    373400    void Pawn::goWithStyle()
    374401    {
     402
    375403        this->bAlive_ = false;
    376404        this->setDestroyWhenPlayerLeft(false);
    377405
    378         BigExplosion* chunk = new BigExplosion(this->getContext());
    379         chunk->setPosition(this->getPosition());
    380         chunk->setVelocity(this->getVelocity());
     406        while(!explosionPartList_.empty())
     407        {
     408            explosionPartList_.back()->setPosition(this->getPosition());
     409            explosionPartList_.back()->setVelocity(this->getVelocity());
     410            explosionPartList_.back()->setOrientation(this->getOrientation());
     411            explosionPartList_.back()->Explode();
     412            explosionPartList_.pop_back();
     413        }
     414
     415        for (unsigned int i = 0; i < this->numexplosionchunks_; ++i)
     416        {
     417            ExplosionChunk* chunk = new ExplosionChunk(this->getContext());
     418            chunk->setPosition(this->getPosition());
     419        }
    381420
    382421        this->explosionSound_->setPosition(this->getPosition());
    383422        this->explosionSound_->play();
    384     }
    385     void Pawn::deatheffect()
    386     {
    387         // play death effect
    388         /*{
    389             ParticleSpawner* effect = new ParticleSpawner(this->getContext());
    390             effect->setPosition(this->getPosition());
    391             effect->setOrientation(this->getOrientation());
    392             effect->setDestroyAfterLife(true);
    393             effect->setSource("Orxonox/explosion2b");
    394             effect->setLifetime(4.0f);
    395         }
    396         {
    397             ParticleSpawner* effect = new ParticleSpawner(this->getContext());
    398             effect->setPosition(this->getPosition());
    399             effect->setOrientation(this->getOrientation());
    400             effect->setDestroyAfterLife(true);
    401             effect->setSource("Orxonox/smoke6");
    402             effect->setLifetime(4.0f);
    403         }
    404         {
    405             ParticleSpawner* effect = new ParticleSpawner(this->getContext());
    406             effect->setPosition(this->getPosition());
    407             effect->setOrientation(this->getOrientation());
    408             effect->setDestroyAfterLife(true);
    409             effect->setSource("Orxonox/sparks");
    410             effect->setLifetime(4.0f);
    411         }*/
    412        
    413        
    414         {
    415             ParticleSpawner* effect = new ParticleSpawner(this->getContext());
    416             effect->setPosition(this->getPosition());
    417             effect->setOrientation(this->getOrientation());
    418             effect->setDestroyAfterLife(true);
    419             effect->setSource("orxonox/explosion_flash2");
    420             effect->setLifetime(5.0f);
    421         }
    422         {
    423             ParticleSpawner* effect = new ParticleSpawner(this->getContext());
    424             effect->setPosition(this->getPosition());
    425             effect->setOrientation(this->getOrientation());
    426             effect->setDestroyAfterLife(true);
    427             effect->setSource("orxonox/explosion_flame2");
    428             effect->setLifetime(5.0f);
    429         }
    430         {
    431             ParticleSpawner* effect = new ParticleSpawner(this->getContext());
    432             effect->setPosition(this->getPosition());
    433             effect->setOrientation(this->getOrientation());
    434             effect->setDestroyAfterLife(true);
    435             effect->setSource("orxonox/explosion_shockwave2");
    436             effect->scale(20);
    437             effect->setLifetime(5.0f);
    438         }{
    439             ParticleSpawner* effect = new ParticleSpawner(this->getContext());
    440             effect->setPosition(this->getPosition());
    441             effect->setOrientation(this->getOrientation());
    442             effect->setDestroyAfterLife(true);
    443             effect->setSource("orxonox/explosion_sparks2");
    444             effect->setLifetime(5.0f);
    445         }
    446         {
    447             ParticleSpawner* effect = new ParticleSpawner(this->getContext());
    448             effect->setPosition(this->getPosition());
    449             effect->setOrientation(this->getOrientation());
    450             effect->setDestroyAfterLife(true);
    451             effect->setSource("orxonox/explosion_streak2");
    452             effect->setLifetime(5.0f);
    453         }
    454         {
    455             ParticleSpawner* effect = new ParticleSpawner(this->getContext());
    456             effect->setPosition(this->getPosition());
    457             effect->setOrientation(this->getOrientation());
    458             effect->setDestroyAfterLife(true);
    459             effect->setSource("orxonox/explosion_afterglow");
    460             effect->scale(20);
    461             effect->setLifetime(5.0f);
    462         }
    463        
    464        
    465         for (unsigned int i = 0; i < this->numexplosionchunks_; ++i)
    466         {
    467             ExplosionChunk* chunk = new ExplosionChunk(this->getContext());
    468             chunk->setPosition(this->getPosition());
    469         }
    470423    }
    471424
    … …  
    474427        Check whether the Pawn has a @ref Orxonox::WeaponSystem and fire it with the specified firemode if it has one.
    475428    */
     429
    476430    void Pawn::fired(unsigned int firemode)
    477431    {
    478432        if (this->weaponSystem_)
    479433            this->weaponSystem_->fire(firemode);
    480     }
    481 
    482     void Pawn::reload()
    483     {
    484         this->bReload_ = true;
    485434    }
    486435
    … …  
    491440            this->spawneffect();
    492441    }
     442
     443
     444    void Pawn::addExplosionPart(ExplosionPart* ePart)
     445    {this->explosionPartList_.push_back(ePart);}
     446
     447
     448    ExplosionPart * Pawn::getExplosionPart()
     449    {return this->explosionPartList_.back();}
     450
     451
    493452
    494453    /* WeaponSystem:
    … …  
    554513    }
    555514
     515    std::vector<WeaponPack *> * Pawn::getAllWeaponPacks()
     516    {
     517        if (this->weaponSystem_)
     518            return this->weaponSystem_->getAllWeaponPacks();
     519        else
     520            return 0;       
     521    }
     522
     523    void Pawn::addMunitionXML(Munition* munition)
     524    {
     525        if (this->weaponSystem_ && munition)
     526        {
     527            this->weaponSystem_->addMunition(munition);
     528        }
     529    }
     530
     531    Munition* Pawn::getMunitionXML() const
     532    {
     533        return NULL;
     534    }
     535
     536    Munition* Pawn::getMunition(SubclassIdentifier<Munition> * identifier)
     537    {
     538        if (weaponSystem_)
     539        {
     540            return weaponSystem_->getMunition(identifier);
     541        }
     542
     543        return NULL;
     544    }
     545
    556546    //Tell the Map (RadarViewable), if this is a playership
    557547    void Pawn::startLocalHumanControl()
    558548    {
    559 //        SUPER(ControllableEntity, changedPlayer());
     549//        SUPER(ControllableEntity, startLocalHumanControl());
    560550        ControllableEntity::startLocalHumanControl();
    561551        this->isHumanShip_ = true;

  • code/trunk/src/orxonox/worldentities/pawns/Pawn.h

    r10437 r11052  
    3333
    3434#include <string>
     35#include <vector>
    3536#include "interfaces/PickupCarrier.h"
    3637#include "interfaces/RadarViewable.h"
    3738#include "worldentities/ControllableEntity.h"
     39#include "worldentities/ExplosionPart.h"
    3840
    3941
    … …  
    4244    /**
    4345    @brief
    44         Everything in Orxonoy that has a health attribute is a Pawn. After a Pawn is spawned its health is set to
     46        Everything in Orxonox that has a health attribute is a Pawn. After a Pawn is spawned its health is set to
    4547        its initial health. In every call of the Pawns tick function the game checks whether the pawns health is at
    4648        or below zero. If it is, the pawn gets killed.
    4749
    48         Pawns can carry pickups and fire weapons. The can also have shields.
     50        Pawns can carry pickups and fire weapons. They can also have shields.
    4951
    5052        Notice that every Pawn is a ControllableEntity.
    … …  
    6264
    6365            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
     66            virtual void XMLEventPort(Element& xmlelement, XMLPort::Mode mode);
    6467            virtual void tick(float dt);
    6568
    … …  
    116119                { return this->shieldAbsorption_; }
    117120
    118             // TODO: Rename to shieldRechargeRate
    119             virtual void setReloadRate(float reloadrate);
    120             inline float getReloadRate() const
    121                 { return this->reloadRate_; }
    122 
    123             virtual void setReloadWaitTime(float reloadwaittime);
    124             inline float getReloadWaitTime() const
    125                 { return this->reloadWaitTime_; }
    126 
    127             inline void resetReloadCountdown()
    128                 { this->reloadWaitCountdown_ = 0; }
    129 
    130             inline void startReloadCountdown()
    131                 { this->reloadWaitCountdown_ = this->getReloadWaitTime(); } // TODO: Implement in Projectile.cc
    132 
    133             virtual void decreaseReloadCountdownTime(float dt);
     121            virtual void setShieldRechargeRate(float shieldRechargeRate);
     122            inline float getShieldRechargeRate() const
     123                { return this->shieldRechargeRate_; }
     124
     125            virtual void setShieldRechargeWaitTime(float shieldRechargeWaitTime);
     126            inline float getShieldRechargeWaitTime() const
     127                { return this->shieldRechargeWaitTime_; }
     128
     129            inline void resetShieldRechargeCountdown()
     130                { this->shieldRechargeWaitCountdown_ = 0; }
     131
     132            inline void startShieldRechargeCountdown()
     133                { this->shieldRechargeWaitCountdown_ = this->getShieldRechargeWaitTime(); } // TODO: Implement in Projectile.cc
     134
     135            virtual void decreaseShieldRechargeCountdownTime(float dt);
     136
     137            /** @brief Sets the state of the pawns vulnerability. @param bVulnerable */
     138            inline void setVulnerable(bool bVulnerable)
     139            {
     140                if (this->bVulnerable_ != bVulnerable)
     141                {
     142                    this->bVulnerable_ = bVulnerable;
     143                    this->changedVulnerability();
     144                }
     145            }
     146            /** @brief Returns the state of the pawns vulnerability. @return The state of the vulnerability */
     147            inline const bool& isVulnerable() const { return this->bVulnerable_; }
     148            /** @brief This function gets called if the vulnerability of the pawn changes. */
     149            virtual void changedVulnerability();
    134150
    135151            inline ControllableEntity* getLastHitOriginator() const
    136152                { return this->lastHitOriginator_; }
    137153
    138             //virtual void hit(Pawn* originator, const Vector3& force, float damage);
    139             //virtual void hit(Pawn* originator, btManifoldPoint& contactpoint, float damage);
    140154            virtual void hit(Pawn* originator, const Vector3& force, const btCollisionShape* cs, float damage, float healthdamage = 0.0f, float shielddamage = 0.0f);
    141155            virtual void hit(Pawn* originator, btManifoldPoint& contactpoint, const btCollisionShape* cs, float damage, float healthdamage = 0.0f, float shielddamage = 0.0f);
    … …  
    144158
    145159            virtual void fired(unsigned int firemode);
    146             virtual void reload();
    147160            virtual void postSpawn();
     161
     162            void addExplosionPart(ExplosionPart* ePart);
     163            ExplosionPart * getExplosionPart();
    148164
    149165            void addWeaponSlot(WeaponSlot * wSlot);
    … …  
    154170            void addWeaponPackXML(WeaponPack * wPack);
    155171            WeaponPack * getWeaponPack(unsigned int index) const;
     172            std::vector<WeaponPack *> * getAllWeaponPacks();
     173
     174            void addMunitionXML(Munition* munition);
     175            Munition* getMunitionXML() const;
     176           
     177            Munition* getMunition(SubclassIdentifier<Munition> * identifier);
    156178
    157179            virtual void addedWeaponPack(WeaponPack* wPack) {}
    … …  
    194216            const std::string& getExplosionSound();
    195217
     218            virtual const WeaponSystem* getWeaponSystem() const
     219                { return this->weaponSystem_; }
     220
    196221        protected:
    197222            virtual void preDestroy();
    … …  
    204229            virtual Controller* getSlave();
    205230            virtual void goWithStyle();
    206             virtual void deatheffect();
    207231            virtual void spawneffect();
    208232
    209             //virtual void damage(float damage, Pawn* originator = 0);
    210233            virtual void damage(float damage, float healthdamage = 0.0f, float shielddamage = 0.0f, Pawn* originator = NULL, const btCollisionShape* cs = NULL);
    211234
    212235            bool bAlive_;
     236            bool bVulnerable_; ///< If false the pawn may not ged damaged
    213237
    214238            virtual std::vector<PickupCarrier*>* getCarrierChildren(void) const
    … …  
    226250            float initialShieldHealth_;
    227251            float shieldAbsorption_; ///< Has to be between 0 and 1
    228             float reloadRate_;
    229             float reloadWaitTime_;
    230             float reloadWaitCountdown_;
     252            float shieldRechargeRate_;
     253            float shieldRechargeWaitTime_;
     254            float shieldRechargeWaitCountdown_;
    231255
    232256            float damageMultiplier_; ///< Used by the Damage Boost Pickup.
    … …  
    235259
    236260            WeaponSystem* weaponSystem_;
    237             bool bReload_;
    238261
    239262            std::string spawnparticlesource_;
    240263            float spawnparticleduration_;
    241264            unsigned int numexplosionchunks_;
     265
     266            std::vector<ExplosionPart*> explosionPartList_;
    242267
    243268        private:

  • code/trunk/src/orxonox/worldentities/pawns/SpaceShip.cc

    r10216 r11052  
    115115
    116116        XMLPortObject(SpaceShip, Engine, "engines", addEngine, getEngine, xmlelement, mode);
     117
     118       
    117119    }
    118120
    … …  
    297299        }
    298300    }
     301
     302    void SpaceShip::gainBoostPower(float gainedBoostPower)
     303    {
     304        this->boostPower_ += gainedBoostPower;
     305       
     306        if (this->boostPower_ > this->initialBoostPower_)
     307        {
     308            this->boostPower_ = this->initialBoostPower_;
     309        }
     310
     311        // If the booster is in cooldown mode and we gained boost power, the abort the cooldown.
     312        if (this->isBoostCoolingDown() && this->boostPower_ > 0.0f)
     313        {
     314            timer_.stopTimer();
     315            this->boostCooledDown();
     316        }
     317    }
     318
    299319    /**
    300320    @brief

  • code/trunk/src/orxonox/worldentities/pawns/SpaceShip.h

    r10437 r11052  
    5353        - The <b>boost</b>, there are quite some parameters pertaining to boosting. The boost is a special move of the SpaceShip, where, for a limited amount of time, it can fly considerably faster than usual. The <b>boostPower</b> is the amount of power available for boosting. The <b>boostPowerRate</b> is the rate at which the boost power is replenished. The <b>boostRate</b> is the rate at which boosting uses power. And the <b>boostCooldownDuration</b> is the time the SpaceShip cannot boost, once all the boost power has been used up. Naturally all of these parameters must be non-negative.
    5454        - The <b>boost shaking</b>, when the SpaceShip boosts, the camera shakes to create a more immersive effect. Two parameters can be used to adjust the effect. The <b>shakeFrequency</b> is the frequency with which the camera shakes. And the <b>shakeAmplitude</b> is the amount with which the camera shakes. Again these parameters must bee non-negative.
    55         - The <b>lift</b> creates a more natural flight feeling through the addition of a lift force. There are again tow parameters that can be specified. The <b>lift</b> which is the lift force that is applied. And the <b>stallSpeed</b> which is the forward speed after which no more lift is generated.
     55        - The <b>lift</b> creates a more natural flight feeling through the addition of a lift force. There are again two parameters that can be specified. The <b>lift</b> which is the lift force that is applied. And the <b>stallSpeed</b> which is the forward speed after which no more lift is generated.
     56
     57        A spaceship always needs to have the collision type "dynamic". Other collision types are illegal.
    5658
    5759        As mentioned @ref orxonox::Engine Engines can be mounted on the SpaceShip. Here is a (primitive) example of a SpaceShip defined in XML:
    … …  
    250252            inline float getShakeAmplitude() const
    251253                { return this->shakeAmplitude_; }
     254            /**
     255            @brief Add boost power. Is non-negative.
     256            @return Returns the current boost power.
     257            */
     258            void gainBoostPower(float gainedBoostPower);
    252259
    253260        protected:
    … …  
    262269            bool bBoostCooldown_;         //!< Whether the SpaceShip is currently in boost cooldown, during which boosting is impossible.
    263270            float initialBoostPower_;     //!< The initial (and maximal) boost power.
    264             float boostPower_;            //!< The current boost power.
     271            float boostPower_;            //!< The current boost power. If the boost power is reduced to zero the boost cooldown will start.
    265272            float boostPowerRate_;        //!< The rate at which the boost power is recharged.
    266273            float boostRate_;             //!< The rate at which boost power is used up.
    … …  
    289296            std::vector<Engine*> engineList_; //!< The list of all Engines mounted on this SpaceShip.
    290297
    291             Timer timer_;                          //!< Timer for the cooldown duration.
     298            Timer timer_;                          //!< Timer for the cooldown of the boost.
    292299            float shakeDt_;                        //!< Temporary variable for the shaking of the camera.
    293300            Vector3 cameraOriginalPosition_;       //!< The original position of the camera before shaking it.
Note: See TracChangeset for help on using the changeset viewer.