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

Make a lossless compression for btKart state saving

Browse Source
This commit is contained in:
Benau 2018-11-13 12:56:40 +08:00
parent b4df116661
commit 9de7376b0a
6 changed files with 49 additions and 43 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
src/karts/kart.cpp
View File

@ -2291,7 +2291,7 @@ void Kart::crashed(const Material *m, const Vec3 &normal)
const LinearWorld *lw = dynamic_cast<LinearWorld*>(World::getWorld());
if(m_kart_properties->getTerrainImpulseType()
==KartProperties::IMPULSE_NORMAL &&
m_vehicle->getCentralImpulseTime()<=0 )
m_vehicle->getCentralImpulseTicks()<=0 )
{
// Restrict impule to plane defined by gravity (i.e. X/Z plane).
// This avoids the problem that karts can be pushed up, e.g. above
@ -2312,7 +2312,7 @@ void Kart::crashed(const Material *m, const Vec3 &normal)
m_bounce_back_ticks = 0;
impulse = Vec3(0, 0, 0);
//m_vehicle->setTimedCentralImpulse(0.1f, impulse);
m_vehicle->setTimedCentralImpulse(0.0, impulse);
m_vehicle->setTimedCentralImpulse(0, impulse);
}
// If there is a quad graph, push the kart towards the previous
// graph node center (we have to use the previous point since the
@ -2320,7 +2320,7 @@ void Kart::crashed(const Material *m, const Vec3 &normal)
// would be pushed forward).
else if(m_kart_properties->getTerrainImpulseType()
==KartProperties::IMPULSE_TO_DRIVELINE &&
lw && m_vehicle->getCentralImpulseTime()<=0 &&
lw && m_vehicle->getCentralImpulseTicks()<=0 &&
Track::getCurrentTrack()->isPushBackEnabled())
{
int sector = lw->getSectorForKart(this);
@ -2338,7 +2338,8 @@ void Kart::crashed(const Material *m, const Vec3 &normal)
impulse = Vec3(0, 0, -1); // Arbitrary
impulse *= m_kart_properties->getCollisionTerrainImpulse();
m_bounce_back_ticks = stk_config->time2Ticks(0.2f);
m_vehicle->setTimedCentralImpulse(0.1f, impulse);
m_vehicle->setTimedCentralImpulse(
(uint16_t)stk_config->time2Ticks(0.1f), impulse);
}
}

13
src/karts/kart_rewinder.cpp
View File

@ -154,13 +154,13 @@ BareNetworkString* KartRewinder::saveState(std::vector<std::string>* ru)
buffer->add(body->getLinearVelocity());
buffer->add(body->getAngularVelocity());
buffer->addFloat(m_vehicle->getTimedRotationTime());
buffer->addUInt16(m_vehicle->getTimedRotationTicks());
buffer->add(m_vehicle->getTimedRotation());
buffer->addUInt8(m_vehicle->getCushioningDisableTime());
// For collision rewind
buffer->addUInt16(m_bounce_back_ticks);
buffer->addFloat(m_vehicle->getCentralImpulseTime());
buffer->addUInt16(m_vehicle->getCentralImpulseTicks());
buffer->add(m_vehicle->getAdditionalImpulse());
// 3) Steering and other player controls
@ -262,16 +262,17 @@ void KartRewinder::restoreState(BareNetworkString *buffer, int count)
setTrans(m_transfrom_from_network);
}
float time_rot = buffer->getFloat();
uint16_t time_rot = buffer->getUInt16();
// Set timed rotation divides by time_rot
m_vehicle->setTimedRotation(time_rot, time_rot*buffer->getVec3());
m_vehicle->setTimedRotation(time_rot,
stk_config->ticks2Time(time_rot) * buffer->getVec3());
m_vehicle->setCushioningDisableTime(buffer->getUInt8());
// Collision rewind
m_bounce_back_ticks = buffer->getUInt16();
float central_impulse_time = buffer->getFloat();
uint16_t central_impulse_ticks = buffer->getUInt16();
Vec3 additional_impulse = buffer->getVec3();
m_vehicle->setTimedCentralImpulse(central_impulse_time,
m_vehicle->setTimedCentralImpulse(central_impulse_ticks,
additional_impulse, true/*rewind*/);
// For the raycast to determine the current material under the kart

3
src/karts/skidding.cpp
View File

@ -536,7 +536,8 @@ void Skidding::update(int ticks, bool is_on_ground,
t = std::min(t, kp->getSkidRevertVisualTime());
btVector3 rot(0, m_visual_rotation * kp->getSkidPostSkidRotateFactor(), 0);
m_kart->getVehicle()->setTimedRotation(t, rot);
m_kart->getVehicle()->setTimedRotation(
(uint16_t)stk_config->time2Ticks(t), rot);
// skid_time is used to count backwards for the GFX
m_skid_time = stk_config->time2Ticks(t);
if(bonus_time>0)

26
src/physics/btKart.cpp
View File

@ -124,9 +124,9 @@ void btKart::reset()
m_allow_sliding = false;
m_num_wheels_on_ground = 0;
m_additional_impulse = btVector3(0,0,0);
m_time_additional_impulse = 0;
m_ticks_additional_impulse = 0;
m_additional_rotation = btVector3(0,0,0);
m_time_additional_rotation = 0;
m_ticks_additional_rotation = 0;
m_max_speed = -1.0f;
m_min_speed = 0.0f;
m_cushioning_disable_time = 0;
@ -598,23 +598,21 @@ void btKart::updateVehicle( btScalar step )
// Apply additional impulse set by supertuxkart
// --------------------------------------------
if(m_time_additional_impulse>0)
if(m_ticks_additional_impulse>0)
{
float dt = step > m_time_additional_impulse
? m_time_additional_impulse
: step;
// We have fixed timestep
float dt = stk_config->ticks2Time(1);
m_chassisBody->applyCentralImpulse(m_additional_impulse*dt);
m_time_additional_impulse -= dt;
m_ticks_additional_impulse--;
}
// Apply additional rotation set by supertuxkart
// ---------------------------------------------
if(m_time_additional_rotation>0)
if(m_ticks_additional_rotation>0)
{
btTransform &t = m_chassisBody->getWorldTransform();
float dt = step > m_time_additional_rotation
? m_time_additional_rotation
: step;
// We have fixed timestep
float dt = stk_config->ticks2Time(1);
btQuaternion add_rot(m_additional_rotation.getY()*dt,
m_additional_rotation.getX()*dt,
m_additional_rotation.getZ()*dt);
@ -628,7 +626,7 @@ void btKart::updateVehicle( btScalar step )
// kart, or a strongly 'visual jolt' of the kart
btTransform &iwt=m_chassisBody->getInterpolationWorldTransform();
iwt.setRotation(iwt.getRotation()*add_rot);
m_time_additional_rotation -= dt;
m_ticks_additional_rotation--;
}
adjustSpeed(m_min_speed, m_max_speed);
} // updateVehicle
@ -883,7 +881,7 @@ void btKart::updateFriction(btScalar timeStep)
m_forwardImpulse[wheel] = rollingFriction;
if(m_time_additional_impulse>0)
if(m_ticks_additional_impulse>0)
{
sliding = true;
m_wheelInfo[wheel].m_skidInfo = 0.0f;
@ -913,7 +911,7 @@ void btKart::updateFriction(btScalar timeStep)
// Note: don't reset zipper speed, or the kart rewinder will
// get incorrect zipper information.
if (sliding && (m_allow_sliding || m_time_additional_impulse>0) )
if (sliding && (m_allow_sliding || m_ticks_additional_impulse>0) )
{
for (int wheel = 0; wheel < getNumWheels(); wheel++)
{

27
src/physics/btKart.hpp
View File

@ -19,6 +19,8 @@ class btDynamicsWorld;
#include "BulletDynamics/Vehicle/btWheelInfo.h"
#include "BulletDynamics/Dynamics/btActionInterface.h"
#include "config/stk_config.hpp"
class btVehicleTuning;
class Kart;
struct btWheelContactPoint;
@ -79,13 +81,13 @@ private:
btVector3 m_additional_impulse;
/** The time the additional impulse should be applied. */
float m_time_additional_impulse;
uint16_t m_ticks_additional_impulse;
/** Additional rotation that is applied over a certain amount of time. */
btVector3 m_additional_rotation;
/** Duration over which the additional rotation is applied. */
float m_time_additional_rotation;
uint16_t m_ticks_additional_rotation;
/** The rigid body that is the chassis of the kart. */
btRigidBody *m_chassisBody;
@ -221,36 +223,37 @@ public:
unsigned int getNumWheelsOnGround() const {return m_num_wheels_on_ground;}
// ------------------------------------------------------------------------
/** Sets an impulse that is applied for a certain amount of time.
* \param t Time for the impulse to be active.
* \param t Ticks for the impulse to be active.
* \param imp The impulse to apply. */
void setTimedCentralImpulse(float t, const btVector3 &imp,
void setTimedCentralImpulse(uint16_t t, const btVector3 &imp,
bool rewind = false)
{
// Only add impulse if no other impulse is active.
if (m_time_additional_impulse > 0 && !rewind) return;
if (m_ticks_additional_impulse > 0 && !rewind) return;
m_additional_impulse = imp;
m_time_additional_impulse = t;
m_ticks_additional_impulse = t;
} // setTimedImpulse
// ------------------------------------------------------------------------
/** Returns the time an additional impulse is activated. */
float getCentralImpulseTime() const { return m_time_additional_impulse; }
uint16_t getCentralImpulseTicks() const
{ return m_ticks_additional_impulse; }
// ------------------------------------------------------------------------
const btVector3& getAdditionalImpulse() const
{ return m_additional_impulse; }
// ------------------------------------------------------------------------
/** Sets a rotation that is applied over a certain amount of time (to avoid
* a too rapid changes in the kart).
* \param t Time for the rotation to be applied.
* \param t Ticks for the rotation to be applied.
* \param torque The rotation to apply. */
void setTimedRotation(float t, const btVector3 &rot)
void setTimedRotation(uint16_t t, const btVector3 &rot)
{
if(t>0) m_additional_rotation = rot/t;
m_time_additional_rotation = t;
if(t>0) m_additional_rotation = rot / (stk_config->ticks2Time(t));
m_ticks_additional_rotation = t;
} // setTimedTorque
// ------------------------------------------------------------------------
const btVector3& getTimedRotation() const { return m_additional_rotation; }
// ------------------------------------------------------------------------
float getTimedRotationTime() const { return m_time_additional_rotation; }
uint16_t getTimedRotationTicks() const { return m_ticks_additional_rotation; }
// ------------------------------------------------------------------------
/** Returns the time cushioning is disabled. Used for networking state
* saving. */

14
src/physics/physics.cpp
View File

@ -496,27 +496,29 @@ void Physics::KartKartCollision(AbstractKart *kart_a,
// First push one kart to the left (if there is not already
// an impulse happening - one collision might cause more
// than one impulse otherwise)
if(right_kart->getVehicle()->getCentralImpulseTime()<=0)
if(right_kart->getVehicle()->getCentralImpulseTicks()<=0)
{
const KartProperties *kp = left_kart->getKartProperties();
Vec3 impulse(kp->getCollisionImpulse()*f_right, 0, 0);
impulse = right_kart->getTrans().getBasis() * impulse;
right_kart->getVehicle()
->setTimedCentralImpulse(kp->getCollisionImpulseTime(),
impulse);
->setTimedCentralImpulse(
(uint16_t)stk_config->time2Ticks(kp->getCollisionImpulseTime()),
impulse);
right_kart ->getBody()->setAngularVelocity(btVector3(0,0,0));
}
// Then push the other kart to the right (if there is no
// impulse happening atm).
if(left_kart->getVehicle()->getCentralImpulseTime()<=0)
if(left_kart->getVehicle()->getCentralImpulseTicks()<=0)
{
const KartProperties *kp = right_kart->getKartProperties();
Vec3 impulse = Vec3(-kp->getCollisionImpulse()*f_left, 0, 0);
impulse = left_kart->getTrans().getBasis() * impulse;
left_kart->getVehicle()
->setTimedCentralImpulse(kp->getCollisionImpulseTime(),
impulse);
->setTimedCentralImpulse(
(uint16_t)stk_config->time2Ticks(kp->getCollisionImpulseTime()),
impulse);
left_kart->getBody()->setAngularVelocity(btVector3(0,0,0));
}