Revert "unify separators"

This reverts commit ad641eff67.

src/achievements/achievement.hpp

@@ -29,7 +29,7 @@
 class UTFWriter;
 class XMLNode;
 
-// ----------------------------------------------------------------------------
+// ============================================================================
 /** This is the base class for any achievement. It allows achievement status
  *  to be saved, and detects when an achievement is fulfilled. It provides
  *  storage for state information by a generic key-value mapping. The values

src/achievements/achievement_info.hpp

@@ -29,7 +29,7 @@
 #include <irrString.h>
 #include <string>
 
-// ----------------------------------------------------------------------------
+// ============================================================================
 
 class Achievement;
 

src/achievements/achievements_manager.hpp

@@ -69,7 +69,7 @@ public:
         delete m_achievements_manager;
         m_achievements_manager = NULL;
     }   // destroy
-    // ------------------------------------------------------------------------
+    // ========================================================================
 
     AchievementInfo* getAchievementInfo(uint32_t id) const;
     AchievementsStatus* createAchievementsStatus(const XMLNode *node=NULL);

src/addons/news_manager.cpp

@@ -407,7 +407,7 @@ bool NewsManager::conditionFulfilled(const std::string &cond)
             continue;
         }
         // Check for stkversion comparisons
-        // --------------------------------
+        // ================================
         if(cond[0]=="stkversion")
         {
             int news_version = StringUtils::versionToInt(cond[2]);
@@ -431,7 +431,7 @@ bool NewsManager::conditionFulfilled(const std::string &cond)
                                      "assumed true.", cond_list[i].c_str());
         }
         // Check for addons not installed
-        // ------------------------------
+        // ==============================
         else if(cond[1]=="not" && cond[2]=="installed")
         {
             // The addons_manager can not be access, since it's

src/animations/ipo.cpp

@@ -363,7 +363,7 @@ float Ipo::IpoData::getCubicBezier(float t, float p0, float p1,
     return ((a*t+b)*t+c)*t+p0;
 }   // bezier
 
-// ----------------------------------------------------------------------------
+// ============================================================================
 /** The Ipo constructor. Ipos can share the actual data to interpolate, which
  *  is stored in a separate IpoData object, see Ipo(const Ipo *ipo)
  *  constructor. This is used for cannons: the actual check line stores the

src/config/player_manager.cpp

@@ -152,7 +152,7 @@ Online::OnlineProfile* PlayerManager::getCurrentOnlineProfile()
     return getCurrentPlayer()->getProfile();
 }   // getCurrentOnlineProfile
 
-// ----------------------------------------------------------------------------
+// ============================================================================
 /** Constructor.
  */
 PlayerManager::PlayerManager()

src/config/saved_grand_prix.cpp

@@ -62,7 +62,7 @@ SavedGrandPrix::SavedGPKart::SavedGPKart(GroupUserConfigParam * group,
     m_overall_time.findYourDataInAnAttributeOf(node);
 }   // SavedGPKart
 
-// ----------------------------------------------------------------------------
+// ============================================================================
 SavedGrandPrix::SavedGrandPrix(unsigned int player_id,
                                const std::string &gp_id,
                                RaceManager::Difficulty difficulty,

src/config/saved_grand_prix.hpp

@@ -26,7 +26,7 @@
 
 class RaceManager;
 
-// ----------------------------------------------------------------------------
+// ============================================================================
 
 /**
   * \brief Class for managing saved Grand-Prix's

src/config/user_config.cpp

@@ -69,7 +69,7 @@ void UserConfigParam::writeInner(std::ofstream& stream, int level) const
            << toString().c_str() << "\"\n";
 }   // writeInner
 
-// ----------------------------------------------------------------------------
+// ============================================================================
 GroupUserConfigParam::GroupUserConfigParam(const char* group_name,
                                            const char* comment)
 {
@@ -78,7 +78,7 @@ GroupUserConfigParam::GroupUserConfigParam(const char* group_name,
     if(comment != NULL) m_comment = comment;
 }   // GroupUserConfigParam
 
-// ----------------------------------------------------------------------------
+// ============================================================================
 GroupUserConfigParam::GroupUserConfigParam(const char* group_name,
                                            GroupUserConfigParam* group,
                                            const char* comment)
@@ -184,7 +184,7 @@ void GroupUserConfigParam::addChild(UserConfigParam* child)
 }   // addChild
 
 
-// ----------------------------------------------------------------------------
+// ============================================================================
 template<typename T, typename U>
 ListUserConfigParam<T, U>::ListUserConfigParam(const char* param_name,
                                            const char* comment)
@@ -194,7 +194,7 @@ ListUserConfigParam<T, U>::ListUserConfigParam(const char* param_name,
     if(comment != NULL) m_comment = comment;
 }   // ListUserConfigParam
 
-// ----------------------------------------------------------------------------
+// ============================================================================
 template<typename T, typename U>
 ListUserConfigParam<T,U>::ListUserConfigParam(const char* param_name,
                                            const char* comment,
@@ -213,7 +213,7 @@ ListUserConfigParam<T,U>::ListUserConfigParam(const char* param_name,
     va_end ( arguments );                  // Cleans up the list
 }   // ListUserConfigParam
 
-// ----------------------------------------------------------------------------
+// ============================================================================
 template<typename T, typename U>
 ListUserConfigParam<T, U>::ListUserConfigParam(const char* param_name,
                                            GroupUserConfigParam* group,
@@ -224,7 +224,7 @@ ListUserConfigParam<T, U>::ListUserConfigParam(const char* param_name,
     if(comment != NULL) m_comment = comment;
 }   // ListUserConfigParam
 
-// ----------------------------------------------------------------------------
+// ============================================================================
 template<typename T, typename U>
 ListUserConfigParam<T, U>::ListUserConfigParam(const char* param_name,
                                            GroupUserConfigParam* group,
@@ -326,7 +326,7 @@ core::stringc ListUserConfigParam<T, U>::toString() const
 
 
 
-// ----------------------------------------------------------------------------
+// ============================================================================
 IntUserConfigParam::IntUserConfigParam(int default_value,
                                        const char* param_name,
                                        const char* comment)
@@ -389,7 +389,7 @@ void IntUserConfigParam::findYourDataInAnAttributeOf(const XMLNode* node)
     node->get( m_param_name, &m_value );
 }   // findYourDataInAnAttributeOf
 
-// ----------------------------------------------------------------------------
+// ============================================================================
 TimeUserConfigParam::TimeUserConfigParam(StkTime::TimeType default_value,
                                          const char* param_name,
                                          const char* comment)
@@ -460,7 +460,7 @@ void TimeUserConfigParam::findYourDataInAnAttributeOf(const XMLNode* node)
     m_value = tmp;
 }   // findYourDataInAnAttributeOf
 
-// ----------------------------------------------------------------------------
+// ============================================================================
 StringUserConfigParam::StringUserConfigParam(const char* default_value,
                                              const char* param_name,
                                              const char* comment)
@@ -509,7 +509,7 @@ void StringUserConfigParam::findYourDataInAnAttributeOf(const XMLNode* node)
     node->get( m_param_name, &m_value );
 }   // findYourDataInAnAttributeOf
 
-// ----------------------------------------------------------------------------
+// ============================================================================
 BoolUserConfigParam::BoolUserConfigParam(bool default_value,
                                          const char* param_name,
                                          const char* comment)
@@ -597,7 +597,7 @@ irr::core::stringc BoolUserConfigParam::toString() const
     return (m_value ? "true" : "false" );
 }   // toString
 
-// ----------------------------------------------------------------------------
+// ============================================================================
 FloatUserConfigParam::FloatUserConfigParam(float default_value,
                                            const char* param_name,
                                            const char* comment)
@@ -656,8 +656,8 @@ core::stringc FloatUserConfigParam::toString() const
     return tmp;
 }   // toString
 
-// -------------------------------------------------------------------------------------
-// -------------------------------------------------------------------------------------
+// =====================================================================================
+// =====================================================================================
 
 #if 0
 #pragma mark -

src/config/user_config.hpp

@@ -75,7 +75,7 @@ public:
     virtual irr::core::stringc toString() const = 0;
 };   // UserConfigParam
 
-// ----------------------------------------------------------------------------
+// ============================================================================
 class GroupUserConfigParam : public UserConfigParam
 {
     std::vector<UserConfigParam*> m_attributes;
@@ -97,7 +97,7 @@ public:
     irr::core::stringc toString() const;
 };   // GroupUserConfigParam
 
-// ----------------------------------------------------------------------------
+// ============================================================================
 template<typename T, typename U>
 class ListUserConfigParam : public UserConfigParam
 {
@@ -136,7 +136,7 @@ public:
 };   // ListUserConfigParam
 typedef ListUserConfigParam<std::string, const char*>    StringListUserConfigParam;
 
-// ----------------------------------------------------------------------------
+// ============================================================================
 class IntUserConfigParam : public UserConfigParam
 {
     int m_value;
@@ -164,7 +164,7 @@ public:
                                  { m_value = (int)v; return m_value; }
 };   // IntUserConfigParam
 
-// ----------------------------------------------------------------------------
+// ============================================================================
 class TimeUserConfigParam : public UserConfigParam
 {
     StkTime::TimeType m_value;
@@ -190,7 +190,7 @@ public:
                                           { m_value = (int)v; return m_value; }
 };   // TimeUserConfigParam
 
-// ----------------------------------------------------------------------------
+// ============================================================================
 class StringUserConfigParam : public UserConfigParam
 {
     std::string m_value;
@@ -223,7 +223,7 @@ public:
     const char* c_str() const { return m_value.c_str(); }
 };   // StringUserConfigParam
 
-// ----------------------------------------------------------------------------
+// ============================================================================
 class BoolUserConfigParam : public UserConfigParam
 {
     bool m_value;
@@ -248,7 +248,7 @@ public:
                               { m_value = (bool)v; return m_value; }
 };   // BoolUserConfigParam
 
-// ----------------------------------------------------------------------------
+// ============================================================================
 class FloatUserConfigParam : public UserConfigParam
 {
     float m_value;
@@ -274,7 +274,7 @@ public:
                               { m_value = (float)v; return m_value; }
 };   // FloatUserConfigParam
 
-// ----------------------------------------------------------------------------
+// ============================================================================
 enum AnimType {ANIMS_NONE         = 0,
                ANIMS_PLAYERS_ONLY = 1,
                ANIMS_ALL          = 2 };
@@ -294,7 +294,7 @@ enum AnimType {ANIMS_NONE         = 0,
 #define PARAM_DEFAULT(X)
 #endif
 
-// ----------------------------------------------------------------------------
+// ============================================================================
 /** \brief Contains all parameters that are stored in the user's config file
  *  \ingroup config
  */
@@ -773,7 +773,7 @@ namespace UserConfigParams
 #undef PARAM_PREFIX
 #undef PARAM_SUFFIX
 
-// ----------------------------------------------------------------------------
+// ============================================================================
 /**
   * \brief Class for managing general STK user configuration data.
   * \ingroup config

src/graphics/camera.cpp

@@ -45,7 +45,7 @@
 AlignedArray<Camera::EndCameraInformation> Camera::m_end_cameras;
 std::vector<Camera*>                       Camera::m_all_cameras;
 
-// ----------------------------------------------------------------------------
+// ============================================================================
 Camera::Camera(int camera_index, AbstractKart* kart) : m_kart(NULL)
 {
     m_mode          = CM_NORMAL;

src/graphics/irr_driver.cpp

@@ -1928,7 +1928,7 @@ void IrrDriver::doScreenShot()
 void IrrDriver::update(float dt)
 {
     // User aborted (e.g. closed window)
-    // ---------------------------------
+    // =================================
     if (!m_device->run())
     {
         GUIEngine::cleanUp();

src/graphics/particle_emitter.cpp

@@ -100,7 +100,7 @@ public:
 };   // FadeAwayAffector
 
 
-// ----------------------------------------------------------------------------
+// ============================================================================
 
 class HeightMapCollisionAffector : public scene::IParticleAffector
 {
@@ -178,7 +178,7 @@ public:
     }
 };
 
-// ----------------------------------------------------------------------------
+// ============================================================================
 
 class WindAffector : public scene::IParticleAffector
 {
@@ -218,7 +218,7 @@ public:
 
 };   // WindAffector
 
-// ----------------------------------------------------------------------------
+// ============================================================================
 
 class ScaleAffector : public scene::IParticleAffector
 {
@@ -248,7 +248,7 @@ protected:
     core::vector2df ScaleFactor;
 };
 
-// ----------------------------------------------------------------------------
+// ============================================================================
 
 class ColorAffector : public scene::IParticleAffector
 {
@@ -283,7 +283,7 @@ public:
 
 
 
-// ----------------------------------------------------------------------------
+// ============================================================================
 
 ParticleEmitter::ParticleEmitter(const ParticleKind* type,
                                  const Vec3 &position,

src/guiengine/message_queue.cpp

@@ -70,7 +70,7 @@ public:
     }
 };   // class Message
 
-// ----------------------------------------------------------------------------
+// ============================================================================
 /** A function class to compare messages, required for priority_queue. */
 class CompareMessages
 {
@@ -85,7 +85,7 @@ public:
 };   // operator()
 
 
-// ----------------------------------------------------------------------------
+// ============================================================================
 /** List of all messages. */
 std::priority_queue<Message*, std::vector<Message*>,
                    CompareMessages> g_all_messages;
@@ -101,7 +101,7 @@ float        g_max_display_time     = -1.0f;
 SkinWidgetContainer *g_container    = NULL;
 core::recti g_area;
 
-// ----------------------------------------------------------------------------
+// ============================================================================
 
 void createLabel(const Message *message)
 {

src/guiengine/skin.cpp

@@ -183,7 +183,7 @@ namespace SkinConfig
     }   // loadFromFile
 };   // SkinConfig
 
-// ----------------------------------------------------------------------------
+// ============================================================================
 #if 0
 #pragma mark -
 #endif

src/guiengine/skin.hpp

@@ -190,7 +190,7 @@ namespace GUIEngine
         }   // SkinWidgetContainer
     };   // class SkinWidgetContainer
 
-    // ------------------------------------------------------------------------
+    // ========================================================================
     class Widget;
 
     /**
@@ -256,7 +256,7 @@ namespace GUIEngine
         video::ITexture* getImage() { return m_image; }
     };   // BoxRenderParams
 
-    // ------------------------------------------------------------------------
+    // ========================================================================
     /**
       * \brief Object used to render the GUI widgets
       * see \ref skin for more information about skinning in STK

src/input/input_device.cpp

@@ -83,7 +83,7 @@ bool KeyboardDevice::processAndMapInput(const int id,
     }
 }   // processAndMapInput
 
-// ----------------------------------------------------------------------------
+// ============================================================================
 
 #if 0
 #pragma mark -

src/input/wiimote_manager.cpp

@@ -396,7 +396,7 @@ int WiimoteManager::askUserToConnectWiimotes()
     return getNumberOfWiimotes();
 }   // askUserToConnectWiimotes
 
-// ----------------------------------------------------------------------------
+// ============================================================================
 /** Calles when the user clicks on OK, i.e. all wiimotes are in discovery
  *  mode.
  */

src/io/file_manager.cpp

@@ -95,7 +95,7 @@ bool macSetBundlePathIfRelevant(std::string& data_dir)
 }
 #endif
 
-// ----------------------------------------------------------------------------
+// ============================================================================
 FileManager* file_manager = 0;
 
 /** With irrlicht the constructor creates a NULL device. This is necessary to
@@ -139,7 +139,7 @@ FileManager::FileManager()
     irr::io::path exe_path;
 
     // Search for the root directory
-    // -----------------------------
+    // =============================
 
     // Also check for data dirs relative to the path of the executable.
     // This is esp. useful for Visual Studio, since it's not necessary
@@ -212,7 +212,7 @@ FileManager::FileManager()
                m_gp_dir.c_str());
 
     /** Now search for the path to all needed subdirectories. */
-    // ----------------------------------------------------------
+    // ==========================================================
     // This must be done here since otherwise translations will not be found.
     std::vector<bool> dir_found;
     dir_found.resize(ASSET_COUNT, false);
@@ -296,7 +296,7 @@ void FileManager::reInit()
 FileManager::~FileManager()
 {
     // Clean up left-over files in addons/tmp that are older than 24h
-    // --------------------------------------------------------------
+    // ==============================================================
     // (The 24h delay is useful when debugging a problem with a zip file)
     std::set<std::string> allfiles;
     std::string tmp=getAddonsFile("tmp");
@@ -341,7 +341,7 @@ FileManager::~FileManager()
     }   // for i in all files in tmp
 
     // Clean up rest of file manager
-    // -----------------------------
+    // =============================
     popMusicSearchPath();
     popModelSearchPath();
     popTextureSearchPath();

src/items/item_manager.cpp

@@ -139,7 +139,7 @@ void ItemManager::removeTextures()
 }   // removeTextures
 
 
-// ----------------------------------------------------------------------------
+// ============================================================================
 /** Creates a new instance of the item manager. This is done at startup
  *  of each race. */
 ItemManager::ItemManager()

src/items/item_manager.hpp

@@ -71,7 +71,7 @@ public:
         return m_item_manager;
     }   // get
 
-    // ------------------------------------------------------------------------
+    // ========================================================================
 private:
     /** The vector of all items of the current track. */
     typedef std::vector<Item*> AllItemTypes;

src/items/rubber_ball.cpp

@@ -384,7 +384,7 @@ bool RubberBall::updateAndDelete(float dt)
     TrackSector::update(next_xyz);
 
     // Ball squashing:
-    // ---------------
+    // ===============
     if(height<1.5f*m_extend.getY())
         m_node->setScale(core::vector3df(1.0f, height/m_extend.getY(),1.0f));
     else
@@ -574,7 +574,7 @@ float RubberBall::updateHeight()
 
 
     // Determine the height of the ball
-    // --------------------------------
+    // ================================
     // Consider f(x) = s * x*(x-m_intervall), which is a parabolic function
     // with f(0) = 0, f(m_intervall)=0. We then scale this function to
     // fulfill: f(m_intervall/2) = max_height, or:

src/items/rubber_band.cpp

@@ -236,7 +236,7 @@ void RubberBand::hit(AbstractKart *kart_hit, const Vec3 *track_xyz)
 
 
     // A kart was hit
-    // --------------
+    // ==============
     if(kart_hit)
     {
         if(kart_hit->isShielded())
@@ -253,7 +253,7 @@ void RubberBand::hit(AbstractKart *kart_hit, const Vec3 *track_xyz)
     }
 
     // The track was hit
-    // -----------------
+    // =================
     m_hit_position   = *track_xyz;
     m_attached_state = RB_TO_TRACK;
 }   // hit

src/karts/abstract_kart.hpp

@@ -85,7 +85,7 @@ public:
     virtual core::stringw getName() const;
     virtual void   reset();
     virtual void   init(RaceManager::KartType type) = 0;
-    // ------------------------------------------------------------------------
+    // ========================================================================
     // Functions related to controlling the kart
     // ------------------------------------------------------------------------
     /** Returns the current steering value for this kart. */
@@ -100,7 +100,7 @@ public:
     /** Sets the kart controls. Used e.g. by replaying history. */
     void setControls(const KartControl &c) { m_controls = c; }
 
-    // ------------------------------------------------------------------------
+    // ========================================================================
     // Access to the kart properties.
     // ------------------------------------------------------------------------
     /** Returns the kart properties of this kart. */
@@ -124,7 +124,7 @@ public:
      */
     virtual float getTimeFullSteer(float steer) const = 0;
 
-    // ------------------------------------------------------------------------
+    // ========================================================================
     // Attachment related functions.
     // ------------------------------------------------------------------------
     /** Returns the current attachment. */
@@ -133,7 +133,7 @@ public:
     /** Returns the current attachment, non-const version. */
     Attachment*    getAttachment() {return m_attachment; }
 
-    // ------------------------------------------------------------------------
+    // ========================================================================
     // Access to the graphical kart model.
     // ------------------------------------------------------------------------
     /** Returns this kart's kart model. */
@@ -163,7 +163,7 @@ public:
     const Vec3& getWheelGraphicsPosition(int i) const
                 {assert(i>=0 && i<4); return m_wheel_graphics_position[i];}
 
-    // ------------------------------------------------------------------------
+    // ========================================================================
     // Emergency animation related functions.
     // ------------------------------------------------------------------------
     /** Returns a kart animation (if any), or NULL if currently no kart

src/karts/kart.hpp

@@ -268,7 +268,7 @@ public:
     virtual bool   playCustomSFX    (unsigned int type);
     virtual void   setController(Controller *controller);
 
-    // ------------------------------------------------------------------------
+    // ========================================================================
     // Powerup related functions.
     // ------------------------------------------------------------------------
     /** Sets a new powerup. */

src/main.cpp

@@ -205,9 +205,9 @@
 static void cleanSuperTuxKart();
 static void cleanUserConfig();
 
-// ----------------------------------------------------------------------------
+// ============================================================================
 //                        gamepad visualisation screen
-// ----------------------------------------------------------------------------
+// ============================================================================
 
 void gamepadVisualisation()
 {
@@ -360,7 +360,7 @@ void gamepadVisualisation()
     }
 }   // gamepadVisualisation
 
-// ----------------------------------------------------------------------------
+// ============================================================================
 /** Sets the hat mesh name depending on the current christmas mode
  *  m_xmas_mode (0: use current date, 1: always on, 2: always off).
  */
@@ -385,7 +385,7 @@ void handleXmasMode()
     if(xmas)
         kart_properties_manager->setHatMeshName("christmas_hat.b3d");
 }   // handleXmasMode
-// ----------------------------------------------------------------------------
+// ============================================================================
 /** This function sets up all data structure for an immediate race start.
  *  It is used when the -N or -R command line options are used.
  */
@@ -642,7 +642,7 @@ int handleCmdLinePreliminary()
     return 0;
 }   // handleCmdLinePreliminary
 
-// ----------------------------------------------------------------------------
+// ============================================================================
 /** Handles command line options.
  *  \param argc Number of command line options
  */
@@ -1331,7 +1331,7 @@ int main(int argc, char *argv[] )
 
 
         // Replay a race
-        // -------------
+        // =============
         if(history->replayHistory())
         {
             // This will setup the race manager etc.
@@ -1346,13 +1346,13 @@ int main(int argc, char *argv[] )
         }
 
         // Not replaying
-        // -------------
+        // =============
         if(!ProfileWorld::isProfileMode())
         {
             if(UserConfigParams::m_no_start_screen)
             {
                 // Quickstart (-N)
-                // ---------------
+                // ===============
                 // all defaults are set in InitTuxkart()
                 race_manager->setupPlayerKartInfo();
                 race_manager->startNew(false);
@@ -1361,7 +1361,7 @@ int main(int argc, char *argv[] )
         else  // profile
         {
             // Profiling
-            // ---------
+            // =========
             race_manager->setMajorMode (RaceManager::MAJOR_MODE_SINGLE);
             race_manager->setupPlayerKartInfo();
             race_manager->startNew(false);
@@ -1410,7 +1410,7 @@ int main(int argc, char *argv[] )
     return 0 ;
 }   // main
 
-// ----------------------------------------------------------------------------
+// ============================================================================
 #ifdef WIN32
 //routine for running under windows
 int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,

src/modes/world.hpp

@@ -185,7 +185,7 @@ public:
                     World();
     virtual        ~World();
     // Static functions to access world:
-    // ---------------------------------
+    // =================================
     // ------------------------------------------------------------------------
     /** Returns a pointer to the (singleton) world object. */
     static World*   getWorld() { return m_world; }
@@ -201,7 +201,7 @@ public:
     // ------------------------------------------------------------------------
 
     // Pure virtual functions
-    // ----------------------
+    // ======================
 
     /** Each game mode should have a unique identifier. Override
       * this method in child classes to provide it. */
@@ -237,7 +237,7 @@ public:
     // ------------------------------------------------------------------------
 
     // Virtual functions
-    // -----------------
+    // =================
     virtual void    init();
     virtual void    terminateRace() OVERRIDE;
     virtual void    reset();
@@ -269,7 +269,7 @@ public:
     virtual void onMouseClick(int x, int y) {};
 
     // Other functions
-    // ---------------
+    // ===============
     Highscores     *getHighscores() const;
     void            schedulePause(Phase phase);
     void            scheduleUnpause();

src/online/online_player_profile.cpp

@@ -68,7 +68,7 @@ namespace Online
             request->addParameter("action", action);
     }   // setUserDetails
 
-    // ------------------------------------------------------------------------
+    // ========================================================================
     OnlinePlayerProfile::OnlinePlayerProfile(const XMLNode *player)
                : PlayerProfile(player)
     {

src/online/online_player_profile.hpp

@@ -40,7 +40,7 @@ namespace Online
 
     class OnlineProfile;
 
-    // ----------------------------------------------------------------------------
+    // ============================================================================
 
     /**
       * \brief Class that represents an online registered user

src/online/online_profile.cpp

@@ -53,7 +53,7 @@ void OnlineProfile::RelationInfo::setOnline(bool online)
         m_is_pending = false;
 }
 
-// ----------------------------------------------------------------------------
+// ============================================================================
 /** Constructor for a new profile.  It does only store the ID, a name, and
  *  if it is the current user.
  */

src/online/online_profile.hpp

@@ -46,7 +46,7 @@ public:
         C_RELATION_INFO
     };
 
-    // ------------------------------------------------------------------------
+    // ========================================================================
     class RelationInfo
     {
     private:
@@ -67,7 +67,7 @@ public:
         // --------------------------------------------------------------------
         bool isOnline() const { return m_is_online; }
     };  // class RelationInfo
-    // ------------------------------------------------------------------------
+    // ========================================================================
 
     typedef std::vector<uint32_t> IDList;
 private:

src/online/request.cpp

@@ -29,7 +29,7 @@
 namespace Online
 {
 
-    // ------------------------------------------------------------------------
+    // ========================================================================
     /**
      *  Creates a request that can be handled by the RequestManager
      *  \param manage_memory whether or not the RequestManager should take care of

src/online/request.hpp

@@ -211,7 +211,7 @@ namespace Online
          *  members to a valid value. */
         virtual bool isAllowedToAdd()   const   { return isPreparing(); }
 
-        // --------------------------------------------------------------------
+        // ====================================================================
         /** This class is used by the priority queue to sort requests by
          *  priority.
          */

src/online/servers_manager.cpp

@@ -45,7 +45,7 @@ namespace Online{
         manager_singleton = NULL;
     }   // deallocate
 
-    // ----------------------------------------------------------------------------
+    // ============================================================================
     ServersManager::ServersManager(){
         m_last_load_time.setAtomic(0.0f);
         m_joined_server.setAtomic(NULL);
@@ -57,7 +57,7 @@ namespace Online{
         delete m_joined_server.getData();
     }
 
-    // ----------------------------------------------------------------------------
+    // ============================================================================
     void ServersManager::cleanUpServers()
     {
         m_sorted_servers.lock();
@@ -68,7 +68,7 @@ namespace Online{
         m_mapped_servers.unlock();
     }
 
-    // ----------------------------------------------------------------------------
+    // ============================================================================
     ServersManager::RefreshRequest * ServersManager::refreshRequest(bool request_now) const
     {
         RefreshRequest * request = NULL;
@@ -103,7 +103,7 @@ namespace Online{
         ServersManager::get()->refresh(isSuccess(), getXMLData());
     }
 
-    // ----------------------------------------------------------------------------
+    // ============================================================================
     const Server * ServersManager::getQuickPlay() const
     {
         if(m_sorted_servers.getData().size() > 0)
@@ -112,7 +112,7 @@ namespace Online{
         return NULL;
     }
 
-    // ----------------------------------------------------------------------------
+    // ============================================================================
     void ServersManager::setJoinedServer(uint32_t id)
     {
         MutexLocker(m_joined_server);
@@ -121,7 +121,7 @@ namespace Online{
         m_joined_server.getData() = new Server(*getServerByID(id));
     }
 
-    // ----------------------------------------------------------------------------
+    // ============================================================================
     void ServersManager::unsetJoinedServer()
     {
         MutexLocker(m_joined_server);
@@ -129,7 +129,7 @@ namespace Online{
         m_joined_server.getData() = NULL;
     }
 
-    // ----------------------------------------------------------------------------
+    // ============================================================================
     void ServersManager::addServer(Server * server)
     {
         m_sorted_servers.lock();
@@ -140,34 +140,34 @@ namespace Online{
         m_mapped_servers.unlock();
     }
 
-    // ----------------------------------------------------------------------------
+    // ============================================================================
     int ServersManager::getNumServers () const
     {
         MutexLocker(m_sorted_servers);
         return m_sorted_servers.getData().size();
     }
 
-    // ----------------------------------------------------------------------------
+    // ============================================================================
     const Server * ServersManager::getServerBySort (int index) const
     {
         MutexLocker(m_sorted_servers);
         return m_sorted_servers.getData().get(index);
     }
 
-    // ----------------------------------------------------------------------------
+    // ============================================================================
     const Server * ServersManager::getServerByID (uint32_t id) const
     {
         MutexLocker(m_mapped_servers);
         return m_mapped_servers.getData().at(id);
     }
 
-    // ----------------------------------------------------------------------------
+    // ============================================================================
     Server * ServersManager::getJoinedServer() const
     {
         return m_joined_server.getAtomic();
     }
 
-    // ----------------------------------------------------------------------------
+    // ============================================================================
     void ServersManager::sort(bool sort_desc){
         MutexLocker(m_sorted_servers);
         m_sorted_servers.getData().insertionSort(0, sort_desc);

src/physics/btKart.cpp

@@ -35,7 +35,7 @@ btRigidBody& btKart::getFixedBody()
     return s_fixed;
 }
 
-// ----------------------------------------------------------------------------
+// ============================================================================
 btKart::btKart(btRigidBody* chassis, btVehicleRaycaster* raycaster,
                Kart *kart)
       : m_vehicleRaycaster(raycaster)

src/physics/btKartRaycast.cpp

@@ -22,7 +22,7 @@
 void* btKartRaycaster::castRay(const btVector3& from, const btVector3& to,
                                btVehicleRaycasterResult& result)
 {
-    // ------------------------------------------------------------------------
+    // ========================================================================
     class ClosestWithNormal : public btCollisionWorld::ClosestRayResultCallback
     {
     private:
@@ -55,7 +55,7 @@ void* btKartRaycaster::castRay(const btVector3& from, const btVector3& to,
         int getTriangleIndex() const { return m_triangle_index; }
 
     };   // CloestWithNormal
-    // ------------------------------------------------------------------------
+    // ========================================================================
 
     ClosestWithNormal rayCallback(from,to);
 

src/physics/physical_object.cpp

@@ -98,7 +98,7 @@ void PhysicalObject::Settings::init()
     m_flatten_kart       = false;
 }   // Settings
 
-// ----------------------------------------------------------------------------
+// ============================================================================
 PhysicalObject* PhysicalObject::fromXML(bool is_dynamic,
                                         const XMLNode &xml_node,
                                         TrackObject* object)

src/physics/physics.cpp

@@ -224,7 +224,7 @@ void Physics::update(float dt)
 
         }
         // now the first object must be a projectile
-        // -----------------------------------------
+        // =========================================
         if(p->getUserPointer(1)->is(UserPointer::UP_TRACK))
         {
             // Projectile hits track
@@ -487,7 +487,7 @@ btScalar Physics::solveGroup(btCollisionObject** bodies, int numBodies,
         if(!upA || !upB) continue;
 
         // 1) object A is a track
-        // -----------------------
+        // =======================
         if(upA->is(UserPointer::UP_TRACK))
         {
             if(upB->is(UserPointer::UP_FLYABLE))   // 1.1 projectile hits track
@@ -520,7 +520,7 @@ btScalar Physics::solveGroup(btCollisionObject** bodies, int numBodies,
             }
         }
         // 2) object a is a kart
-        // ---------------------
+        // =====================
         else if(upA->is(UserPointer::UP_KART))
         {
             if(upB->is(UserPointer::UP_TRACK))
@@ -555,7 +555,7 @@ btScalar Physics::solveGroup(btCollisionObject** bodies, int numBodies,
                     upA, contact_manifold->getContactPoint(0).m_localPointA);
         }
         // 3) object is a projectile
-        // -------------------------
+        // =========================
         else if(upA->is(UserPointer::UP_FLYABLE))
         {
             // 3.1) projectile hits track
@@ -573,7 +573,7 @@ btScalar Physics::solveGroup(btCollisionObject** bodies, int numBodies,
             }
         }
         // Object is a physical object
-        // ---------------------------
+        // ===========================
         else if(upA->is(UserPointer::UP_PHYSICAL_OBJECT))
         {
             if(upB->is(UserPointer::UP_FLYABLE))

src/physics/physics.hpp

@@ -100,7 +100,7 @@ private:
         }   // getContactPointCS
     };  // CollisionPair
 
-    // ------------------------------------------------------------------------
+    // ========================================================================
     // This class is the list of collision objects, where each collision
     // pair is stored as most once.
     class CollisionList : public std::vector<CollisionPair>
@@ -121,7 +121,7 @@ private:
             push_back(CollisionPair(a, contact_point_a, b, contact_point_b));
         }
     };  // CollisionList
-    // ------------------------------------------------------------------------
+    // ========================================================================
 
     /** This flag is set while bullets time step processing is taking
     *  place. It is used to avoid altering data structures that might

src/race/race_manager.cpp

@@ -295,7 +295,7 @@ void RaceManager::startNew(bool from_overworld)
         m_num_karts = (int)m_player_karts.size();
 
     // Create the kart status data structure to keep track of scores, times, ...
-    // --------------------------------------------------------------------------
+    // ==========================================================================
     m_kart_status.clear();
     Log::verbose("RaceManager", "Nb of karts=%u, ai:%lu players:%lu\n", (unsigned int)m_num_karts, m_ai_kart_list.size(), m_player_karts.size());
 
@@ -344,7 +344,7 @@ void RaceManager::startNew(bool from_overworld)
         !NetworkWorld::getInstance<NetworkWorld>()->isRunning()) // offline mode only
     {
         //We look if Player 1 has a saved version of this GP.
-        // -------------------------------------------------
+        // =================================================
         SavedGrandPrix* gp = SavedGrandPrix::getSavedGP( StateManager::get()
                                                          ->getActivePlayerProfile(0)
                                                          ->getUniqueID(),
@@ -354,7 +354,7 @@ void RaceManager::startNew(bool from_overworld)
                                                          m_player_karts.size());
 
         // Start the race with the appropriate track
-        // -----------------------------------------
+        // =========================================
         if(gp != NULL)
         {
             if (m_continue_saved_gp)
@@ -392,7 +392,7 @@ void RaceManager::startNextRace()
     m_num_finished_players = 0;
 
     // if subsequent race, sort kart status structure
-    // ----------------------------------------------
+    // ==============================================
     if (m_track_number > 0)
     {
         // In follow the leader mode do not change the first kart,

src/states_screens/dialogs/addons_loading.cpp

@@ -111,7 +111,7 @@ void AddonsLoading::beforeAddingWidgets()
     rating->setStarNumber(3);
 
     // Display flags for this addon
-    // ----------------------------
+    // ============================
     std::vector<core::stringw> l;
     if(UserConfigParams::m_artist_debug_mode)
     {
@@ -154,7 +154,7 @@ void AddonsLoading::beforeAddingWidgets()
     }
 
     // Display the size
-    // ----------------
+    // ================
     int n = m_addon.getSize();
     core::stringw unit="";
     if(n>1024*1024)

src/states_screens/feature_unlocked.cpp

@@ -58,7 +58,7 @@ const int GIFT_EXIT_TO = GIFT_EXIT_FROM + 7;
 
 DEFINE_SCREEN_SINGLETON( FeatureUnlockedCutScene );
 
-// ----------------------------------------------------------------------------
+// ============================================================================
 
 #if 0
 #pragma mark FeatureUnlockedCutScene::UnlockedThing
@@ -124,7 +124,7 @@ FeatureUnlockedCutScene::UnlockedThing::~UnlockedThing()
     m_root_gift_node = NULL;
 }   // UnlockedThing::~UnlockedThing
 
-// ----------------------------------------------------------------------------
+// ============================================================================
 
 #if 0
 #pragma mark -

src/states_screens/kart_selection.cpp

@@ -121,7 +121,7 @@ void FocusDispatcher::add()
 
 static FocusDispatcher* g_dispatcher = NULL;
 
-// ----------------------------------------------------------------------------
+// ============================================================================
 
 /** A small extension to the spinner widget to add features like player ID
  *  management or badging */
@@ -176,7 +176,7 @@ void PlayerNameSpinner::markAsCorrect()
         m_incorrect = false;
     }
 }   // markAsCorrect
-// ----------------------------------------------------------------------------
+// ============================================================================
 
 #if 0
 #pragma mark -
@@ -871,7 +871,7 @@ bool sameKart(const PlayerKartWidget& player1, const PlayerKartWidget& player2)
 #pragma mark -
 #pragma mark KartHoverListener
 #endif
-// ----------------------------------------------------------------------------
+// ============================================================================
 
 KartHoverListener::KartHoverListener(KartSelectionScreen* parent)
 {
@@ -921,7 +921,7 @@ void KartHoverListener::onSelectionChanged(DynamicRibbonWidget* theWidget,
 #pragma mark KartSelectionScreen
 #endif
 
-// ----------------------------------------------------------------------------
+// ============================================================================
 
 KartSelectionScreen::KartSelectionScreen(const char* filename) : Screen(filename)
 {
@@ -931,7 +931,7 @@ KartSelectionScreen::KartSelectionScreen(const char* filename) : Screen(filename
     m_go_to_overworld_next = false;
 }   // KartSelectionScreen
 
-// ----------------------------------------------------------------------------
+// ============================================================================
 
 KartSelectionScreen* KartSelectionScreen::getRunningInstance()
 {

src/states_screens/race_result_gui.cpp

@@ -635,7 +635,7 @@ void RaceResultGUI::renderGlobal(float dt)
     unsigned int num_karts = m_all_row_infos.size();
 
     // First: Update the finite state machine
-    // --------------------------------------
+    // ======================================
     switch(m_animation_state)
     {
     case RR_INIT:
@@ -733,7 +733,7 @@ void RaceResultGUI::renderGlobal(float dt)
     }   // switch
 
     // Second phase: update X and Y positions for the various animations
-    // -----------------------------------------------------------------
+    // =================================================================
     float v = 0.9f*UserConfigParams::m_width/m_time_single_scroll;
     if(!isSoccerWorld)
     {
@@ -902,7 +902,7 @@ void RaceResultGUI::displayOneEntry(unsigned int x, unsigned int y,
     }
 
     // Only display points in GP mode and when the GP results are displayed.
-    // ---------------------------------------------------------------------
+    // =====================================================================
     if (race_manager->getMajorMode() == RaceManager::MAJOR_MODE_GRAND_PRIX &&
         m_animation_state != RR_RACE_RESULT)
     {

src/states_screens/state_manager.cpp

@@ -51,7 +51,7 @@ void StateManager::deallocate()
 }   // deallocate
 
 
-// ----------------------------------------------------------------------------
+// ============================================================================
 
 #if 0
 #pragma mark -
@@ -245,7 +245,7 @@ void StateManager::onStackEmptied()
     main_loop->abort();
 }   // onStackEmptied
 
-// ----------------------------------------------------------------------------
+// ============================================================================
 
 #if 0
 #pragma mark -

src/states_screens/state_manager.hpp

@@ -172,7 +172,7 @@ public:
 
     };   // ActivePlayer
 
-    // ------------------------------------------------------------------------
+    // ========================================================================
     const PtrVector<ActivePlayer, HOLD>& getActivePlayers()
                                  { return m_active_players; }
     ActivePlayer* getActivePlayer(const int id);

src/states_screens/user_screen.cpp

@@ -549,7 +549,7 @@ void BaseUserScreen::unloaded()
 
 
 
-// ----------------------------------------------------------------------------
+// ============================================================================
 /** In the tab version, make sure the right tab is selected.
  */
 void TabbedUserScreen::init()

src/states_screens/user_screen.hpp

@@ -114,7 +114,7 @@ public:
     void logoutError(const irr::core::stringw &error_message);
 };   // class BaseUserScreen
 
-// ----------------------------------------------------------------------------
+// ============================================================================
 class UserScreen : public BaseUserScreen,
                    public GUIEngine::ScreenSingleton<UserScreen>
 {
@@ -125,7 +125,7 @@ public:
     friend class GUIEngine::ScreenSingleton<UserScreen>;
 };   // class UserScreenTabed
 
-// ----------------------------------------------------------------------------
+// ============================================================================
 class TabbedUserScreen : public BaseUserScreen,
                          public GUIEngine::ScreenSingleton<TabbedUserScreen>
 {

src/utils/leak_check.cpp

@@ -99,7 +99,7 @@ namespace MemoryLeaks
 
     }   // print
 
-    // ------------------------------------------------------------------------
+    // ========================================================================
     /** Adds an object to the sets of all allocated objects. */
     void addObject(AllocatedObject* obj)
     {

src/utils/leak_check.hpp

@@ -52,7 +52,7 @@ namespace MemoryLeaks
         virtual void print() const;
     };   // AllocatedObjects
 
-    // ------------------------------------------------------------------------
+    // ========================================================================
     void checkForLeaks();
 
     void addObject(AllocatedObject* obj);