ilikecats/stk-code_catmod
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Save nitro and zipper GFX in replay

Browse Source
This commit is contained in:
Benau 2016-02-05 09:30:40 +08:00
parent 5810acb114
commit 0091c1555a
9 changed files with 109 additions and 140 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/karts/abstract_kart.hpp
View File

@ -46,6 +46,7 @@ class Material;
class Powerup;
class Skidding;
class SlipStream;
class TerrainInfo;
/** An abstract interface for the actual karts. Some functions are actually
* implemented here in order to allow inlining.
@ -421,6 +422,9 @@ public:
/** Shows the star effect for a certain time. */
virtual void showStarEffect(float t) = 0;
// ------------------------------------------------------------------------
/** Returns the terrain info oject. */
virtual const TerrainInfo *getTerrainInfo() const = 0;
// ------------------------------------------------------------------------
/** Called when the kart crashes against another kart.
* \param k The kart that was hit.
* \param update_attachments If true the attachment of this kart and the

75
src/karts/ghost_kart.cpp
View File

@ -17,6 +17,7 @@
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#include "karts/ghost_kart.hpp"
#include "karts/kart_gfx.hpp"
#include "karts/kart_model.hpp"
#include "modes/world.hpp"
@ -27,11 +28,10 @@ GhostKart::GhostKart(const std::string& ident)
: Kart(ident, /*world kart id*/99999,
/*position*/-1, btTransform(), PLAYER_DIFFICULTY_NORMAL)
{
m_current_transform = 0;
m_next_event = 0;
m_all_times.clear();
m_all_transform.clear();
m_all_physic_info.clear();
m_all_replay_events.clear();
} // GhostKart
// ----------------------------------------------------------------------------
@ -40,19 +40,15 @@ void GhostKart::reset()
m_node->setVisible(true);
Kart::reset();
m_current_transform = 0;
m_next_event = 0;
// This will set the correct start position
update(0);
} // reset
// ----------------------------------------------------------------------------
/** Sets the next time and transform. The current time and transform becomes
* the previous time and transform.
* \param
*/
void GhostKart::addTransform(float time,
const btTransform &trans,
const ReplayBase::PhysicInfo &pi)
void GhostKart::addReplayEvent(float time,
const btTransform &trans,
const ReplayBase::PhysicInfo &pi,
const ReplayBase::KartReplayEvent &kre)
{
// FIXME: for now avoid that transforms for the same time are set
// twice (to avoid division by zero in update). This should be
@ -62,6 +58,7 @@ void GhostKart::addTransform(float time,
m_all_times.push_back(time);
m_all_transform.push_back(trans);
m_all_physic_info.push_back(pi);
m_all_replay_events.push_back(kre);
// Use first frame of replay to calculate default suspension
if (m_all_physic_info.size() == 1)
@ -74,55 +71,45 @@ void GhostKart::addTransform(float time,
->setDefaultSuspension();
}
} // addTransform
// ----------------------------------------------------------------------------
/** Adds a replay event for this kart.
*/
void GhostKart::addReplayEvent(const ReplayBase::KartReplayEvent &kre)
{
m_replay_events.push_back(kre);
} // addReplayEvent
// ----------------------------------------------------------------------------
/** Updates the ghost data each time step. It uses interpolation to get a new
* position and rotation.
/** Updates the current event of the ghost kart using interpolation
* \param dt Time step size.
*/
void GhostKart::update(float dt)
{
float t = World::getWorld()->getTime();
// Don't do anything at startup
if(t==0) return;
updateTransform(t, dt);
while(m_next_event < m_replay_events.size() &&
m_replay_events[m_next_event].m_time <= t)
{
Log::debug("Ghost_Kart", "Handling event %d", m_next_event);
// Handle the next event now
m_next_event++;
}
}
// ----------------------------------------------------------------------------
/** Updates the current transform of the ghost kart using interpolation
* \param t Current world time.
* \param dt Time step size.
*/
void GhostKart::updateTransform(float t, float dt)
{
// Find (if necessary) the next index to use
while(m_current_transform+1 < m_all_times.size() &&
t>=m_all_times[m_current_transform+1])
if (t != 0.0f)
{
m_current_transform ++;
while (m_current_transform + 1 < m_all_times.size() &&
t >= m_all_times[m_current_transform+1])
{
m_current_transform++;
}
}
if(m_current_transform+1>=m_all_times.size())
if (m_current_transform + 1 >= m_all_times.size())
{
m_node->setVisible(false);
return;
}
float nitro_frac = 0;
if (m_all_replay_events[m_current_transform].m_on_nitro)
{
nitro_frac = fabsf(m_all_physic_info[m_current_transform].m_speed) /
(m_kart_properties->getEngineMaxSpeed());
if (nitro_frac > 1.0f)
nitro_frac = 1.0f;
}
getKartGFX()->updateNitroGraphics(nitro_frac);
if (m_all_replay_events[m_current_transform].m_on_zipper)
showZipperFire();
float f =(t - m_all_times[m_current_transform])
/ ( m_all_times[m_current_transform+1]
- m_all_times[m_current_transform] );
@ -143,4 +130,6 @@ void GhostKart::updateTransform(float t, float dt)
m_all_physic_info[m_current_transform].m_steer,
m_all_physic_info[m_current_transform].m_speed,
m_current_transform);
getKartGFX()->update(dt);
} // update

17
src/karts/ghost_kart.hpp
View File

@ -44,23 +44,15 @@ private:
std::vector<ReplayBase::PhysicInfo> m_all_physic_info;
std::vector<ReplayBase::KartReplayEvent> m_replay_events;
std::vector<ReplayBase::KartReplayEvent> m_all_replay_events;
/** Pointer to the last index in m_all_times that is smaller than
* the current world time. */
unsigned int m_current_transform;
/** Index of the next kart replay event. */
unsigned int m_next_event;
void updateTransform(float t, float dt);
public:
GhostKart(const std::string& ident);
virtual void update (float dt);
virtual void addTransform(float time,
const btTransform &trans,
const ReplayBase::PhysicInfo &pi);
virtual void addReplayEvent(const ReplayBase::KartReplayEvent &kre);
virtual void reset();
// ------------------------------------------------------------------------
/** No physics body for ghost kart, so nothing to adjust. */
@ -72,8 +64,13 @@ public:
// Not needed to create any physics for a ghost kart.
virtual void createPhysics() {}
// ------------------------------------------------------------------------
const float getSuspensionLength(int index, int wheel) const
const float getSuspensionLength(int index, int wheel) const
{ return m_all_physic_info[index].m_suspension_length[wheel]; }
// ------------------------------------------------------------------------
void addReplayEvent(float time,
const btTransform &trans,
const ReplayBase::PhysicInfo &pi,
const ReplayBase::KartReplayEvent &kre);
// ------------------------------------------------------------------------
}; // GhostKart
#endif

2
src/karts/kart.hpp
View File

@ -431,7 +431,7 @@ public:
virtual void showStarEffect(float t);
// ------------------------------------------------------------------------
/** Returns the terrain info oject. */
TerrainInfo *getTerrainInfo() { return m_terrain_info; }
virtual const TerrainInfo *getTerrainInfo() const { return m_terrain_info; }
// ------------------------------------------------------------------------
virtual void setOnScreenText(const wchar_t *text);
// ------------------------------------------------------------------------

7
src/karts/kart_model.cpp
View File

@ -817,11 +817,14 @@ void KartModel::update(float dt, float distance, float steer, float speed,
float suspension_length = 0.0f;
GhostKart* gk = dynamic_cast<GhostKart*>(m_kart);
if (gk && gt_replay_index != -1)
// Prevent using m_default_physics_suspension uninitialized
if (gk && gt_replay_index == -1) break;
if (gk)
{
suspension_length = gk->getSuspensionLength(gt_replay_index, i);
}
else if (!gk)
else
{
suspension_length = m_kart->getVehicle()->getWheelInfo(i).
m_raycastInfo.m_suspensionLength;

11
src/replay/replay_base.hpp
View File

@ -59,17 +59,12 @@ protected:
}; // PhysicInfo
// ------------------------------------------------------------------------
/** Records all other events - atm start and end skidding. */
/** Records all other events - atm nitro and zipper handling. */
struct KartReplayEvent
{
/** The type of event. */
enum KartReplayEventType {KRE_NONE,
KRE_SKID_LEFT,
KRE_SKID_MIN = KRE_SKID_LEFT,
KRE_SKID_RIGHT, KRE_SKID_RELEASE} m_type;
/** Time at which this event happens. */
float m_time;
bool m_on_nitro;
bool m_on_zipper;
}; // KartReplayEvent
// ------------------------------------------------------------------------

41
src/replay/replay_play.cpp
View File

@ -173,27 +173,32 @@ void ReplayPlay::readKartData(FILE *fd, char *next_line)
{
fgets(s, 1023, fd);
float x, y, z, rx, ry, rz, rw, time, speed, steer, w1, w2, w3, w4;
int nitro, zipper;
// Check for EV_TRANSFORM event:
// -----------------------------
if(sscanf(s, "%f %f %f %f %f %f %f %f %f %f %f %f %f %f\n",
if(sscanf(s, "%f %f %f %f %f %f %f %f %f %f %f %f %f %f %d %d\n",
&time,
&x, &y, &z,
&rx, &ry, &rz, &rw,
&speed, &steer, &w1, &w2, &w3, &w4
)==14)
&speed, &steer, &w1, &w2, &w3, &w4,
&nitro, &zipper
)==16)
{
btQuaternion q(rx, ry, rz, rw);
btVector3 xyz(x, y, z);
PhysicInfo pi = {0};
KartReplayEvent kre = {0};
pi.m_speed = speed;
pi.m_steer = steer;
pi.m_suspension_length[0] = w1;
pi.m_suspension_length[1] = w2;
pi.m_suspension_length[2] = w3;
pi.m_suspension_length[3] = w4;
m_ghost_karts[m_ghost_karts.size()-1].addTransform(time,
btTransform(q, xyz), pi);
kre.m_on_nitro = (bool)nitro;
kre.m_on_zipper = (bool)zipper;
m_ghost_karts[m_ghost_karts.size()-1].addReplayEvent(time,
btTransform(q, xyz), pi, kre);
}
else
{
@ -204,31 +209,5 @@ void ReplayPlay::readKartData(FILE *fd, char *next_line)
Log::warn("Replay", "Ignored.");
}
} // for i
fgets(s, 1023, fd);
unsigned int num_events;
if(sscanf(s,"events: %u",&num_events)!=1)
Log::warn("Replay", "Number of events not found in replay file "
"for kart %d.", m_ghost_karts.size()-1);
for(unsigned int i=0; i<num_events; i++)
{
fgets(s, 1023, fd);
KartReplayEvent kre;
int type;
if(sscanf(s, "%f %d\n", &kre.m_time, &type)==2)
{
kre.m_type = (KartReplayEvent::KartReplayEventType)type;
m_ghost_karts[m_ghost_karts.size()-1].addReplayEvent(kre);
}
else
{
// Invalid record found
// ---------------------
Log::warn("Replay", "Can't read replay event line %d:", i);
Log::warn("Replay", "%s", s);
Log::warn("Replay", "Ignored.");
}
} // for i < events
} // readKartData

82
src/replay/replay_recorder.cpp
View File

@ -24,6 +24,7 @@
#include "modes/world.hpp"
#include "physics/btKart.hpp"
#include "race/race_manager.hpp"
#include "tracks/terrain_info.hpp"
#include "tracks/track.hpp"
#include <algorithm>
@ -45,6 +46,7 @@ ReplayRecorder::~ReplayRecorder()
{
m_transform_events.clear();
m_physic_info.clear();
m_kart_replay_event.clear();
} // ~Replay
//-----------------------------------------------------------------------------
@ -55,9 +57,9 @@ void ReplayRecorder::init()
{
m_transform_events.clear();
m_physic_info.clear();
m_kart_replay_event.clear();
m_transform_events.resize(race_manager->getNumberOfKarts());
m_physic_info.resize(race_manager->getNumberOfKarts());
m_skid_control.resize(race_manager->getNumberOfKarts());
m_kart_replay_event.resize(race_manager->getNumberOfKarts());
unsigned int max_frames = (unsigned int)( stk_config->m_replay_max_time
/ stk_config->m_replay_dt);
@ -65,8 +67,7 @@ void ReplayRecorder::init()
{
m_transform_events[i].resize(max_frames);
m_physic_info[i].resize(max_frames);
// Rather arbitraritly sized, it will be added with push_back
m_kart_replay_event[i].reserve(500);
m_kart_replay_event[i].resize(max_frames);
}
m_count_transforms.clear();
m_count_transforms.resize(race_manager->getNumberOfKarts(), 0);
@ -103,40 +104,22 @@ void ReplayRecorder::update(float dt)
for(unsigned int i=0; i<num_karts; i++)
{
const AbstractKart *kart = world->getKart(i);
// Check if skidding state has changed. If so, store this
if(kart->getControls().m_skid != m_skid_control[i])
{
KartReplayEvent kre;
kre.m_time = World::getWorld()->getTime();
if(kart->getControls().m_skid==KartControl::SC_LEFT)
kre.m_type = KartReplayEvent::KRE_SKID_LEFT;
else if(kart->getControls().m_skid==KartControl::SC_RIGHT)
kre.m_type = KartReplayEvent::KRE_SKID_RIGHT;
else
kre.m_type = KartReplayEvent::KRE_NONE;
m_kart_replay_event[i].push_back(kre);
if(m_skid_control[i]!=KartControl::SC_NONE)
m_skid_control[i] = KartControl::SC_NONE;
else
m_skid_control[i] = kart->getControls().m_skid;
}
#ifdef DEBUG
m_count ++;
m_count++;
#endif
if(time - m_last_saved_time[i]<stk_config->m_replay_dt)
if (time - m_last_saved_time[i] < stk_config->m_replay_dt)
{
#ifdef DEBUG
m_count_skipped_time ++;
m_count_skipped_time++;
#endif
continue;
}
m_last_saved_time[i] = time;
m_count_transforms[i]++;
if(m_count_transforms[i]>=m_transform_events[i].size())
if (m_count_transforms[i] >= m_transform_events[i].size())
{
// Only print this message once.
if(m_count_transforms[i]==m_transform_events[i].size())
if (m_count_transforms[i] == m_transform_events[i].size())
{
char buffer[100];
sprintf(buffer, "Can't store more events for kart %s.",
@ -147,6 +130,8 @@ void ReplayRecorder::update(float dt)
}
TransformEvent *p = &(m_transform_events[i][m_count_transforms[i]-1]);
PhysicInfo *q = &(m_physic_info[i][m_count_transforms[i]-1]);
KartReplayEvent *r = &(m_kart_replay_event[i][m_count_transforms[i]-1]);
p->m_time = World::getWorld()->getTime();
p->m_transform.setOrigin(kart->getXYZ());
p->m_transform.setRotation(kart->getVisualRotation());
@ -164,6 +149,28 @@ void ReplayRecorder::update(float dt)
->getWheelInfo(j).m_raycastInfo.m_suspensionLength;
}
}
bool nitro = false;
bool zipper = false;
const KartControl kc = kart->getControls();
const Material* m = kart->getTerrainInfo()->getMaterial();
if (kc.m_nitro && kart->isOnGround() &&
kart->isOnMinNitroTime() > 0.0f && kart->getEnergy() > 0.0f)
{
nitro = true;
}
if (m)
{
if (m->isZipper() && kart->isOnGround())
zipper = true;
}
if (kc.m_fire &&
kart->getPowerup()->getType() == PowerupManager::POWERUP_ZIPPER)
{
zipper = true;
}
r->m_on_nitro = nitro;
r->m_on_zipper = zipper;
} // for i
} // update
@ -177,7 +184,7 @@ void ReplayRecorder::Save()
m_count, m_count_skipped_time);
#endif
FILE *fd = openReplayFile(/*writeable*/true);
if(!fd)
if (!fd)
{
Log::error("ReplayRecorder", "Can't open '%s' for writing - can't save replay data.",
getReplayFilename().c_str());
@ -195,18 +202,19 @@ void ReplayRecorder::Save()
unsigned int max_frames = (unsigned int)( stk_config->m_replay_max_time
/ stk_config->m_replay_dt );
for(unsigned int k=0; k<num_karts; k++)
for (unsigned int k = 0; k < num_karts; k++)
{
fprintf(fd, "model: %s\n", world->getKart(k)->getIdent().c_str());
fprintf(fd, "size: %d\n", m_count_transforms[k]);
unsigned int num_transforms = std::min(max_frames,
m_count_transforms[k]);
for(unsigned int i=0; i<num_transforms; i++)
for (unsigned int i = 0; i < num_transforms; i++)
{
const TransformEvent *p = &(m_transform_events[k][i]);
const PhysicInfo *q = &(m_physic_info[k][i]);
fprintf(fd, "%f %f %f %f %f %f %f %f %f %f %f %f %f %f\n",
const TransformEvent *p = &(m_transform_events[k][i]);
const PhysicInfo *q = &(m_physic_info[k][i]);
const KartReplayEvent *r = &(m_kart_replay_event[k][i]);
fprintf(fd, "%f %f %f %f %f %f %f %f %f %f %f %f %f %f %d %d\n",
p->m_time,
p->m_transform.getOrigin().getX(),
p->m_transform.getOrigin().getY(),
@ -220,15 +228,11 @@ void ReplayRecorder::Save()
q->m_suspension_length[0],
q->m_suspension_length[1],
q->m_suspension_length[2],
q->m_suspension_length[3]
q->m_suspension_length[3],
(int)r->m_on_nitro,
(int)r->m_on_zipper
);
} // for i
fprintf(fd, "events: %d\n", (int)m_kart_replay_event[k].size());
for(unsigned int i=0; i<m_kart_replay_event[k].size(); i++)
{
const KartReplayEvent *p=&(m_kart_replay_event[k][i]);
fprintf(fd, "%f %d\n", p->m_time, p->m_type);
}
}
fclose(fd);
} // Save

10
src/replay/replay_recorder.hpp
View File

@ -34,20 +34,18 @@ private:
/** A separate vector of Replay Events for all transforms. */
std::vector< std::vector<TransformEvent> > m_transform_events;
/** A separate vector of Replay Events for all transforms. */
/** A separate vector of Replay Events for all physic info. */
std::vector< std::vector<PhysicInfo> > m_physic_info;
/** A separate vector of Replay Events for all other events. */
std::vector< std::vector<KartReplayEvent> > m_kart_replay_event;
/** Time at which a transform was saved for the last time. */
std::vector<float> m_last_saved_time;
/** Counts the number of transform events for each kart. */
std::vector<unsigned int> m_count_transforms;
/** Stores the last skid state. */
std::vector<KartControl::SkidControl> m_skid_control;
std::vector< std::vector<KartReplayEvent> > m_kart_replay_event;
/** Static pointer to the one instance of the replay object. */
static ReplayRecorder *m_replay_recorder;