//------------------------------------------------------------------------
void CVehicleMovementHelicopter::Serialize(TSerialize ser, EEntityAspects aspects)
{
CVehicleMovementBase::Serialize(ser, aspects);
if((ser.GetSerializationTarget() == eST_Network) &&(aspects & eEA_GameClientDynamic))
{
m_netActionSync.Serialize(ser, aspects);
}
else if(ser.GetSerializationTarget() != eST_Network)
{
ser.Value("enginePower", m_enginePower);
ser.Value("timeOnTheGround", m_timeOnTheGround);
ser.Value("lastDir", m_lastDir);
ser.Value("desiredHeight", m_desiredHeight);
ser.Value("vehicleVolume",m_vehicleVolume);
ser.Value("turbulence", m_turbulence);
ser.Value("steeringDamage",m_steeringDamage);
ser.Value("noHoveringTimer",m_noHoveringTimer);
ser.Value("relaxTimer",m_relaxTimer);
ser.Value("desiredRoll",m_desiredRoll);
ser.Value("desiredPitch",m_desiredPitch);
if(ser.IsReading())
m_isTouchingGround = m_timeOnTheGround > 0.0f;
}
};
//------------------------------------------------------------------------
void CProjectile::FullSerialize(TSerialize ser)
{
assert(ser.GetSerializationTarget() != eST_Network);
ser.Value("Remote", m_remote);
// m_tracerpath should be serialized but the template-template stuff doesn't work under VS2005
ser.Value("Owner", m_ownerId, 'eid');
ser.Value("Weapon", m_weaponId, 'eid');
ser.Value("TrailEffect", m_trailEffectId);
ser.Value("TrailSound", m_trailSoundId);
ser.Value("WhizSound", m_whizSoundId);
ser.Value("Damage", m_damage);
ser.Value("Destroying", m_destroying);
ser.Value("LastPos", m_last);
ser.Value("InitialPos", m_initial_pos);
ser.Value("ScaledEffectSignaled", m_scaledEffectSignaled);
ser.Value("HitListener", m_hitListener);
ser.Value("HitPoints", m_hitPoints);
bool wasVisible = false;
if(ser.IsWriting())
wasVisible = (GetEntity()->GetSlotFlags(0)&(ENTITY_SLOT_RENDER))?true:false;
ser.Value("Visibility", wasVisible);
if(ser.IsReading())
{
if(wasVisible)
GetEntity()->SetSlotFlags(0, GetEntity()->GetSlotFlags(0)|ENTITY_SLOT_RENDER);
else
GetEntity()->SetSlotFlags(0, GetEntity()->GetSlotFlags(0)&(~ENTITY_SLOT_RENDER));
InitWithAI();
}
}
//------------------------------------------------------------------------
void CVehicleDamageBehaviorExplosion::Serialize(TSerialize ser, EEntityAspects aspects)
{
if (ser.GetSerializationTarget() != eST_Network)
{
ser.Value("exploded", m_exploded);
}
}
void CVehicleMovementMPVTOL::Serialize(TSerialize ser, EEntityAspects aspects)
{
CVTOLVehicleManager* pVTOLManager = g_pGame->GetGameRules()->GetVTOLVehicleManager();
if(pVTOLManager && ser.GetSerializationTarget()==eST_Network)
{
// Don't call CVehicleMovementHelicopter::Serialize();
CVehicleMovementBase::Serialize(ser, aspects);
if( (aspects&k_vtolPathUpdate)!=0 )
{
SVTOLPathPosParams data(m_pathing.pathingData);
// Serialize.
data.Serialize(ser);
// Apply results.
if(ser.IsReading() && !gEnv->bServer)
{
ReceivedServerPathingData(data);
}
}
}
else
{
BaseClass::Serialize(ser, aspects);
}
}
void SGrabStats::Serialize(TSerialize ser)
{
assert(ser.GetSerializationTarget() != eST_Network);
if(ser.BeginOptionalGroup("SGrabStats", true))
{
//when reading, reset the structure first.
if(ser.IsReading())
Reset();
ser.Value("grabId", grabId);
ser.Value("dropId", dropId);
ser.Value("lHoldPos", lHoldPos);
ser.Value("throwVector", throwVector);
ser.Value("additionalRotation", additionalRotation);
ser.Value("limbNum", limbNum);
for(int i=0; i < limbNum; ++i)
{
char limbName[64];
_snprintf(limbName, 64, "limbId%d", i);
ser.Value(limbName, limbId[i]);
}
ser.Value("resetFlagsDelay", resetFlagsDelay);
ser.Value("grabDelay", grabDelay);
ser.Value("throwDelay", throwDelay);
ser.Value("maxDelay", maxDelay);
ser.Value("followSpeed", followSpeed);
ser.Value("useIKRotation", useIKRotation);
ser.Value("collisionFlags", collisionFlags);
ser.Value("usingAnimation", usingAnimation);
ser.Value("usingAnimationForGrab", usingAnimationForGrab);
ser.Value("usingAnimationForDrop", usingAnimationForDrop);
ser.ValueChar("carryAnimGraphInput", (char *)carryAnimGraphInput, s_maxAGInputNameLen);
ser.ValueChar("grabAnimGraphSignal", (char *)grabAnimGraphSignal, s_maxAGInputNameLen);
ser.ValueChar("dropAnimGraphSignal", (char *)dropAnimGraphSignal, s_maxAGInputNameLen);
ser.Value("IKActive", IKActive);
ser.Value("releaseIKTime", releaseIKTime);
ser.Value("followBoneID", followBoneID);
ser.Value("followBoneWPos", followBoneWPos);
ser.Value("grabbedObjOfs", grabbedObjOfs);
ser.Value("readIkInaccuracyCorrection", readIkInaccuracyCorrection);
ser.Value("ikInaccuracyCorrection", ikInaccuracyCorrection);
ser.Value("origRotation", origRotation);
ser.Value("origEndBoneWorldRotTrans", origEndBoneWorldRot.t);
ser.Value("origEndBoneWorldRotQuat", origEndBoneWorldRot.q);
ser.Value("origRotationsValid", origRotationsValid);
ser.Value("entityGrabSpot", entityGrabSpot);
ser.Value("boneGrabOffset", boneGrabOffset);
ser.EndGroup();
}
}
//------------------------------------------------------------------------
void CPlant::Serialize(TSerialize ser)
{
if (ser.GetSerializationTarget()!=eST_Network)
{
ser.Value("projectiles", m_projectiles);
}
}
//------------------------------------------------------------------------
void CVehicleDamageBehaviorDetachPart::Serialize(TSerialize ser, EEntityAspects aspects)
{
if (ser.GetSerializationTarget() != eST_Network)
{
EntityId detachedId = m_detachedEntityId;
ser.Value("m_detachedEntityId", detachedId);
if (ser.IsReading() && m_detachedEntityId != detachedId)
{
if (detachedId)
{
m_detachedEntityId = detachedId;
if (IEntity* pDetachedEntity = gEnv->pEntitySystem->GetEntity(m_detachedEntityId))
{
if (CVehiclePartBase* pPart = (CVehiclePartBase*)m_pVehicle->GetPart(m_partName.c_str()))
MovePartToTheNewEntity(pDetachedEntity, pPart);
}
}
else
{
Reset();
}
}
}
}
//------------------------------------------------------------------------
void CNetworkMovementStdBoat::Serialize(TSerialize ser, EEntityAspects aspects)
{
if(ser.GetSerializationTarget()==eST_Network && aspects&CONTROLLED_ASPECT)
{
ser.Value("pedal", m_pedal, 'vPed');
ser.Value("steer", m_steer, 'vStr');
ser.Value("boost", m_boost, 'bool');
}
}
void CVehicleMovementAmphibiousT<Wheeled>::Serialize(TSerialize ser, EEntityAspects aspects)
{
Wheeled::Serialize(ser, aspects);
if (ser.GetSerializationTarget() != eST_Network)
{
m_boat.Serialize(ser, aspects);
}
}
//------------------------------------------------------------------------
void CVehicleViewSteer::Serialize(TSerialize serialize, EEntityAspects aspects)
{
CVehicleViewBase::Serialize(serialize, aspects);
if (serialize.GetSerializationTarget() != eST_Network)
{
serialize.Value("position", m_position);
}
}
//------------------------------------------------------------------------
void CFists::FullSerialize(TSerialize ser)
{
CWeapon::FullSerialize(ser);
if(ser.GetSerializationTarget() != eST_Network)
{
ser.Value("underWater", m_underWater);
ser.Value("inFreeFall", m_inFreeFall);
ser.Value("m_timeOut", m_timeOut);
}
}
//------------------------------------------------------------------------
void CVehicleDamageBehaviorBlowTire::Serialize(TSerialize ser, EEntityAspects aspects)
{
if (ser.GetSerializationTarget() != eST_Network)
{
bool bActive = m_isActive;
ser.Value("isActive", bActive);
ser.Value("component", m_component);
if (ser.IsReading())
Activate(bActive);
}
}
void CBaseGrabHandler::Serialize(TSerialize ser)
{
assert(ser.GetSerializationTarget() != eST_Network);
if (ser.BeginOptionalGroup("CBaseGrabHandler", true))
{
m_grabStats.Serialize(ser);
// NOTE Apr 11, 2007: <pvl> for reading, m_pActor has already been taken
// care of in the constructor.
ser.EndGroup();
}
}
//------------------------------------------------------------------------
void CHelicopterPlayerControls::Serialize(TSerialize ser, EEntityAspects aspects)
{
if(ser.GetSerializationTarget() == eST_Network && aspects & CONTROLLED_ASPECT)
{
TMovementValueVector::iterator valueIte = m_values.begin();
TMovementValueVector::iterator valueEnd = m_values.end();
for(; valueIte != valueEnd; ++valueIte)
{
SMovementValue &value = *valueIte;
ser.Value(value.name.c_str(), *value.pValue, 'vPow');
}
}
}
//------------------------------------------------------------------------
void CVehicleMovementStdBoat::Serialize(TSerialize ser, EEntityAspects aspects)
{
CVehicleMovementBase::Serialize(ser, aspects);
if(ser.GetSerializationTarget() == eST_Network)
{
if(m_bNetSync && aspects & CNetworkMovementStdBoat::CONTROLLED_ASPECT)
m_netActionSync.Serialize(ser, aspects);
}
else
{
ser.Value("m_prevAngle", m_prevAngle);
ser.Value("lifted", m_lifted);
}
};
//------------------------------------------------------------------------
void CVehiclePartTread::Serialize(TSerialize ser, EEntityAspects aspects)
{
float damageRatio = m_damageRatio;
CVehiclePartBase::Serialize(ser, aspects);
if(ser.GetSerializationTarget() != eST_Network)
{
if (ser.IsReading())
{
if (damageRatio != m_damageRatio)
SetDamageRatio(m_damageRatio);
}
}
}
void CTriggerProxy::Serialize( TSerialize ser )
{
if (ser.GetSerializationTarget() != eST_Network)
{
if (ser.BeginOptionalGroup("TriggerProxy",true))
{
ser.Value("BoxMin",m_aabb.min);
ser.Value("BoxMax",m_aabb.max);
ser.EndGroup();
}
if (ser.IsReading())
OnMove();
}
}
//------------------------------------------------------------------------
void CVehiclePartLight::Serialize(TSerialize ser, EEntityAspects aspects)
{
CVehiclePartBase::Serialize(ser, aspects);
if (ser.GetSerializationTarget()!=eST_Network)
{
bool isEnabled = IsEnabled();
ser.Value("lightEnabled", isEnabled, 'bool');
if (ser.IsReading())
{
ToggleLight(isEnabled);
}
}
}
//------------------------------------------------------------------------
void CVehicleDamageBehaviorSink::Serialize(TSerialize serialize, EEntityAspects)
{
if (serialize.GetSerializationTarget() != eST_Network)
{
serialize.Value("sinkTimer", m_sinkingTimer);
bool isNowSinking = m_isSinking;
serialize.Value("isSinking", isNowSinking);
if (serialize.IsReading())
{
ChangeSinkingBehavior(isNowSinking);
}
}
}
//------------------------------------------------------------------------
void CNetworkMovementHelicopter::Serialize(TSerialize ser, EEntityAspects aspects)
{
if(ser.GetSerializationTarget()==eST_Network && aspects&CONTROLLED_ASPECT)
{
ser.Value("power", m_hoveringPower, 'vPow');
ser.Value("fws", m_forwardAction, 'vPow');
ser.Value("strafe", m_actionStrafe, 'vPow');
ser.Value("pitch", m_actionPitch, 'vAng');
ser.Value("yaw", m_actionYaw, 'vAng');
ser.Value("roll", m_actionRoll, 'vAng');
ser.Value("height", m_desiredHeight, 'iii');
ser.Value("dir", m_desiredDir, 'iii');
ser.Value("boost", m_boost, 'bool');
}
}
// ----------------------------------------------------------------------------
void CMannequinAGState::Serialize( TSerialize ser )
{
// TODO: Serialize? What about our back-pointers?
if (ser.GetSerializationTarget() == eST_SaveGame)
{
if (ser.IsReading())
Reset();
//ser.Value("action", m_actionValue);
//ser.Value("signal", m_signalValue);
// TODO: Start actions based on the serialized value? Or just not serialize at all?
}
}
//------------------------------------------------------------------------
void CVehicleMovementHelicopter::Serialize(TSerialize ser, EEntityAspects aspects)
{
CVehicleMovementBase::Serialize(ser, aspects);
if (ser.GetSerializationTarget() == eST_Network)
{
m_netActionSync.Serialize(ser, aspects);
}
else
{
ser.Value("enginePower", m_enginePower);
//ser.Value("turbulence", m_turbulence);
ser.Value("steeringDamage",m_steeringDamage);
}
}
//------------------------------------------------------------------------
void CVehicleDamageBehaviorBlowTire::Serialize(TSerialize ser, EEntityAspects aspects)
{
if (ser.GetSerializationTarget() != eST_Network)
{
if (ser.IsReading())
Activate(false); // reset
bool bActive;
ser.Value("isActive", bActive);
ser.Value("component", m_component);
ser.Value("immobilizedTimer", m_aiImmobilizedTimer);
Activate(bActive);
}
}
//------------------------------------------------------------------------
void CVehicleDamageBehaviorBurn::Serialize(TSerialize ser, EEntityAspects aspects)
{
if(ser.GetSerializationTarget()!=eST_Network)
{
bool active = m_isActive;
ser.Value("Active", active);
ser.Value("time", m_timeCounter);
ser.Value("shooterId", m_shooterId);
if(ser.IsReading())
{
if(active != m_isActive)
Activate(active);
}
}
}
//------------------------------------------------------------------------
void CVehiclePartEntity::Serialize(TSerialize serializer, EEntityAspects aspects)
{
CVehiclePartBase::Serialize(serializer, aspects);
bool saveGame = serializer.GetSerializationTarget() != eST_Network ;
if( saveGame )
{
uint32 flags = 0;
if(serializer.IsWriting())
{
if(m_hidden)
{
flags |= Flags::Hidden;
}
if(m_entityAttached)
{
flags |= Flags::EntityAttached;
}
if (m_destroyed)
{
flags |= Flags::Destroyed;
}
}
serializer.Value("entityId", m_entityId);
serializer.Value("flags", flags);
if(serializer.IsReading())
{
m_hidden = !!(flags & Flags::Hidden);
m_entityAttached = !!(flags & Flags::EntityAttached);
m_destroyed = !!(flags & Flags::Destroyed);
}
}
else
{
serializer.Value("netId",m_entityNetId,'ui16');
}
}
//------------------------------------------------------------------------
void CVehicleMovementVTOL::Serialize(TSerialize ser, EEntityAspects aspects)
{
CVehicleMovementHelicopter::Serialize(ser, aspects);
if ((ser.GetSerializationTarget() == eST_Network) &&(aspects & eEA_GameClientDynamic))
{
ser.Value("wings", m_wingsAnimTime, 'unit');
}
else
{
ser.Value("horizontal", m_horizontal);
ser.Value("wingsTime", m_wingsAnimTime);
ser.Value("forwardAction", m_forwardAction);
ser.Value("isVTOLMovement", m_isVTOLMovement); // for ai
if (ser.IsReading())
SetHorizontalMode(m_horizontal);
}
}
//------------------------------------------------------------------------
void CNetworkMovementHelicopterCrysis2::Serialize(TSerialize ser, EEntityAspects aspects)
{
CRY_ASSERT(ser.GetSerializationTarget() == eST_Network);
NET_PROFILE_SCOPE("Movement", ser.IsReading());
NET_PROFILE_SCOPE("NetMovementHelicopterCrysis2", ser.IsReading());
if (m_netSyncFlags & k_syncLookMoveSpeed)
{
ser.Value("look", m_lookTarget, 'wrl3');
ser.Value("move", m_moveTarget, 'wrl3');
ser.Value("speed", m_desiredSpeed, 'iii');
}
if (m_netSyncFlags & k_syncPos)
{
ser.Value("pos", m_currentPos, 'wrld');
ser.Value("rot", m_currentRot, 'ori1');
}
}
void CPlayerInput::SerializeSaveGame( TSerialize ser )
{
if(ser.GetSerializationTarget() != eST_Network)
{
// Store the frame we serialize, to avoid accumulated input during serialization.
m_lastSerializeFrameID = gEnv->pRenderer->GetFrameID();
bool proning = (m_actions & ACTION_PRONE)?true:false;
ser.Value("ProningAction", proning);
if(ser.IsReading())
{
Reset();
if(proning)
OnAction(g_pGame->Actions().prone, 1, 1.0f);
}
//ser.Value("Actions", m_actions); //don't serialize the actions - this will only lead to repeating movement (no key-release)
}
}
//------------------------------------------------------------------------
void CVehicleSeatActionRotateTurret::Serialize(TSerialize ser, EEntityAspects aspects)
{
// MR: for network, only turret parts are serialized
// for savegame, all parts are serialized (by CVehicle)
if (ser.GetSerializationTarget() == eST_Network)
{
for (int i = 0; i < eVTRT_NumRotationTypes; ++i)
{
if (m_rotations[i].m_pPart)
{
m_rotations[i].m_pPart->Serialize(ser, aspects);
}
}
}
else
{
// save rotation details
CryFixedStringT<16> tag;
for (int i = 0; i < eVTRT_NumRotationTypes; ++i)
{
if (m_rotations[i].m_pPart)
{
Quat q;
Matrix34 currentTM = m_rotations[i].m_pPart->GetLocalBaseTM();
if (ser.IsWriting())
q = Quat(currentTM);
tag = (i == eVTRT_Pitch) ? "rotation_pitch" : "rotation_yaw";
ser.Value(tag.c_str(), q, 'ori1');
if (ser.IsReading())
{
Matrix34 newTM(q);
newTM.SetTranslation(currentTM.GetTranslation());
m_rotations[i].m_pPart->SetLocalBaseTM(newTM);
m_rotations[i].m_orientation.Set(q);
}
}
}
}
}
void CScriptProxy::SerializeProperties( TSerialize ser )
{
if (ser.GetSerializationTarget() == eST_Network)
return;
// Saving.
if (!(m_pEntity->GetFlags() & ENTITY_FLAG_UNREMOVABLE))
{
// Properties never serialized
/*
if (!m_pEntity->GetArchetype())
{
// If not archetype also serialize properties table of the entity.
SerializeTable( ser, "Properties" );
}*/
// Instance table always initialized for dynamic entities.
SerializeTable( ser, "PropertiesInstance" );
}
}
