void CInventoryItem::PH_Ch_CrPr ()
{
net_updateData* p = NetSync();
//restore recalculated data and get data for interpolation
if (!object().CrPr_IsActivated()) return;
////////////////////////////////////
CPHSynchronize* pSyncObj = NULL;
pSyncObj = object().PHGetSyncItem (0);
if (!pSyncObj) return;
////////////////////////////////////
pSyncObj->get_State (p->CheckState);
if (!object().H_Parent() && object().getVisible())
{
if (p->CheckState.enabled == false && p->RecalculatedState.enabled == true)
{
///////////////////////////////////////////////////////////////////
pSyncObj->set_State (p->LastState);
pSyncObj->set_State (p->RecalculatedState);//, N_A.State.enabled);
object().PHUnFreeze ();
///////////////////////////////////////////////////////////////////
ph_world->Step ();
///////////////////////////////////////////////////////////////////
PH_Ch_CrPr ();
////////////////////////////////////
};
};
};
void CInventoryItem::PH_A_CrPr ()
{
net_updateData* p = NetSync();
//restore recalculated data and get data for interpolation
if (!object().CrPr_IsActivated()) return;
////////////////////////////////////
CPHSynchronize* pSyncObj = NULL;
pSyncObj = object().PHGetSyncItem (0);
if (!pSyncObj) return;
////////////////////////////////////
pSyncObj->get_State (p->PredictedState);
////////////////////////////////////
pSyncObj->set_State (p->RecalculatedState);
////////////////////////////////////
if (!m_flags.test(FInInterpolate)) return;
////////////////////////////////////
Fmatrix xformX;
pSyncObj->cv2obj_Xfrom(p->PredictedState.quaternion, p->PredictedState.position, xformX);
VERIFY2 (_valid(xformX),*object().cName());
pSyncObj->cv2obj_Xfrom (p->PredictedState.quaternion, p->PredictedState.position, xformX);
p->IEndRot.set (xformX);
p->IEndPos.set (xformX.c);
VERIFY2 (_valid(p->IEndPos),*object().cName());
/////////////////////////////////////////////////////////////////////////
CalculateInterpolationParams ();
///////////////////////////////////////////////////
};
void CInventoryItem::PH_B_CrPr ()
{
net_updateData* p = NetSync();
//just set last update data for now
if (object().CrPr_IsActivated()) return;
if (object().CrPr_GetActivationStep() > ph_world->m_steps_num) return;
object().CrPr_SetActivated(true);
///////////////////////////////////////////////
CPHSynchronize* pSyncObj = NULL;
pSyncObj = object().PHGetSyncItem (0);
if (!pSyncObj) return;
///////////////////////////////////////////////
pSyncObj->get_State (p->LastState);
///////////////////////////////////////////////
net_update_IItem N_I = p->NET_IItem.back();
pSyncObj->set_State (N_I.State);
object().PHUnFreeze ();
///////////////////////////////////////////////
if (Level().InterpolationDisabled())
{
m_flags.set (FInInterpolation, FALSE);
// m_bInInterpolation = false;
};
///////////////////////////////////////////////
};
void CPhysicObject::Interpolate()
{
net_updatePhData* p = NetSync();
CPHSynchronize* pSyncObj = this->PHGetSyncItem(0);
//simple linear interpolation...
if (!this->H_Parent() &&
this->getVisible() &&
this->m_pPhysicsShell &&
!OnServer() &&
p->NET_IItem.size())
{
SPHNetState newState = p->NET_IItem.front().State;
if (p->NET_IItem.size() >= 2)
{
float ret_interpolate = interpolate_states(p->NET_IItem.front(), p->NET_IItem.back(), newState);
//Msg("Interpolation factor is %0.4f", ret_interpolate);
//Msg("Current position is: x = %3.3f, y = %3.3f, z = %3.3f", newState.position.x, newState.position.y, newState.position.z);
if (ret_interpolate >= 1.f)
{
p->NET_IItem.pop_front();
if (m_activated)
{
Msg("Deactivating object [%d] after interpolation finish", ID());
processing_deactivate();
m_activated = false;
}
}
}
pSyncObj->set_State(newState);
}
}
void CInventoryItem::net_Import (NET_Packet& P)
{
P.r_float (m_fCondition) ;
net_update_IItem N ;
N.dwTimeStamp=P.r_u32 ( );
u16 NumItems = 0;
NumItems=P.r_u16 ( );
if (CSE_ALifeInventoryItem::FLAG_NO_POSITION != NumItems)
N.State.position=P.r_vec3 ();
if (!NumItems || (CSE_ALifeInventoryItem::FLAG_NO_POSITION == NumItems)) return;
position_Import (P,N) ;
net_updateData *p = NetSync() ;
if ( !p->NET_IItem.empty() &&
(p->NET_IItem.back().dwTimeStamp>=N.dwTimeStamp))
return;
if (!p->NET_IItem.empty()){
m_flags.set (FInInterpolate, TRUE);
// m_bInterpolate = true;
}
Level().AddObject_To_Objects4CrPr (m_object);
object().CrPr_SetActivated (false);
object().CrPr_SetActivationStep (0);
p->NET_IItem.push_back (N);
while (p->NET_IItem.size() > 2)
{
p->NET_IItem.pop_front ();
};
};
// LP: added whether a savegame is being restored (skip Pfhortran init if that's the case)
bool entering_map(bool restoring_saved)
{
bool success= true;
/* if any active monsters think they have paths, we'll make them reconsider */
initialize_monsters_for_new_level();
/* and since no monsters have paths, we should make sure no paths think they have monsters */
reset_paths();
/* mark our shape collections for loading and load them */
mark_environment_collections(static_world->environment_code, true);
mark_all_monster_collections(true);
mark_player_collections(true);
mark_map_collections(true);
MarkLuaCollections(true);
MarkLuaHUDCollections(true);
#ifdef SDL
load_collections(true, get_screen_mode()->acceleration != _no_acceleration);
#else
load_collections(true, true);
#endif
load_all_monster_sounds();
load_all_game_sounds(static_world->environment_code);
#if !defined(DISABLE_NETWORKING)
/* tell the keyboard controller to start recording keyboard flags */
if (game_is_networked) success= NetSync(); /* make sure everybody is ready */
#endif // !defined(DISABLE_NETWORKING)
/* make sure nobodyÕs holding a weapon illegal in the new environment */
check_player_weapons_for_environment_change();
#if !defined(DISABLE_NETWORKING)
if (dynamic_world->player_count>1 && !restoring_saved) initialize_net_game();
#endif // !defined(DISABLE_NETWORKING)
randomize_scenery_shapes();
// reset_action_queues(); //¦¦
// sync_heartbeat_count();
// set_keyboard_controller_status(true);
L_Call_Init(restoring_saved);
#if !defined(DISABLE_NETWORKING)
NetSetChatCallbacks(InGameChatCallbacks::instance());
#endif // !defined(DISABLE_NETWORKING)
// Zero out fades *AND* any inadvertant fades from script start...
stop_fade();
set_fade_effect(NONE);
if (!success) leaving_map();
return success;
}
void CPhysicObject::net_Import (NET_Packet& P)
{
u8 NumItems = 0;
NumItems = P.r_u8();
if (!NumItems)
return;
CSE_ALifeObjectPhysic::mask_num_items num_items;
num_items.common = NumItems;
NumItems = num_items.num_items;
/*if (num_items.mask & CSE_ALifeObjectPhysic::animated)
{
net_Import_Anim_Params(P);
}*/
net_update_PItem N;
N.dwTimeStamp = Device.dwTimeGlobal;
net_Import_PH_Params(P,N,num_items);
////////////////////////////////////////////
P.r_u8(); // freezed or not..
if (this->cast_game_object()->Local())
{
return;
}
net_updatePhData *p = NetSync();
// if (!p->NET_IItem.empty() && (p->NET_IItem.back().dwTimeStamp>=N.dwTimeStamp))
// return;
//if (!p->NET_IItem.empty())
//m_flags.set (FInInterpolate, TRUE);
Level().AddObject_To_Objects4CrPr (this);
//this->CrPr_SetActivated (false);
//this->CrPr_SetActivationStep (0);
p->NET_IItem.push_back (N);
while (p->NET_IItem.size() > 2)
{
p->NET_IItem.pop_front ();
}
if (!m_activated)
{
#ifdef DEBUG
Msg("Activating object [%d] before interpolation starts", ID());
#endif // #ifdef DEBUG
processing_activate();
m_activated = true;
}
};
void CArtefact::Interpolate()
{
if (OnServer())
return;
net_updateInvData* p = NetSync();
while (p->NET_IItem.size() > 1) //in real no interpolation, just get latest state
{
p->NET_IItem.pop_front();
}
inherited::Interpolate();
if (p->NET_IItem.size())
{
p->NET_IItem.clear(); //same as p->NET_IItem.pop_front();
}
}
void CInventoryItem::PH_I_CrPr () // actions & operations between two phisic prediction steps
{
net_updateData* p = NetSync();
//store recalculated data, then we able to restore it after small future prediction
if (!object().CrPr_IsActivated()) return;
////////////////////////////////////
CPHSynchronize* pSyncObj = NULL;
pSyncObj = object().PHGetSyncItem (0);
if (!pSyncObj) return;
////////////////////////////////////
pSyncObj->get_State (p->RecalculatedState);
///////////////////////////////////////////////
Fmatrix xformX;
pSyncObj->cv2obj_Xfrom(p->RecalculatedState.quaternion, p->RecalculatedState.position, xformX);
VERIFY2 (_valid(xformX),*object().cName());
pSyncObj->cv2obj_Xfrom (p->RecalculatedState.quaternion, p->RecalculatedState.position, xformX);
p->IRecRot.set(xformX);
p->IRecPos.set(xformX.c);
VERIFY2 (_valid(p->IRecPos),*object().cName());
};
void CInventoryItem::make_Interpolation ()
{
net_updateData* p = NetSync();
p->m_dwILastUpdateTime = Level().timeServer();
if(!object().H_Parent() && object().getVisible() && object().m_pPhysicsShell && m_flags.test(FInInterpolation) )
{
u32 CurTime = Level().timeServer();
if (CurTime >= p->m_dwIEndTime)
{
m_flags.set(FInInterpolation, FALSE);
object().m_pPhysicsShell->NetInterpolationModeOFF();
CPHSynchronize* pSyncObj = NULL;
pSyncObj = object().PHGetSyncItem(0);
pSyncObj->set_State (p->PredictedState);
Fmatrix xformI;
pSyncObj->cv2obj_Xfrom (p->PredictedState.quaternion, p->PredictedState.position, xformI);
VERIFY2 (_valid(object().renderable.xform),*object().cName());
object().XFORM().set (xformI);
VERIFY2 (_valid(object().renderable.xform),*object().cName());
}
else
{
VERIFY (CurTime <= p->m_dwIEndTime);
float factor = float(CurTime - p->m_dwIStartTime)/(p->m_dwIEndTime - p->m_dwIStartTime);
if (factor > 1) factor = 1.0f;
else if (factor < 0) factor = 0;
Fvector IPos;
Fquaternion IRot;
float c = factor;
for (u32 k=0; k<3; k++)
{
IPos[k] = c*(c*(c*p->SCoeff[k][0]+p->SCoeff[k][1])+p->SCoeff[k][2])+p->SCoeff[k][3];
};
VERIFY2 (_valid(IPos),*object().cName());
VERIFY (factor>=0.f && factor<=1.f);
IRot.slerp(p->IStartRot, p->IEndRot, factor);
VERIFY2 (_valid(IRot),*object().cName());
object().XFORM().rotation(IRot);
VERIFY2 (_valid(object().renderable.xform),*object().cName());
object().Position().set(IPos);
VERIFY2 (_valid(object().renderable.xform),*object().cName());
};
}
else
{
m_flags.set(FInInterpolation,FALSE);
};
#ifdef DEBUG
Fvector iPos = object().Position();
if (!object().H_Parent() && object().getVisible())
{
if(m_net_updateData)
m_net_updateData->LastVisPos.push_back(iPos);
};
#endif
}
void CInventoryItem::CalculateInterpolationParams()
{
net_updateData* p = NetSync();
p->IStartPos.set(object().Position());
p->IStartRot.set(object().XFORM());
Fvector P0, P1, P2, P3;
CPHSynchronize* pSyncObj = NULL;
pSyncObj = object().PHGetSyncItem(0);
Fmatrix xformX0, xformX1;
if (m_flags.test(FInInterpolation))
{
u32 CurTime = Level().timeServer();
float factor = float(CurTime - p->m_dwIStartTime)/(p->m_dwIEndTime - p->m_dwIStartTime);
if (factor > 1.0f) factor = 1.0f;
float c = factor;
for (u32 k=0; k<3; k++)
{
P0[k] = c*(c*(c*p->SCoeff[k][0]+p->SCoeff[k][1])+p->SCoeff[k][2])+p->SCoeff[k][3];
P1[k] = (c*c*p->SCoeff[k][0]*3+c*p->SCoeff[k][1]*2+p->SCoeff[k][2])/3; // сокрость из формулы в 3 раза превышает скорость при расчете коэффициентов !!!!
};
P0.set(p->IStartPos);
P1.add(p->IStartPos);
}
else
{
P0 = p->IStartPos;
if (p->LastState.linear_vel.x == 0 &&
p->LastState.linear_vel.y == 0 &&
p->LastState.linear_vel.z == 0)
{
pSyncObj->cv2obj_Xfrom(p->RecalculatedState.previous_quaternion, p->RecalculatedState.previous_position, xformX0);
pSyncObj->cv2obj_Xfrom(p->RecalculatedState.quaternion, p->RecalculatedState.position, xformX1);
}
else
{
pSyncObj->cv2obj_Xfrom(p->LastState.previous_quaternion, p->LastState.previous_position, xformX0);
pSyncObj->cv2obj_Xfrom(p->LastState.quaternion, p->LastState.position, xformX1);
};
P1.sub(xformX1.c, xformX0.c);
P1.add(p->IStartPos);
}
P2.sub(p->PredictedState.position, p->PredictedState.linear_vel);
pSyncObj->cv2obj_Xfrom(p->PredictedState.quaternion, P2, xformX0);
P2.set(xformX0.c);
pSyncObj->cv2obj_Xfrom(p->PredictedState.quaternion, p->PredictedState.position, xformX1);
P3.set(xformX1.c);
/////////////////////////////////////////////////////////////////////////////
Fvector TotalPath;
TotalPath.sub(P3, P0);
float TotalLen = TotalPath.magnitude();
SPHNetState State0 = (p->NET_IItem.back()).State;
SPHNetState State1 = p->PredictedState;
float lV0 = State0.linear_vel.magnitude();
float lV1 = State1.linear_vel.magnitude();
u32 ConstTime = u32((fixed_step - ph_world->m_frame_time)*1000)+ Level().GetInterpolationSteps()*u32(fixed_step*1000);
p->m_dwIStartTime = p->m_dwILastUpdateTime;
if (( lV0 + lV1) > 0.000001 && g_cl_lvInterp == 0)
{
u32 CulcTime = iCeil(TotalLen*2000/( lV0 + lV1));
p->m_dwIEndTime = p->m_dwIStartTime + min(CulcTime, ConstTime);
}
else
p->m_dwIEndTime = p->m_dwIStartTime + ConstTime;
/////////////////////////////////////////////////////////////////////////////
Fvector V0, V1;
V0.sub(P1, P0);
V1.sub(P3, P2);
lV0 = V0.magnitude();
lV1 = V1.magnitude();
if (TotalLen != 0)
{
if (V0.x != 0 || V0.y != 0 || V0.z != 0)
{
if (lV0 > TotalLen/3)
{
V0.normalize();
V0.mul(TotalLen/3);
P1.add(V0, P0);
}
}
if (V1.x != 0 || V1.y != 0 || V1.z != 0)
{
if (lV1 > TotalLen/3)
{
V1.normalize();
V1.mul(TotalLen/3);
P2.sub(P3, V1);
};
}
};
/////////////////////////////////////////////////////////////////////////////
for( u32 i =0; i<3; i++)
{
p->SCoeff[i][0] = P3[i] - 3*P2[i] + 3*P1[i] - P0[i];
p->SCoeff[i][1] = 3*P2[i] - 6*P1[i] + 3*P0[i];
p->SCoeff[i][2] = 3*P1[i] - 3*P0[i];
p->SCoeff[i][3] = P0[i];
};
/////////////////////////////////////////////////////////////////////////////
m_flags.set (FInInterpolation, TRUE);
if (object().m_pPhysicsShell) object().m_pPhysicsShell->NetInterpolationModeON();
};
void CInventoryItem::net_Import (NET_Packet& P)
{
//copy from CPhysicObject
//Msg("Inventory item [%d][%s] net_Import...", object().ID(), object().cName().c_str());
u8 NumItems = 0;
NumItems = P.r_u8();
if (!NumItems)
return;
mask_inv_num_items num_items;
num_items.common = NumItems;
NumItems = num_items.num_items;
/*if (num_items.mask & CSE_ALifeObjectPhysic::animated)
{
net_Import_Anim_Params(P);
}*/
net_update_IItem N;
N.dwTimeStamp = Device.dwTimeGlobal;
net_Import_PH_Params(P,N,num_items);
////////////////////////////////////////////
P.r_u8(); //active (not freezed ot not)
if (this->cast_game_object()->Local())
{
return;
}
net_updateInvData *p = NetSync();
// if (!p->NET_IItem.empty() && (p->NET_IItem.back().dwTimeStamp>=N.dwTimeStamp))
// return;
//if (!p->NET_IItem.empty())
//m_flags.set (FInInterpolate, TRUE);
Level().AddObject_To_Objects4CrPr (m_object);
//this->CrPr_SetActivated (false);
//this->CrPr_SetActivationStep (0);
p->NET_IItem.push_back (N);
while (p->NET_IItem.size() > 2)
{
p->NET_IItem.pop_front ();
}
if (!m_activated)
{
#ifdef DEBUG
Msg("Activating object [%d] before interpolation starts", object().ID());
#endif // #ifdef DEBUG
object().processing_activate();
m_activated = true;
}
/*u8 NumItems = 0;
NumItems = P.r_u8();
if (!NumItems)
return;
net_update_IItem N;
N.State.force.set (0.f,0.f,0.f);
N.State.torque.set (0.f,0.f,0.f);
P.r_vec3 (N.State.position);
N.State.quaternion.x = P.r_float_q8(-1.f, 1.f);
N.State.quaternion.y = P.r_float_q8(-1.f, 1.f);
N.State.quaternion.z = P.r_float_q8(-1.f, 1.f);
N.State.quaternion.w = P.r_float_q8(-1.f, 1.f);
mask_num_items num_items;
num_items.common = NumItems;
NumItems = num_items.num_items;
N.State.enabled = num_items.mask & CSE_ALifeInventoryItem::inventory_item_state_enabled;
if (!(num_items.mask & CSE_ALifeInventoryItem::inventory_item_angular_null)) {
N.State.angular_vel.x = P.r_float_q8(0.f,10.f*PI_MUL_2);
N.State.angular_vel.y = P.r_float_q8(0.f,10.f*PI_MUL_2);
N.State.angular_vel.z = P.r_float_q8(0.f,10.f*PI_MUL_2);
}
else
N.State.angular_vel.set (0.f,0.f,0.f);
if (!(num_items.mask & CSE_ALifeInventoryItem::inventory_item_linear_null)) {
N.State.linear_vel.x = P.r_float_q8(-32.f,32.f);
N.State.linear_vel.y = P.r_float_q8(-32.f,32.f);
N.State.linear_vel.z = P.r_float_q8(-32.f,32.f);
}
else
N.State.linear_vel.set (0.f,0.f,0.f);
////////////////////////////////////////////
N.State.previous_position = N.State.position;
N.State.previous_quaternion = N.State.quaternion;
net_updateData *p = NetSync();
if (!p->NET_IItem.empty())
{
//if (p->NET_IItem.back().dwTimeStamp>=N.dwTimeStamp)
//{
// return;
//}
//m_flags.set (FInInterpolate, TRUE);
}
Level().AddObject_To_Objects4CrPr (m_object);
object().CrPr_SetActivated (false);
object().CrPr_SetActivationStep (0);
p->NET_IItem.push_back (N);
while (p->NET_IItem.size() > 2)
{
p->NET_IItem.pop_front ();
};
P.r_u8(); //enabled or not*/
};
void CInventoryItem::net_Import (NET_Packet& P)
{
u8 NumItems = 0;
NumItems = P.r_u8();
if (!NumItems)
return;
net_update_IItem N;
N.State.force.set (0.f,0.f,0.f);
N.State.torque.set (0.f,0.f,0.f);
P.r_vec3 (N.State.position);
N.State.quaternion.x = P.r_float_q8(0.f,1.f);
N.State.quaternion.y = P.r_float_q8(0.f,1.f);
N.State.quaternion.z = P.r_float_q8(0.f,1.f);
N.State.quaternion.w = P.r_float_q8(0.f,1.f);
mask_num_items num_items;
num_items.common = NumItems;
NumItems = num_items.num_items;
N.State.enabled = num_items.mask & CSE_ALifeInventoryItem::inventory_item_state_enabled;
if (!(num_items.mask & CSE_ALifeInventoryItem::inventory_item_angular_null)) {
N.State.angular_vel.x = P.r_float_q8(0.f,10.f*PI_MUL_2);
N.State.angular_vel.y = P.r_float_q8(0.f,10.f*PI_MUL_2);
N.State.angular_vel.z = P.r_float_q8(0.f,10.f*PI_MUL_2);
}
else
N.State.angular_vel.set (0.f,0.f,0.f);
if (!(num_items.mask & CSE_ALifeInventoryItem::inventory_item_linear_null)) {
N.State.linear_vel.x = P.r_float_q8(-32.f,32.f);
N.State.linear_vel.y = P.r_float_q8(-32.f,32.f);
N.State.linear_vel.z = P.r_float_q8(-32.f,32.f);
}
else
N.State.linear_vel.set (0.f,0.f,0.f);
////////////////////////////////////////////
N.State.previous_position = N.State.position;
N.State.previous_quaternion = N.State.quaternion;
net_updateData *p = NetSync();
//if (!p->NET_IItem.empty() && (p->NET_IItem.back().dwTimeStamp>=N.dwTimeStamp))
// return;
if (!p->NET_IItem.empty())
{
m_flags.set (FInInterpolate, TRUE);
}
Level().AddObject_To_Objects4CrPr (m_object);
object().CrPr_SetActivated (false);
object().CrPr_SetActivationStep (0);
p->NET_IItem.push_back (N);
while (p->NET_IItem.size() > 2)
{
p->NET_IItem.pop_front ();
};
};
