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

Save skidding info in replay

Browse Source
This commit is contained in:
Benau
2016-03-25 15:37:53 +08:00
parent 11b119066c
commit 151cc72e22
8 changed files with 131 additions and 51 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/karts/abstract_kart.hpp
View File

@@ -40,6 +40,7 @@ class btKart;
class btQuaternion;
class Controller;
class Item;
class KartGFX;
class KartModel;
class KartProperties;
class Material;
@@ -376,6 +377,9 @@ public:
/** Returns the current powerup. */
virtual Powerup *getPowerup() = 0;
// ------------------------------------------------------------------------
/** Returns a points to this kart's graphical effects. */
virtual KartGFX* getKartGFX() = 0;
// ------------------------------------------------------------------------
virtual void setPowerup (PowerupManager::PowerupType t, int n) = 0;
// ------------------------------------------------------------------------
/** Returns the bullet vehicle which represents this kart. */

18
src/karts/ghost_kart.cpp
View File

@@ -79,6 +79,7 @@ void GhostKart::update(float dt)
if (gc->isReplayEnd())
{
m_node->setVisible(false);
getKartGFX()->setGFXInvisible();
return;
}
@@ -99,20 +100,6 @@ void GhostKart::update(float dt)
const float rd = gc->getReplayDelta();
assert(idx < m_all_transform.size());
float nitro_frac = 0;
if (m_all_replay_events[idx].m_on_nitro)
{
nitro_frac = fabsf(m_all_physic_info[idx].m_speed) /
(m_kart_properties->getEngineMaxSpeed());
if (nitro_frac > 1.0f)
nitro_frac = 1.0f;
}
getKartGFX()->updateNitroGraphics(nitro_frac);
if (m_all_replay_events[idx].m_on_zipper)
showZipperFire();
setXYZ((1- rd)*m_all_transform[idx ].getOrigin()
+ rd *m_all_transform[idx + 1].getOrigin() );
@@ -127,6 +114,9 @@ void GhostKart::update(float dt)
Moveable::updateGraphics(dt, center_shift, btQuaternion(0, 0, 0, 1));
getKartModel()->update(dt, dt*(m_all_physic_info[idx].m_speed),
m_all_physic_info[idx].m_steer, m_all_physic_info[idx].m_speed, idx);
getKartGFX()->setGFXFromReplay(m_all_replay_events[idx].m_nitro_zipper_usage,
m_all_replay_events[idx].m_skidding_state);
getKartGFX()->update(dt);
Vec3 front(0, 0, getKartLength()*0.5f);

2
src/karts/kart.hpp
View File

@@ -297,7 +297,7 @@ public:
virtual int getNumPowerup() const;
// ------------------------------------------------------------------------
/** Returns a points to this kart's graphical effects. */
KartGFX* getKartGFX() { return m_kart_gfx; }
virtual KartGFX* getKartGFX() { return m_kart_gfx; }
// ------------------------------------------------------------------------
/** Returns the remaining collected energy. */
virtual float getEnergy () const { return m_collected_energy; }

101
src/karts/kart_gfx.cpp
View File

@@ -391,3 +391,104 @@ void KartGFX::updateSkidLight(unsigned int level)
m_skidding_light_1->setVisible(level == 1);
m_skidding_light_2->setVisible(level > 1);
} // updateSkidLight
// ----------------------------------------------------------------------------
void KartGFX::getGFXStatus(uint32_t* nitro_zipper, uint32_t* skidding) const
{
uint32_t n_z, s;
n_z = 0;
s = 0;
if (m_all_emitters[KGFX_ZIPPER])
{
n_z |= m_all_emitters[KGFX_ZIPPER]->getCreationRate() > 0;
n_z <<= 16;
}
if (m_all_emitters[KGFX_NITRO1])
{
n_z += (uint16_t)(m_all_emitters[KGFX_NITRO1]->getCreationRate());
}
if (m_all_emitters[KGFX_SKIDL])
{
s |= m_skidding_light_2->isVisible();
s <<= 16;
s += (uint16_t)(m_all_emitters[KGFX_SKIDL]->getCreationRate());
}
*nitro_zipper = n_z;
*skidding = s;
} // getGFXStatus
// ----------------------------------------------------------------------------
void KartGFX::setGFXFromReplay(uint32_t nitro_zipper, uint32_t skidding)
{
const int nitro_rate = (int)(nitro_zipper & 0xffff);
const bool zipper_fire = ((nitro_zipper >> 16) & 0xffff) != 0;
const int skidding_rate = (int)(skidding & 0xffff);
const bool red_fire_skidding = ((skidding >> 16) & 0xffff) != 0;
if (zipper_fire)
setCreationRateAbsolute(KartGFX::KGFX_ZIPPER, 800.0f);
if (nitro_rate > 0)
{
setCreationRateAbsolute(KartGFX::KGFX_NITRO1, (float)nitro_rate);
setCreationRateAbsolute(KartGFX::KGFX_NITRO2, (float)nitro_rate);
setCreationRateAbsolute(KartGFX::KGFX_NITROSMOKE1, (float)nitro_rate);
setCreationRateAbsolute(KartGFX::KGFX_NITROSMOKE2, (float)nitro_rate);
m_nitro_light->setVisible(true);
}
else if (m_nitro_light->isVisible() && nitro_rate == 0)
{
setCreationRateAbsolute(KartGFX::KGFX_NITRO1, 0.0f);
setCreationRateAbsolute(KartGFX::KGFX_NITRO2, 0.0f);
setCreationRateAbsolute(KartGFX::KGFX_NITROSMOKE1, 0.0f);
setCreationRateAbsolute(KartGFX::KGFX_NITROSMOKE2, 0.0f);
m_nitro_light->setVisible(false);
}
if (skidding_rate > 0)
{
if (!m_skidding_light_1->isVisible() && !red_fire_skidding)
{
if (m_all_emitters[KGFX_SKID1L])
m_all_emitters[KGFX_SKID1L]->setParticleType(m_skid_kind1);
if (m_all_emitters[KGFX_SKID1R])
m_all_emitters[KGFX_SKID1R]->setParticleType(m_skid_kind1);
m_skidding_light_1->setVisible(true);
m_skidding_light_2->setVisible(false);
}
if (!m_skidding_light_2->isVisible() && red_fire_skidding)
{
if (m_all_emitters[KGFX_SKID1L])
m_all_emitters[KGFX_SKID1L]->setParticleType(m_skid_kind2);
if (m_all_emitters[KGFX_SKID1R])
m_all_emitters[KGFX_SKID1R]->setParticleType(m_skid_kind2);
m_skidding_light_1->setVisible(false);
m_skidding_light_2->setVisible(true);
}
setCreationRateAbsolute(KartGFX::KGFX_SKIDL, (float)skidding_rate);
setCreationRateAbsolute(KartGFX::KGFX_SKIDR, (float)skidding_rate);
}
else if ((m_skidding_light_1->isVisible() ||
m_skidding_light_2->isVisible()) && skidding_rate == 0)
{
setCreationRateAbsolute(KartGFX::KGFX_SKIDL, 0.0f);
setCreationRateAbsolute(KartGFX::KGFX_SKIDR, 0.0f);
m_skidding_light_1->setVisible(false);
m_skidding_light_2->setVisible(false);
}
} // setGFXFromReplay
// ----------------------------------------------------------------------------
void KartGFX::setGFXInvisible()
{
m_nitro_light->setVisible(false);
m_skidding_light_1->setVisible(false);
m_skidding_light_2->setVisible(false);
} // setGFXInvisible

3
src/karts/kart_gfx.hpp
View File

@@ -101,6 +101,9 @@ public:
void update(float dt);
void updateNitroGraphics(float f);
void updateSkidLight(unsigned int level);
void getGFXStatus(uint32_t* nitro_zipper, uint32_t* skidding) const;
void setGFXFromReplay(uint32_t nitro_zipper, uint32_t skidding);
void setGFXInvisible();
}; // KartWGFX
#endif

11
src/replay/replay_base.hpp
View File

@@ -57,13 +57,14 @@ protected:
}; // PhysicInfo
// ------------------------------------------------------------------------
/** Records all other events - atm nitro, zipper and jumping handling. */
/** Records all other events. */
struct KartReplayEvent
{
/** True if the kart recorded is using nitro/zipper or jumping.
* If true, a suitable GFX or animation will be replayed. */
bool m_on_nitro;
bool m_on_zipper;
/** Combined info for nitro and zipper usage for the kart recored. */
uint32_t m_nitro_zipper_usage;
/** Combined info for skidding info for the kart recored. */
uint32_t m_skidding_state;
/** True if the kart recorded is jumping. */
bool m_jumping;
}; // KartReplayEvent

10
src/replay/replay_play.cpp
View File

@@ -248,7 +248,7 @@ 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, jumping;
int nitro_zipper, skidding, jumping;
// Check for EV_TRANSFORM event:
// -----------------------------
@@ -257,7 +257,7 @@ void ReplayPlay::readKartData(FILE *fd, char *next_line)
&x, &y, &z,
&rx, &ry, &rz, &rw,
&speed, &steer, &w1, &w2, &w3, &w4,
&nitro, &zipper, &jumping
&nitro_zipper, &skidding, &jumping
)==17)
{
btQuaternion q(rx, ry, rz, rw);
@@ -270,9 +270,9 @@ void ReplayPlay::readKartData(FILE *fd, char *next_line)
pi.m_suspension_length[1] = w2;
pi.m_suspension_length[2] = w3;
pi.m_suspension_length[3] = w4;
kre.m_on_nitro = nitro!=0;
kre.m_on_zipper = zipper!=0;
kre.m_jumping = jumping!=0;
kre.m_nitro_zipper_usage = (uint32_t)nitro_zipper;
kre.m_skidding_state = (uint32_t)skidding;
kre.m_jumping = jumping != 0;
m_ghost_karts[kart_num].addReplayEvent(time,
btTransform(q, xyz), pi, kre);
}

33
src/replay/replay_recorder.cpp
View File

@@ -22,10 +22,10 @@
#include "io/file_manager.hpp"
#include "guiengine/message_queue.hpp"
#include "karts/ghost_kart.hpp"
#include "karts/kart_gfx.hpp"
#include "modes/world.hpp"
#include "physics/btKart.hpp"
#include "race/race_manager.hpp"
#include "tracks/terrain_info.hpp"
#include "tracks/track.hpp"
#include <algorithm>
@@ -100,14 +100,14 @@ void ReplayRecorder::update(float dt)
{
if (m_incorrect_replay || m_complete_replay) return;
const World *world = World::getWorld();
World *world = World::getWorld();
const bool single_player = race_manager->getNumPlayers() == 1;
unsigned int num_karts = world->getNumKarts();
float time = world->getTime();
for(unsigned int i=0; i<num_karts; i++)
{
const AbstractKart *kart = world->getKart(i);
AbstractKart *kart = world->getKart(i);
// If a single player give up in game menu, stop recording
if (kart->isEliminated() && single_player) return;
@@ -159,27 +159,8 @@ void ReplayRecorder::update(float dt)
}
}
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;
kart->getKartGFX()->getGFXStatus(&(r->m_nitro_zipper_usage),
&(r->m_skidding_state));
r->m_jumping = kart->isJumping();
} // for i
@@ -282,8 +263,8 @@ void ReplayRecorder::save()
q->m_suspension_length[1],
q->m_suspension_length[2],
q->m_suspension_length[3],
(int)r->m_on_nitro,
(int)r->m_on_zipper,
(int)r->m_nitro_zipper_usage,
(int)r->m_skidding_state,
(int)r->m_jumping
);
} // for i