Made the KartRewinder to be a kart (which gives it easier access to

some of the kart attributes that need to be saved).

src/items/attachment.cpp

@@ -231,7 +231,7 @@ void Attachment::clear()
 /** Saves the attachment state. Called as part of the kart saving its state.
  *  \param buffer The kart rewinder's state buffer.
  */
-void Attachment::saveState(BareNetworkString *buffer)
+void Attachment::saveState(BareNetworkString *buffer) const
 {
     // We use bit 7 to indicate if a previous owner is defined for a bomb
     assert(ATTACH_MAX<=127);

src/items/attachment.hpp

@@ -118,7 +118,7 @@ public:
                AbstractKart *previous_kart=NULL);
     virtual void rewind(BareNetworkString *buffer);
     void rewindTo(BareNetworkString *buffer);
-    void saveState(BareNetworkString *buffer);
+    void saveState(BareNetworkString *buffer) const;
 
     // ------------------------------------------------------------------------
     /** Sets the type of the attachment, but keeps the old time left value. */

src/items/powerup.cpp

@@ -74,7 +74,7 @@ void Powerup::reset()
  *  state or when a new powerup even is saved.
  *  \param buffer The buffer into which to save the state.
  */
-void Powerup::saveState(BareNetworkString *buffer)
+void Powerup::saveState(BareNetworkString *buffer) const
 {
     buffer->addUInt8(uint8_t(m_type));
     if(m_type!=PowerupManager::POWERUP_NOTHING)

src/items/powerup.hpp

@@ -60,7 +60,7 @@ public:
     void            adjustSound  ();
     void            use          ();
     void            hitBonusBox (const Item &item, int newC=-1);
-    void            saveState(BareNetworkString *buffer);
+    void            saveState(BareNetworkString *buffer) const;
     void            rewindTo(BareNetworkString *buffer);
 
 

src/karts/controller/kart_control.hpp

@@ -100,7 +100,7 @@ public:
     static int getLength() { return 9; }
     // ------------------------------------------------------------------------
     /** Copies the important data from this objects into a memory buffer. */
-    void copyToBuffer(BareNetworkString *buffer)
+    void copyToBuffer(BareNetworkString *buffer) const
     {
         buffer->add(m_steer);
         buffer->add(m_accel);

src/karts/kart.cpp

@@ -232,7 +232,6 @@ void Kart::init(RaceManager::KartType type)
     // Create the stars effect
     m_stars_effect = new Stars(this);
 
-    m_rewinder = new KartRewinder(this);
     reset();
 }   // init
 
@@ -243,8 +242,6 @@ void Kart::init(RaceManager::KartType type)
  */
 Kart::~Kart()
 {
-	delete m_rewinder;
-
     // Delete all custom sounds (TODO: add back when properly done)
     /*
     for (int n = 0; n < SFXManager::NUM_CUSTOMS; n++)
@@ -412,9 +409,6 @@ void Kart::reset()
     if(m_controller)
         m_controller->reset();
 
-    // Must be called after the controls are reset
-    m_rewinder->reset();
-
     // 3 strikes mode can hide the wheels
     scene::ISceneNode** wheels = getKartModel()->getWheelNodes();
     if(wheels[0]) wheels[0]->setVisible(true);
@@ -1496,8 +1490,6 @@ void Kart::update(float dt)
         }
     }
 
-    // Store current controls if there was any change from the previous state:
-    m_rewinder->update();
 }   // update
 
 //-----------------------------------------------------------------------------

src/karts/kart.hpp

@@ -76,7 +76,7 @@ protected:
     /** Is time flying activated */
     bool m_is_jumping;
 
-private:
+protected:
     /** Handles speed increase and capping due to powerup, terrain, ... */
     MaxSpeed *m_max_speed;
 
@@ -199,9 +199,6 @@ private:
     float         m_view_blocked_by_plunger;
     float         m_speed;
 
-	/** The rewinder object for network play. */
-	KartRewinder *m_rewinder;
-
     std::vector<SFXBase*> m_custom_sounds;
     SFXBase      *m_beep_sound;
     SFXBase      *m_engine_sound;

src/karts/kart_rewinder.cpp

@@ -27,9 +27,14 @@
 
 #include <string.h>
 
-KartRewinder::KartRewinder(AbstractKart *kart) : Rewinder(/*can_be_destroyed*/ false)
+KartRewinder::KartRewinder(const std::string& ident,unsigned int world_kart_id,
+                           int position, const btTransform& init_transform,
+                           PerPlayerDifficulty difficulty,
+                           RenderInfo::KartRenderType krt)
+            : Rewinder(/*can_be_destroyed*/ false)
+            , Kart(ident, world_kart_id, position, init_transform, difficulty,
+                   krt)
 {
-    m_kart = kart;
 }   // KartRewinder
 
 // ----------------------------------------------------------------------------
@@ -37,6 +42,8 @@ KartRewinder::KartRewinder(AbstractKart *kart) : Rewinder(/*can_be_destroyed*/ f
  */
 void KartRewinder::reset()
 {
+    Kart::reset();
+    Rewinder::reset();
 }   // reset
 
 // ----------------------------------------------------------------------------
@@ -52,7 +59,7 @@ BareNetworkString* KartRewinder::saveState() const
     const int MEMSIZE = 13*sizeof(float) + 9+2;
 
     BareNetworkString *buffer = new BareNetworkString(MEMSIZE);
-    const btRigidBody *body = m_kart->getBody();
+    const btRigidBody *body = getBody();
 
     // 1) Physics values: transform and velocities
     // -------------------------------------------
@@ -65,15 +72,15 @@ BareNetworkString* KartRewinder::saveState() const
 
     // 2) Steering and other player controls
     // -------------------------------------
-    m_kart->getControls().copyToBuffer(buffer);
+    getControls().copyToBuffer(buffer);
 
     // 3) Attachment
     // -------------
-    m_kart->getAttachment()->saveState(buffer);
+    getAttachment()->saveState(buffer);
 
     // 4) Powerup
     // ----------
-    m_kart->getPowerup()->saveState(buffer);
+    getPowerup()->saveState(buffer);
     return buffer;
 }   // saveState
 
@@ -88,22 +95,22 @@ void KartRewinder::rewindToState(BareNetworkString *buffer)
     btTransform t;
     t.setOrigin(buffer->getVec3());
     t.setRotation(buffer->getQuat());
-    btRigidBody *body = m_kart->getBody();
+    btRigidBody *body = getBody();
     body->proceedToTransform(t);
     body->setLinearVelocity(buffer->getVec3());
     body->setAngularVelocity(buffer->getVec3());
 
     // 2) Steering and other controls
     // ------------------------------
-    m_kart->getControls().setFromBuffer(buffer);
+    getControls().setFromBuffer(buffer);
 
     // 3) Attachment
     // -------------
-    m_kart->getAttachment()->rewindTo(buffer);
+    getAttachment()->rewindTo(buffer);
 
     // 4) Powerup
     // ----------
-    m_kart->getPowerup()->rewindTo(buffer);
+    getPowerup()->rewindTo(buffer);
     return;
 }   // rewindToState
 
@@ -111,8 +118,9 @@ void KartRewinder::rewindToState(BareNetworkString *buffer)
 /** Called once a frame. It will add a new kart control event to the rewind
  *  manager if any control values have changed.
  */
-void KartRewinder::update()
+void KartRewinder::update(float dt)
 {
+    Kart::update(dt);
 }   // update
 
 // ----------------------------------------------------------------------------

src/karts/kart_rewinder.hpp

@@ -19,28 +19,33 @@
 #ifndef HEADER_KART_REWINDER_HPP
 #define HEADER_KART_REWINDER_HPP
 
+#include "karts/kart.hpp"
 #include "network/rewinder.hpp"
 #include "utils/cpp2011.hpp"
 
 class AbstractKart;
 class BareNetworkString;
 
-class KartRewinder : public Rewinder
+class KartRewinder : public Rewinder, public Kart
 {
 private:
-	/** Pointer to the original kart object. */
-	AbstractKart *m_kart;
     
     // Flags to indicate the different event types
     enum { EVENT_CONTROL = 0x01,
            EVENT_ATTACH  = 0x02 };
 public:
-	             KartRewinder(AbstractKart *kart);
+	             KartRewinder(const std::string& ident,
+                              unsigned int world_kart_id,
+                              int position, const btTransform& init_transform,
+                              PerPlayerDifficulty difficulty,
+                              RenderInfo::KartRenderType krt =
+                                                      RenderInfo::KRT_DEFAULT);
    virtual      ~KartRewinder() {};
    virtual BareNetworkString* saveState() const;
    void          reset();
    virtual void  rewindToState(BareNetworkString *p) OVERRIDE;
    virtual void  rewindToEvent(BareNetworkString *p) OVERRIDE;
+   virtual void  update(float dt);
 
    // -------------------------------------------------------------------------
    virtual void  undoState(BareNetworkString *p) OVERRIDE
@@ -54,8 +59,7 @@ public:
 
    // -------------------------------------------------------------------------
 
-   void update();
-
+   
 
 };   // Rewinder
 #endif

src/modes/world.cpp

@@ -40,6 +40,7 @@
 #include "karts/controller/network_player_controller.hpp"
 #include "karts/kart.hpp"
 #include "karts/kart_properties_manager.hpp"
+#include "karts/kart_rewinder.hpp"
 #include "modes/overworld.hpp"
 #include "modes/profile_world.hpp"
 #include "modes/soccer_world.hpp"
@@ -338,8 +339,12 @@ AbstractKart *World::createKart(const std::string &kart_ident, int index,
 
     int position           = index+1;
     btTransform init_pos   = getStartTransform(index - gk);
-    AbstractKart *new_kart = new Kart(kart_ident, index, position, init_pos,
-                                      difficulty);
+    AbstractKart *new_kart;
+    if (RewindManager::get()->isEnabled())
+        new_kart = new KartRewinder(kart_ident, index, position, init_pos,
+                                    difficulty);
+    else
+        new_kart = new Kart(kart_ident, index, position, init_pos, difficulty);
     new_kart->init(race_manager->getKartType(index));
     Controller *controller = NULL;
     switch(kart_type)

src/network/rewinder.hpp

@@ -58,6 +58,9 @@ public:
     */
    virtual void undoState(BareNetworkString *buffer) = 0;
 
+   // -------------------------------------------------------------------------
+   /** Nothing to do here. */
+   virtual void reset() {};
    // -------------------------------------------------------------------------
    /** True if this rewinder can be destroyed. Karts can not be destroyed,
     *  cakes can. This is used by the RewindManager in reset. */