int CheckDemoExDemo(void)
{
int result = false;
int p;
M_ChangeDemoExtendedFormat();
p = IsDemoPlayback();
if (!p)
{
p = IsDemoContinue();
}
if (p)
{
char *demoname, *filename;
filename = malloc(strlen(myargv[p + 1]) + 16);
strcpy(filename, myargv[p + 1]);
AddDefaultExtension(filename, ".lmp");
demoname = I_FindFile(filename, NULL);
if (demoname)
{
result = G_ReadDemoFooter(demoname);
free(demoname);
}
free(filename);
}
return result;
}
//------------------------------------------------------------------------
CProjectile *CWeaponSystem::DoSpawnAmmo(IEntityClass *pAmmoType, bool isRemote, const SAmmoParams *pAmmoParams)
{
bool isServer=gEnv->bServer;
bool isClient=gEnv->IsClient();
if(pAmmoParams->serverSpawn && (!isServer || IsDemoPlayback()))
{
if(!pAmmoParams->predictSpawn || isRemote)
return 0;
}
SEntitySpawnParams spawnParams;
spawnParams.pClass = pAmmoType;
spawnParams.sName = "ammo";
spawnParams.nFlags = pAmmoParams->flags | ENTITY_FLAG_NO_PROXIMITY; // No proximity for this entity.
IEntity *pEntity = gEnv->pEntitySystem->SpawnEntity(spawnParams);
if(!pEntity)
{
GameWarning("Failed to spawn ammo '%s'! Entity creation failed...", pAmmoType->GetName());
return 0;
}
CProjectile *pProjectile = GetProjectile(pEntity->GetId());
if(pProjectile && !isServer && !isRemote && pAmmoParams->predictSpawn)
pProjectile->GetGameObject()->RegisterAsPredicted();
return pProjectile;
}
void e6y_InitCommandLine(void)
{
int p;
if ((p = M_CheckParm("-skipsec")) && (p < myargc-1))
{
float min, sec;
if (sscanf(myargv[p+1], "%f:%f", &min, &sec) == 2)
demo_skiptics = (int) ((60 * min + sec) * TICRATE);
else if (sscanf(myargv[p+1], "%f", &sec) == 1)
demo_skiptics = (int) (sec * TICRATE);
}
if ((IsDemoPlayback() || IsDemoContinue()) && (startmap > 1 || demo_skiptics))
G_SkipDemoStart();
if ((p = M_CheckParm("-avidemo")) && (p < myargc-1))
avi_shot_fname = myargv[p + 1];
stats_level = M_CheckParm("-levelstat");
// TAS-tracers
InitTracers();
shorttics = movement_shorttics || M_CheckParm("-shorttics");
}
void e6y_InitCommandLine(void)
{
int p;
if ((p = M_CheckParm("-skipsec")) && (p < myargc-1))
demo_skiptics = (int)(atof(myargv[p + 1]) * 35);
if ((IsDemoPlayback() || IsDemoContinue()) && (startmap > 1 || demo_skiptics))
G_SkipDemoStart();
if ((p = M_CheckParm("-avidemo")) && (p < myargc-1))
avi_shot_fname = myargv[p + 1];
stats_level = M_CheckParm("-levelstat");
// TAS-tracers
InitTracers();
shorttics = movement_shorttics || M_CheckParm("-shorttics");
// What hacked exe are we emulating?
game_exe = EXE_NONE;
if ((p = M_CheckParm("-exe")) && (p < myargc-1))
{
if (!strcasecmp(myargv[p + 1], "chex") || !strcasecmp(myargv[p + 1], "chex.exe"))
{
game_exe = EXE_CHEX;
}
}
}
void CVehicleClient::EnableActionMaps(IVehicleSeat* pSeat, bool enable)
{
assert(pSeat);
// illegal to change action maps in demo playback - Lin
if (!IsDemoPlayback() && pSeat)
{
IActionMapManager* pActionMapMan = g_pGame->GetIGameFramework()->GetIActionMapManager();
CRY_ASSERT(pActionMapMan);
pActionMapMan->EnableActionMap("player", !enable);
EntityId passengerID = pSeat->GetPassenger();
// now the general vehicle controls
if (IActionMap* pActionMap = pActionMapMan->GetActionMap("vehicle_general"))
{
pActionMap->SetActionListener(enable ? passengerID : 0);
pActionMapMan->EnableActionMap("vehicle_general", enable);
}
// todo: if necessary enable the vehicle-specific action map here
// specific controls for this vehicle seat
const char* actionMap = pSeat->GetActionMap();
if (actionMap && actionMap[0])
{
if (IActionMap* pActionMap = pActionMapMan->GetActionMap(actionMap))
{
pActionMap->SetActionListener(enable ? passengerID : 0);
pActionMapMan->EnableActionMap(actionMap, enable);
}
}
}
}
void e6y_G_Compatibility(void)
{
deh_applyCompatibility();
if (IsDemoPlayback())
{
int i, p;
//"2.4.8.2" -> 0x02040802
if ((p = M_CheckParm("-emulate")) && (p < myargc - 1))
{
unsigned int emulated_version = 0;
int b[4], k = 1;
memset(b, 0, sizeof(b));
sscanf(myargv[p + 1], "%d.%d.%d.%d", &b[0], &b[1], &b[2], &b[3]);
for (i = 3; i >= 0; i--, k *= 256)
{
#ifdef RANGECHECK
if (b[i] >= 256)
I_Error("Wrong version number of package: %s", PACKAGE_VERSION);
#endif
emulated_version += b[i] * k;
}
for (i = 0; i < PC_MAX; i++)
{
prboom_comp[i].state =
(emulated_version >= prboom_comp[i].minver &&
emulated_version < prboom_comp[i].maxver);
}
}
for (i = 0; i < PC_MAX; i++)
{
if (M_CheckParm(prboom_comp[i].cmd))
prboom_comp[i].state = true;
}
}
P_CrossSubsector = P_CrossSubsector_PrBoom;
if (!prboom_comp[PC_FORCE_LXDOOM_DEMO_COMPATIBILITY].state)
{
if (demo_compatibility)
P_CrossSubsector = P_CrossSubsector_Doom;
switch (compatibility_level)
{
case boom_compatibility_compatibility:
case boom_201_compatibility:
case boom_202_compatibility:
case mbf_compatibility:
P_CrossSubsector = P_CrossSubsector_Boom;
break;
}
}
}
void CNetPlayerInput::DoSetState(const SSerializedPlayerInput& input )
{
m_newInterpolation |= (input.position != m_curInput.position) || (input.deltaMovement != m_curInput.deltaMovement);
const bool wasSprinting = m_curInput.sprint;
m_curInput = input;
CHANGED_NETWORK_STATE(m_pPlayer, CPlayer::ASPECT_INPUT_CLIENT );
if(wasSprinting != input.sprint)
{
SInputEventData inputEventData( SInputEventData::EInputEvent_Sprint, m_pPlayer->GetEntityId(), CCryName("sprint"), input.sprint ? eAAM_OnPress : eAAM_OnRelease, 0.f );
m_pPlayer->StateMachineHandleEventMovement( SStateEventPlayerInput( &inputEventData ) );
}
// not having these set seems to stop a remote avatars rotation being reflected
m_curInput.aiming = true;
m_curInput.allowStrafing = true;
m_curInput.usinglookik = true;
IAIActor* pAIActor = CastToIAIActorSafe(m_pPlayer->GetEntity()->GetAI());
if (pAIActor)
pAIActor->GetState().bodystate=input.bodystate;
CMovementRequest moveRequest;
moveRequest.SetStance( (EStance)m_curInput.stance );
if(IsDemoPlayback())
{
Vec3 localVDir(m_pPlayer->GetViewQuatFinal().GetInverted() * m_curInput.lookDirection);
Ang3 deltaAngles(asinf(localVDir.z),0,atan2_tpl(-localVDir.x,localVDir.y));
moveRequest.AddDeltaRotation(deltaAngles*gEnv->pTimer->GetFrameTime());
}
moveRequest.SetPseudoSpeed(CalculatePseudoSpeed());
moveRequest.SetAllowStrafing(input.allowStrafing);
m_pPlayer->GetMovementController()->RequestMovement(moveRequest);
#if !defined(_RELEASE)
// debug..
if (g_pGameCVars->g_debugNetPlayerInput & 1)
{
IPersistantDebug * pPD = gEnv->pGame->GetIGameFramework()->GetIPersistantDebug();
pPD->Begin( string("net_player_input_") + m_pPlayer->GetEntity()->GetName(), true );
pPD->AddSphere( moveRequest.GetLookTarget(), 0.5f, ColorF(1,0,1,1), 1.0f );
// pPD->AddSphere( moveRequest.GetMoveTarget(), 0.5f, ColorF(1,1,0,1), 1.0f );
Vec3 wp(m_pPlayer->GetEntity()->GetWorldPos() + Vec3(0,0,2));
pPD->AddDirection( wp, 1.5f, m_curInput.deltaMovement, ColorF(1,0,0,1), 1.0f );
pPD->AddDirection( wp, 1.5f, m_curInput.lookDirection, ColorF(0,1,0,1), 1.0f );
}
#endif
}
void CNetPlayerInput::DoSetState(const SSerializedPlayerInput& input )
{
m_curInput = input;
m_pPlayer->GetGameObject()->ChangedNetworkState( INPUT_ASPECT );
CMovementRequest moveRequest;
moveRequest.SetStance( (EStance)m_curInput.stance );
if(IsDemoPlayback())
{
Vec3 localVDir(m_pPlayer->GetViewQuatFinal().GetInverted() * m_curInput.lookDirection);
Ang3 deltaAngles(asin(localVDir.z),0,cry_atan2f(-localVDir.x,localVDir.y));
moveRequest.AddDeltaRotation(deltaAngles*gEnv->pTimer->GetFrameTime());
}
//else
{
moveRequest.SetLookTarget( m_pPlayer->GetEntity()->GetWorldPos() + 10.0f * m_curInput.lookDirection );
moveRequest.SetAimTarget(moveRequest.GetLookTarget());
}
float pseudoSpeed = 0.0f;
if (m_curInput.deltaMovement.len2() > 0.0f)
{
pseudoSpeed = m_pPlayer->CalculatePseudoSpeed(m_curInput.sprint);
}
moveRequest.SetPseudoSpeed(pseudoSpeed);
moveRequest.SetAllowStrafing(true);
float lean=0.0f;
if (m_curInput.leanl)
lean-=1.0f;
if (m_curInput.leanr)
lean+=1.0f;
moveRequest.SetLean(lean);
m_pPlayer->GetMovementController()->RequestMovement(moveRequest);
// debug..
if (g_pGameCVars->g_debugNetPlayerInput & 1)
{
IPersistantDebug * pPD = gEnv->pGame->GetIGameFramework()->GetIPersistantDebug();
pPD->Begin( string("net_player_input_") + m_pPlayer->GetEntity()->GetName(), true );
pPD->AddSphere( moveRequest.GetLookTarget(), 0.5f, ColorF(1,0,1,1), 1.0f );
// pPD->AddSphere( moveRequest.GetMoveTarget(), 0.5f, ColorF(1,1,0,1), 1.0f );
Vec3 wp(m_pPlayer->GetEntity()->GetWorldPos() + Vec3(0,0,2));
pPD->AddDirection( wp, 1.5f, m_curInput.deltaMovement, ColorF(1,0,0,1), 1.0f );
pPD->AddDirection( wp, 1.5f, m_curInput.lookDirection, ColorF(0,1,0,1), 1.0f );
}
}
//------------------------------------------------------------------------
void CRocket::HandleEvent(const SGameObjectEvent &event)
{
if (m_destroying)
return;
CProjectile::HandleEvent(event);
if (!gEnv->bServer || IsDemoPlayback())
return;
if (event.event == eGFE_OnCollision)
{
EventPhysCollision *pCollision = (EventPhysCollision *)event.ptr;
if (m_safeExplosion>0.0f)
{
float dp2=(m_launchLoc-GetEntity()->GetWorldPos()).len2();
if (dp2<=m_safeExplosion*m_safeExplosion)
return;
}
if(pCollision && pCollision->pEntity[0]->GetType()==PE_PARTICLE)
{
float bouncy, friction;
uint pierceabilityMat;
gEnv->pPhysicalWorld->GetSurfaceParameters(pCollision->idmat[1], bouncy, friction, pierceabilityMat);
pe_params_particle params;
if(pCollision->pEntity[0]->GetParams(¶ms)==0)
SetDefaultParticleParams(¶ms);
if((params.velocity>1.0f) && (pCollision->idmat[1] != CBullet::GetWaterMaterialId())
&& (!pCollision->pEntity[1] || (pCollision->pEntity[1]->GetType() != PE_LIVING && pCollision->pEntity[1]->GetType() != PE_ARTICULATED)))
{
if(pierceabilityMat>params.iPierceability)
return;
}
else if((pCollision->idmat[1] == CBullet::GetWaterMaterialId()) && m_skipWater)
return;
}
IEntity* pTarget = pCollision->iForeignData[1]==PHYS_FOREIGN_ID_ENTITY ? (IEntity*)pCollision->pForeignData[1] : 0;
Explode(true, true, pCollision->pt, pCollision->n, pCollision->vloc[0], pTarget?pTarget->GetId():0);
}
}
//------------------------------------------------------------------------
CProjectile *CWeaponSystem::SpawnAmmo(IEntityClass* pAmmoType, bool isRemote)
{
TAmmoTypeParams::const_iterator it = m_ammoparams.find(pAmmoType);
if (it == m_ammoparams.end())
{
GameWarning("Failed to spawn ammo '%s'! Unknown class or entity class not registered...", pAmmoType?pAmmoType->GetName():"");
return 0;
}
const SAmmoParams* pAmmoParams = it->second.params;
if (!m_config.empty())
{
std::map<string, const SAmmoParams *>::const_iterator cit=it->second.configurations.find(m_config);
if (cit != it->second.configurations.end())
pAmmoParams=cit->second;
else
pAmmoParams=it->second.params;
}
bool isServer=gEnv->bServer;
bool isClient=gEnv->bClient;
if ( pAmmoParams->serverSpawn && (!isServer || IsDemoPlayback()) )
{
if (!pAmmoParams->predictSpawn || isRemote)
return 0;
}
SEntitySpawnParams spawnParams;
spawnParams.pClass = pAmmoType;
spawnParams.sName = "ammo";
spawnParams.nFlags = pAmmoParams->flags | ENTITY_FLAG_NO_PROXIMITY; // No proximity for this entity.
IEntity *pEntity = gEnv->pEntitySystem->SpawnEntity(spawnParams);
if (!pEntity)
{
GameWarning("Failed to spawn ammo '%s'! Entity creation failed...", pAmmoType->GetName());
return 0;
}
CProjectile *pProjectile = GetProjectile(pEntity->GetId());
if (pProjectile && !isServer && !isRemote && pAmmoParams->predictSpawn)
pProjectile->GetGameObject()->RegisterAsPredicted();
return pProjectile;
}
void e6y_InitCommandLine(void)
{
int p;
if ((p = M_CheckParm("-skipsec")) && (p < myargc-1))
demo_skiptics = (int)(atof(myargv[p + 1]) * 35);
if ((IsDemoPlayback() || IsDemoContinue()) && (startmap > 1 || demo_skiptics))
G_SkipDemoStart();
if ((p = M_CheckParm("-avidemo")) && (p < myargc-1))
avi_shot_fname = myargv[p + 1];
stats_level = M_CheckParm("-levelstat");
// TAS-tracers
InitTracers();
shorttics = movement_shorttics || M_CheckParm("-shorttics");
}
void CNetPlayerInput::DoSetState(const SSerializedPlayerInput& input )
{
// PLAYERPREDICTION
m_newInterpolation |= (input.position != m_curInput.position) || (input.deltaMovement != m_curInput.deltaMovement);
m_curInput = input;
CHANGED_NETWORK_STATE(m_pPlayer, IPlayerInput::INPUT_ASPECT );
// not having these set seems to stop a remote avatars rotation being reflected
m_curInput.aiming = true;
m_curInput.allowStrafing = true;
m_curInput.usinglookik = true;
// ~PLAYERPREDICTION
IAIActor* pAIActor = CastToIAIActorSafe(m_pPlayer->GetEntity()->GetAI());
if (pAIActor)
pAIActor->GetState().bodystate=input.bodystate;
CMovementRequest moveRequest;
moveRequest.SetStance( (EStance)m_curInput.stance );
if(IsDemoPlayback())
{
Vec3 localVDir(m_pPlayer->GetViewQuatFinal().GetInverted() * m_curInput.lookDirection);
Ang3 deltaAngles(asinf(localVDir.z),0,cry_atan2f(-localVDir.x,localVDir.y));
moveRequest.AddDeltaRotation(deltaAngles*gEnv->pTimer->GetFrameTime());
}
{
if (m_curInput.usinglookik)
moveRequest.SetLookTarget( m_pPlayer->GetEntity()->GetWorldPos() + 10.0f * m_curInput.lookDirection );
else
moveRequest.ClearLookTarget();
if (m_curInput.aiming)
moveRequest.SetAimTarget(moveRequest.GetLookTarget());
else
moveRequest.ClearAimTarget();
}
/*
float pseudoSpeed = 0.0f;
if (m_curInput.deltaMovement.len2() > 0.0f)
{
pseudoSpeed = m_pPlayer->CalculatePseudoSpeed(m_curInput.sprint);
}
*/
// PLAYERPREDICTION
moveRequest.SetPseudoSpeed(CalculatePseudoSpeed());
// ~PLAYERPREDICTION
moveRequest.SetAllowStrafing(input.allowStrafing);
float lean=0.0f;
if (m_curInput.leanl)
lean-=1.0f;
if (m_curInput.leanr)
lean+=1.0f;
moveRequest.SetLean(lean);
m_pPlayer->GetMovementController()->RequestMovement(moveRequest);
IAnimationGraphState *pState=0;
if (m_pPlayer->GetAnimatedCharacter())
pState=m_pPlayer->GetAnimatedCharacter()->GetAnimationGraphState();
// PLAYERPREDICTION
if (pState)
{
pState->SetInput(m_pPlayer->m_inputAiming, m_curInput.aiming);
pState->SetInput(m_pPlayer->m_inputUsingLookIK, m_curInput.usinglookik);
}
#if !defined(_RELEASE)
// debug..
if (g_pGameCVars->g_debugNetPlayerInput & 1)
{
IPersistantDebug * pPD = gEnv->pGame->GetIGameFramework()->GetIPersistantDebug();
pPD->Begin( string("net_player_input_") + m_pPlayer->GetEntity()->GetName(), true );
pPD->AddSphere( moveRequest.GetLookTarget(), 0.5f, ColorF(1,0,1,1), 1.0f );
// pPD->AddSphere( moveRequest.GetMoveTarget(), 0.5f, ColorF(1,1,0,1), 1.0f );
Vec3 wp(m_pPlayer->GetEntity()->GetWorldPos() + Vec3(0,0,2));
pPD->AddDirection( wp, 1.5f, m_curInput.deltaMovement, ColorF(1,0,0,1), 1.0f );
pPD->AddDirection( wp, 1.5f, m_curInput.lookDirection, ColorF(0,1,0,1), 1.0f );
}
#endif
// ~PLAYERPREDICTION
}
//
//-----------------------------------------------------------------------------------------------------------
// (MATT) Moved here from Scriptbind_AI when that was moved to the AI system {2008/02/15:15:23:16}
int CScriptBind_Action::RegisterWithAI(IFunctionHandler *pH)
{
if (gEnv->bMultiplayer && !gEnv->bServer)
return pH->EndFunction();
int type;
ScriptHandle hdl;
if (!pH->GetParams(hdl, type))
return pH->EndFunction();
EntityId entityID = (EntityId)hdl.n;
IEntity *pEntity = gEnv->pEntitySystem->GetEntity(entityID);
if(!pEntity)
{
GameWarning("RegisterWithAI: Tried to set register with AI nonExisting entity with id [%d]. ", entityID);
return pH->EndFunction();
}
// Apparently we can't assume that there is just one IGameObject to an entity, because we choose between (at least) Actor and Vehicle objects.
// (MATT) Do we really need to check on the actor system here? {2008/02/15:18:38:34}
IGameFramework *pGameFramework = gEnv->pGame->GetIGameFramework();
IVehicleSystem* pVSystem = pGameFramework->GetIVehicleSystem();
IActorSystem* pASystem = pGameFramework->GetIActorSystem();
if(!pASystem)
{
GameWarning("RegisterWithAI: no ActorSystem for %s.", pEntity->GetName());
return pH->EndFunction();
}
AIObjectParams params(type, 0, entityID);
bool autoDisable(true);
// For most types, we need to parse the tables
// For others we leave them blank
switch (type)
{
case AIOBJECT_ACTOR:
case AIOBJECT_2D_FLY:
case AIOBJECT_BOAT:
case AIOBJECT_CAR:
case AIOBJECT_HELICOPTER:
case AIOBJECT_INFECTED:
case AIOBJECT_ALIENTICK:
case AIOBJECT_HELICOPTERCRYSIS2:
if(gEnv->pAISystem && ! gEnv->pAISystem->ParseTables(3, true, pH, params, autoDisable))
return pH->EndFunction();
default:;
}
// Most types check these, so just get them in advance
IActor* pActor = pASystem->GetActor( pEntity->GetId() );
IVehicle* pVehicle = NULL;
if( pVSystem )
pVehicle = pVSystem->GetVehicle( pEntity->GetId() );
// Set this if we've found something to create a proxy from
IGameObject* pGameObject = NULL;
switch(type)
{
case AIOBJECT_ACTOR:
case AIOBJECT_2D_FLY:
case AIOBJECT_INFECTED:
case AIOBJECT_ALIENTICK:
{
// (MATT) The pActor/pVehicle test below - is it basically trying to distiguish between the two cases above? If so, separate them! {2008/02/15:19:38:08}
if(!pActor)
{
GameWarning("RegisterWithAI: no Actor for %s.", pEntity->GetName());
return pH->EndFunction();
}
pGameObject = pActor->GetGameObject();
}
break;
case AIOBJECT_BOAT:
case AIOBJECT_CAR:
{
if(!pVehicle)
{
GameWarning("RegisterWithAI: no Vehicle for %s (Id %i).", pEntity->GetName(), pEntity->GetId());
return pH->EndFunction();
}
pGameObject = pVehicle->GetGameObject();
}
break;
case AIOBJECT_HELICOPTER:
case AIOBJECT_HELICOPTERCRYSIS2:
{
if(!pVehicle)
{
GameWarning("RegisterWithAI: no Vehicle for %s (Id %i).", pEntity->GetName(), pEntity->GetId());
return pH->EndFunction();
}
pGameObject = pVehicle->GetGameObject();
params.m_moveAbility.b3DMove = true;
}
break;
case AIOBJECT_PLAYER:
{
if(IsDemoPlayback())
return pH->EndFunction();
SmartScriptTable pTable;
if (pH->GetParamCount() > 2)
pH->GetParam(3,pTable);
else
return pH->EndFunction();
pGameObject = pActor->GetGameObject();
pTable->GetValue("groupid",params.m_sParamStruct.m_nGroup);
const char* faction = 0;
if (pTable->GetValue("esFaction", faction) && gEnv->pAISystem)
{
params.m_sParamStruct.factionID = gEnv->pAISystem->GetFactionMap().GetFactionID(faction);
if (faction && *faction && (params.m_sParamStruct.factionID == IFactionMap::InvalidFactionID))
{
GameWarning("Unknown faction '%s' being set...", faction);
}
}
else
{
// Márcio: backwards compatibility
int species = -1;
if (!pTable->GetValue("eiSpecies", species))
pTable->GetValue("species", species);
if (species > -1)
params.m_sParamStruct.factionID = species;
}
pTable->GetValue("commrange",params.m_sParamStruct.m_fCommRange); //Luciano - added to use GROUPONLY signals
SmartScriptTable pPerceptionTable;
if(pTable->GetValue("Perception",pPerceptionTable))
{
pPerceptionTable->GetValue( "sightrange", params.m_sParamStruct.m_PerceptionParams.sightRange);
}
}
break;
case AIOBJECT_SNDSUPRESSOR:
{
// (MATT) This doesn't need a proxy? {2008/02/15:19:45:58}
SmartScriptTable pTable;
// Properties table
if (pH->GetParamCount() > 2)
pH->GetParam(3,pTable);
else
return pH->EndFunction();
if (!pTable->GetValue("radius",params.m_moveAbility.pathRadius))
params.m_moveAbility.pathRadius = 10.f;
break;
}
case AIOBJECT_WAYPOINT:
break;
/*
// this block is commented out since params.m_sParamStruct is currently ignored in pEntity->RegisterInAISystem()
// instead of setting the group id here, it will be set from the script right after registering
default:
// try to get groupid settings for anchors
params.m_sParamStruct.m_nGroup = -1;
params.m_sParamStruct.m_nSpecies = -1;
{
SmartScriptTable pTable;
if ( pH->GetParamCount() > 2 )
pH->GetParam( 3, pTable );
if ( *pTable )
pTable->GetValue( "groupid", params.m_sParamStruct.m_nGroup );
}
break;
*/
}
// Remove any existing AI object
pEntity->RegisterInAISystem(AIObjectParams(0));
// Register in AI to get a new AI object, deregistering the old one in the process
pEntity->RegisterInAISystem(params);
// (MATT) ? {2008/02/15:19:46:29}
// AI object was not created (possibly AI System is disabled)
if (IAIObject* aiObject = pEntity->GetAI())
{
if(type==AIOBJECT_SNDSUPRESSOR)
aiObject->SetRadius(params.m_moveAbility.pathRadius);
else if(type>=AIANCHOR_FIRST) // if anchor - set radius
{
SmartScriptTable pTable;
// Properties table
if (pH->GetParamCount() > 2)
pH->GetParam(3,pTable);
else
return pH->EndFunction();
float radius(0.f);
pTable->GetValue("radius",radius);
int groupId = -1;
pTable->GetValue("groupid", groupId);
aiObject->SetGroupId(groupId);
aiObject->SetRadius(radius);
}
if (IAIActorProxy* proxy = aiObject->GetProxy())
proxy->UpdateMeAlways(!autoDisable);
}
return pH->EndFunction();
}
void CNetPlayerInput::UpdateMoveRequest()
{
CMovementRequest moveRequest;
SMovementState moveState;
m_pPlayer->GetMovementController()->GetMovementState(moveState);
Quat worldRot = m_pPlayer->GetBaseQuat(); // m_pPlayer->GetEntity()->GetWorldRotation();
Vec3 deltaMovement = worldRot.GetInverted().GetNormalized() * m_curInput.deltaMovement;
// absolutely ensure length is correct
deltaMovement = deltaMovement.GetNormalizedSafe(ZERO) * m_curInput.deltaMovement.GetLength();
moveRequest.AddDeltaMovement( deltaMovement );
if( IsDemoPlayback() )
{
Vec3 localVDir(m_pPlayer->GetViewQuatFinal().GetInverted() * m_curInput.lookDirection);
Ang3 deltaAngles(asinf(localVDir.z),0,cry_atan2f(-localVDir.x,localVDir.y));
moveRequest.AddDeltaRotation(deltaAngles*gEnv->pTimer->GetFrameTime());
}
//else
{
//--- Vector slerp actually produces QNans if the vectors are exactly opposite, in that case snap to the target
if (m_lookDir.Dot(m_curInput.lookDirection) < (float)-0.99f)
{
m_lookDir = m_curInput.lookDirection;
}
else
{
m_lookDir.SetSlerp(m_lookDir, m_curInput.lookDirection, g_pGameCVars->pl_netAimLerpFactor);
}
Vec3 distantTarget = moveState.eyePosition + 1000.0f * m_lookDir;
Vec3 lookTarget = distantTarget;
if (m_curInput.usinglookik)
moveRequest.SetLookTarget( lookTarget );
else
moveRequest.ClearLookTarget();
if (m_curInput.aiming)
moveRequest.SetAimTarget( lookTarget );
else
moveRequest.ClearAimTarget();
if (m_curInput.deltaMovement.GetLengthSquared() > sqr(0.02f)) // 0.2f is almost stopped
moveRequest.SetBodyTarget( distantTarget );
else
moveRequest.ClearBodyTarget();
}
moveRequest.SetAllowStrafing(m_curInput.allowStrafing);
if(m_pPlayer->IsPlayer())
moveRequest.SetPseudoSpeed(CalculatePseudoSpeed());
else
moveRequest.SetPseudoSpeed(m_curInput.pseudoSpeed);
float lean=0.0f;
if (m_curInput.leanl)
lean-=1.0f;
if (m_curInput.leanr)
lean+=1.0f;
if (fabsf(lean)>0.01f)
moveRequest.SetLean(lean);
else
moveRequest.ClearLean();
moveRequest.SetStance( (EStance)m_curInput.stance );
m_pPlayer->GetMovementController()->RequestMovement(moveRequest);
if (m_curInput.sprint)
m_pPlayer->m_actions |= ACTION_SPRINT;
else
m_pPlayer->m_actions &= ~ACTION_SPRINT;
if (m_curInput.leanl)
m_pPlayer->m_actions |= ACTION_LEANLEFT;
else
m_pPlayer->m_actions &= ~ACTION_LEANLEFT;
if (m_curInput.leanr)
m_pPlayer->m_actions |= ACTION_LEANRIGHT;
else
m_pPlayer->m_actions &= ~ACTION_LEANRIGHT;
#if !defined(_RELEASE)
// debug..
if (g_pGameCVars->g_debugNetPlayerInput & 2)
{
IPersistantDebug * pPD = gEnv->pGame->GetIGameFramework()->GetIPersistantDebug();
pPD->Begin( string("update_player_input_") + m_pPlayer->GetEntity()->GetName(), true );
Vec3 wp = m_pPlayer->GetEntity()->GetWorldPos();
wp.z += 2.0f;
pPD->AddSphere( moveRequest.GetLookTarget(), 0.5f, ColorF(1,0,1,0.3f), 1.0f );
// pPD->AddSphere( moveRequest.GetMoveTarget(), 0.5f, ColorF(1,1,0,0.3f), 1.0f );
pPD->AddDirection( m_pPlayer->GetEntity()->GetWorldPos() + Vec3(0,0,2), 1, m_curInput.deltaMovement, ColorF(1,0,0,0.3f), 1.0f );
}
#endif
//m_curInput.deltaMovement.zero();
}
void e6y_G_Compatibility(void)
{
extern int maxhealth;
extern int max_soul;
extern int mega_health;
int comp_max = (compatibility_level == doom_12_compatibility ? 199 : 200);
max_soul = (IsDehMaxSoul ? deh_max_soul : comp_max);
mega_health = (IsDehMegaHealth ? deh_mega_health : comp_max);
if (comp[comp_maxhealth])
{
maxhealth = 100;
maxhealthbonus = (IsDehMaxHealth ? deh_maxhealth : comp_max);
}
else
{
maxhealth = (IsDehMaxHealth ? deh_maxhealth : 100);
maxhealthbonus = maxhealth * 2;
}
if (!DEH_mobjinfo_bits[MT_SKULL])
{
if (compatibility_level == doom_12_compatibility)
mobjinfo[MT_SKULL].flags |= (MF_COUNTKILL);
else
mobjinfo[MT_SKULL].flags &= ~(MF_COUNTKILL);
}
M_ChangeCompTranslucency();
if (IsDemoPlayback())
{
int i, p;
//"2.4.8.2" -> 0x02040802
if ((p = M_CheckParm("-emulate")) && (p < myargc - 1))
{
unsigned int emulated_version = 0;
int b[4], k = 1;
memset(b, 0, sizeof(b));
sscanf(myargv[p + 1], "%d.%d.%d.%d", &b[0], &b[1], &b[2], &b[3]);
for (i = 3; i >= 0; i--, k *= 256)
{
#ifdef RANGECHECK
if (b[i] >= 256)
I_Error("Wrong version number of package: %s", VERSION);
#endif
emulated_version += b[i] * k;
}
for (i = 0; i < PC_MAX; i++)
{
prboom_comp[i].state =
(emulated_version >= prboom_comp[i].minver &&
emulated_version < prboom_comp[i].maxver);
}
}
for (i = 0; i < PC_MAX; i++)
{
if (M_CheckParm(prboom_comp[i].cmd))
prboom_comp[i].state = true;
}
}
use_wrong_fixeddiv = &(prboom_comp[PC_WRONG_FIXEDDIV].state);
P_CrossSubsector = P_CrossSubsector_PrBoom;
if (!prboom_comp[PC_FORCE_LXDOOM_DEMO_COMPATIBILITY].state)
{
if (demo_compatibility)
P_CrossSubsector = P_CrossSubsector_Doom;
switch (compatibility_level)
{
case boom_compatibility_compatibility:
case boom_201_compatibility:
case boom_202_compatibility:
case mbf_compatibility:
P_CrossSubsector = P_CrossSubsector_Boom;
break;
}
}
}
void CNetPlayerInput::UpdateMoveRequest()
{
CMovementRequest moveRequest;
SMovementState moveState;
m_pPlayer->GetMovementController()->GetMovementState(moveState);
Quat worldRot = m_pPlayer->GetBaseQuat(); // m_pPlayer->GetEntity()->GetWorldRotation();
Vec3 deltaMovement = worldRot.GetInverted().GetNormalized() * m_curInput.deltaMovement;
// absolutely ensure length is correct
deltaMovement = deltaMovement.GetNormalizedSafe(ZERO) * m_curInput.deltaMovement.GetLength();
moveRequest.AddDeltaMovement( deltaMovement );
if( IsDemoPlayback() )
{
Vec3 localVDir(m_pPlayer->GetViewQuatFinal().GetInverted() * m_curInput.lookDirection);
Ang3 deltaAngles(asinf(localVDir.z),0,atan2_tpl(-localVDir.x,localVDir.y));
moveRequest.AddDeltaRotation(deltaAngles*gEnv->pTimer->GetFrameTime());
}
const float fNetAimLerpFactor = g_pGameCVars->pl_netAimLerpFactor;
//Vector slerp produces artifacts here, using a per-component lerp instead
Vec3 vCurrentRight = m_lookDir.cross(Vec3Constants<float>::fVec3_OneZ);
Vec3 vCurrentProjected = -(vCurrentRight.cross(Vec3Constants<float>::fVec3_OneZ));
vCurrentRight.Normalize();
vCurrentProjected.Normalize();
Vec3 vNewRight = m_curInput.lookDirection.cross(Vec3Constants<float>::fVec3_OneZ);
Vec3 vNewProjected = -(vNewRight.cross(Vec3Constants<float>::fVec3_OneZ));
vNewProjected.Normalize();
float fRotZDirDot = vNewProjected.dot(vCurrentRight);
float fRotZDot = vNewProjected.dot(vCurrentProjected);
float fRotZ = acos_tpl(fRotZDot);
fRotZ = AngleWrap_PI(fRotZ);
float fRotZFinal = -fsgnf(fRotZDirDot) * fRotZ * fNetAimLerpFactor;
float fCurrentAngle = acos_tpl(Vec3Constants<float>::fVec3_OneZ.dot(m_lookDir));
float fNewAngle = acos_tpl(Vec3Constants<float>::fVec3_OneZ.dot(m_curInput.lookDirection));
float fRotXFinal = (fNewAngle - fCurrentAngle) * -fNetAimLerpFactor;
//Rotate around X first, as we have already generated the right vector
Vec3 vNewLookDir = m_lookDir.GetRotated(vCurrentRight, fRotXFinal);
m_lookDir = vNewLookDir.GetRotated(Vec3Constants<float>::fVec3_OneZ, fRotZFinal);
Vec3 distantTarget = moveState.eyePosition + 1000.0f * m_lookDir;
Vec3 lookTarget = distantTarget;
if (m_curInput.usinglookik)
moveRequest.SetLookTarget( lookTarget );
else
moveRequest.ClearLookTarget();
if (m_curInput.aiming)
moveRequest.SetAimTarget( lookTarget );
else
moveRequest.ClearAimTarget();
if (m_curInput.deltaMovement.GetLengthSquared() > sqr(0.02f)) // 0.2f is almost stopped
moveRequest.SetBodyTarget( distantTarget );
else
moveRequest.ClearBodyTarget();
moveRequest.SetAllowStrafing(m_curInput.allowStrafing);
moveRequest.SetPseudoSpeed(CalculatePseudoSpeed());
moveRequest.SetStance( (EStance)m_curInput.stance );
m_pPlayer->GetMovementController()->RequestMovement(moveRequest);
if (m_curInput.sprint)
m_pPlayer->m_actions |= ACTION_SPRINT;
else
m_pPlayer->m_actions &= ~ACTION_SPRINT;
#if 0
if (m_pPlayer->m_netSetPosition)
{
SPredictedCharacterStates charStates;
charStates.states[0].position = m_pPlayer->GetEntity()->GetPos();
charStates.states[0].orientation = m_pPlayer->GetEntity()->GetRotation();
charStates.states[0].deltatime = 0.0f;
charStates.states[1].position = m_pPlayer->m_netCurrentLocation;
charStates.states[1].orientation = m_pPlayer->GetEntity()->GetRotation();
charStates.states[1].deltatime = gEnv->pTimer->GetFrameTime();
charStates.states[2].position = m_pPlayer->m_netDesiredLocation;
charStates.states[2].orientation = m_pPlayer->GetEntity()->GetRotation();
charStates.states[2].deltatime = m_pPlayer->m_netLerpTime;
charStates.nStates = 3;
moveRequest.SetPrediction(charStates);
}
#endif //0
#if !defined(_RELEASE)
// debug..
if (g_pGameCVars->g_debugNetPlayerInput & 2)
{
IPersistantDebug * pPD = gEnv->pGame->GetIGameFramework()->GetIPersistantDebug();
pPD->Begin( string("update_player_input_") + m_pPlayer->GetEntity()->GetName(), true );
Vec3 wp = m_pPlayer->GetEntity()->GetWorldPos();
wp.z += 2.0f;
pPD->AddSphere( moveRequest.GetLookTarget(), 0.5f, ColorF(1,0,1,0.3f), 1.0f );
// pPD->AddSphere( moveRequest.GetMoveTarget(), 0.5f, ColorF(1,1,0,0.3f), 1.0f );
pPD->AddDirection( m_pPlayer->GetEntity()->GetWorldPos() + Vec3(0,0,2), 1, m_curInput.deltaMovement, ColorF(1,0,0,0.3f), 1.0f );
}
#endif
//m_curInput.deltaMovement.zero();
}
void CAccessory::PickUp(EntityId pickerId, bool sound, bool select/* =true */, bool keepHistory/* =true */, const char *setup /*= NULL*/)
{
CActor *pActor=GetActor(pickerId);
if (!pActor)
return;
TriggerRespawn();
GetEntity()->EnablePhysics(false);
Physicalize(false, false);
bool soundEnabled = IsSoundEnabled();
EnableSound(sound);
SetViewMode(0);
SetOwnerId(pickerId);
CopyRenderFlags(GetOwner());
Hide(true);
m_stats.dropped = false;
m_stats.detached = false;
m_stats.brandnew = false;
IInventory *pInventory = pActor->GetInventory();
if (!pInventory)
{
GameWarning("Actor '%s' has no inventory, when trying to pickup '%s'!",pActor->GetEntity()->GetName(),GetEntity()->GetName());
return;
}
if (!pActor->IsPlayer() || pActor->IsClient() || gEnv->bMultiplayer)
{
bool hasAccessory = pInventory->HasAccessory(GetEntity()->GetClass());
bool hasAccessoryForThisWeapon = pInventory->HasAccessory(GetEntity()->GetClass());
if (!hasAccessoryForThisWeapon)
pInventory->AddAccessory(GetEntity()->GetClass());
if (!hasAccessory)
ProcessAccessoryAmmoCapacities(pInventory, true);
if (!hasAccessoryForThisWeapon)
ProcessAccessoryAmmo(pInventory);
}
OnPickedUp(pickerId, m_sharedparams->params.unique);
if (select)
{
PlayAction(GetFragmentIds().pickedup);
}
EnableSound(soundEnabled);
bool isLocalEntity = GetEntity()->GetFlags()&(ENTITY_FLAG_CLIENT_ONLY|ENTITY_FLAG_SERVER_ONLY) ? true : false;
if (IsServer() && !IsDemoPlayback())
{
if(!gEnv->bMultiplayer || isLocalEntity)
RemoveEntity();
else if(g_pGame->GetGameRules())
g_pGame->GetGameRules()->ScheduleEntityRemoval(GetEntityId(),10.0f,false); //Give some time to the clients to pick the msg
}
if (IsServer())
{
GetGameObject()->SetNetworkParent(pickerId);
if (!isLocalEntity)
{
pActor->GetGameObject()->InvokeRMIWithDependentObject(CActor::ClPickUp(), CActor::PickItemParams(GetEntityId(), m_stats.selected, sound), eRMI_ToAllClients|eRMI_NoLocalCalls, GetEntityId());
}
}
}
void CAccessory::PickUp(EntityId pickerId, bool sound, bool select, bool keepHistory, const char *setup)
{
CActor *pActor=GetActor(pickerId);
if (!pActor)
return;
if(!CheckAmmoRestrictions(pickerId))
{
if (IsServer())
g_pGame->GetGameRules()->SendTextMessage(eTextMessageCenter, "@ammo_maxed_out", eRMI_ToClientChannel, pActor->GetChannelId(), (string("@")+GetEntity()->GetClass()->GetName()).c_str());
return;
}
TriggerRespawn();
GetEntity()->EnablePhysics(false);
Physicalize(false, false);
bool soundEnabled = IsSoundEnabled();
EnableSound(sound);
SetViewMode(0);
SetOwnerId(pickerId);
CopyRenderFlags(GetOwner());
Hide(true);
m_stats.dropped = false;
m_stats.brandnew = false;
IInventory *pInventory = pActor->GetInventory();
if (!pInventory)
{
GameWarning("Actor '%s' has no inventory, when trying to pickup '%s'!",pActor->GetEntity()->GetName(),GetEntity()->GetName());
return;
}
if(!pInventory->HasAccessory(GetEntity()->GetClass()))
{
pInventory->AddAccessory(GetEntity()->GetClass());
}
OnPickedUp(pickerId, m_sharedparams->params.unique);
PlayAction(g_pItemStrings->pickedup);
EnableSound(soundEnabled);
if (IsServer() && !IsDemoPlayback())
{
if(!gEnv->bMultiplayer)
RemoveEntity();
else if(g_pGame->GetGameRules())
g_pGame->GetGameRules()->ScheduleEntityRemoval(GetEntityId(),10.0f,false); //Give some time to the clients to pick the msg
}
if (IsServer())
{
GetGameObject()->SetNetworkParent(pickerId);
if ((GetEntity()->GetFlags()&(ENTITY_FLAG_CLIENT_ONLY|ENTITY_FLAG_SERVER_ONLY)) == 0)
{
pActor->GetGameObject()->InvokeRMIWithDependentObject(CActor::ClPickUp(), CActor::PickItemParams(GetEntityId(), m_stats.selected, sound), eRMI_ToAllClients|eRMI_NoLocalCalls, GetEntityId());
const char *displayName=GetDisplayName();
}
}
}
void CNetPlayerInput::PreUpdate()
{
IPhysicalEntity * pPhysEnt = m_pPlayer->GetEntity()->GetPhysics();
if (!pPhysEnt)
return;
CMovementRequest moveRequest;
SMovementState moveState;
m_pPlayer->GetMovementController()->GetMovementState(moveState);
Quat worldRot = m_pPlayer->GetBaseQuat(); // m_pPlayer->GetEntity()->GetWorldRotation();
Vec3 deltaMovement = worldRot.GetInverted().GetNormalized() * m_curInput.deltaMovement;
// absolutely ensure length is correct
deltaMovement = deltaMovement.GetNormalizedSafe(ZERO) * m_curInput.deltaMovement.GetLength();
moveRequest.AddDeltaMovement( deltaMovement );
if( IsDemoPlayback() )
{
Vec3 localVDir(m_pPlayer->GetViewQuatFinal().GetInverted() * m_curInput.lookDirection);
Ang3 deltaAngles(asin(localVDir.z),0,cry_atan2f(-localVDir.x,localVDir.y));
moveRequest.AddDeltaRotation(deltaAngles*gEnv->pTimer->GetFrameTime());
}
//else
{
Vec3 distantTarget = moveState.eyePosition + 1000.0f * m_curInput.lookDirection;
Vec3 lookTarget = distantTarget;
if (gEnv->bClient && m_pPlayer->GetGameObject()->IsProbablyVisible())
{
// post-process aim direction
ray_hit hit;
static const int obj_types = ent_all; // ent_terrain|ent_static|ent_rigid|ent_sleeping_rigid|ent_living;
static const unsigned int flags = rwi_stop_at_pierceable|rwi_colltype_any;
bool rayHitAny = 0 != gEnv->pPhysicalWorld->RayWorldIntersection( moveState.eyePosition, 150.0f * m_curInput.lookDirection, obj_types, flags, &hit, 1, pPhysEnt );
if (rayHitAny)
{
lookTarget = hit.pt;
}
static float proneDist = 1.0f;
static float crouchDist = 0.6f;
static float standDist = 0.3f;
float dist = standDist;
if(m_pPlayer->GetStance() == STANCE_CROUCH)
dist = crouchDist;
else if(m_pPlayer->GetStance() == STANCE_PRONE)
dist = proneDist;
if((lookTarget - moveState.eyePosition).GetLength2D() < dist)
{
Vec3 eyeToTarget2d = lookTarget - moveState.eyePosition;
eyeToTarget2d.z = 0.0f;
eyeToTarget2d.NormalizeSafe();
eyeToTarget2d *= dist;
ray_hit newhit;
bool rayHitAny = 0 != gEnv->pPhysicalWorld->RayWorldIntersection( moveState.eyePosition + eyeToTarget2d, 3 * Vec3(0,0,-1), obj_types, flags, &newhit, 1, pPhysEnt );
if (rayHitAny)
{
lookTarget = newhit.pt;
}
}
// SNH: new approach. Make sure the aimTarget is at least 1.5m away,
// if not, pick a point 1m down the vector instead.
Vec3 dir = lookTarget - moveState.eyePosition;
static float minDist = 1.5f;
if(dir.GetLengthSquared() < minDist)
{
lookTarget = moveState.eyePosition + dir.GetNormalizedSafe();
}
// draw eye pos for comparison
//gEnv->pRenderer->GetIRenderAuxGeom()->DrawSphere(moveState.eyePosition, 0.04f, ColorF(0.3f,0.2f,0.7f,1.0f));
}
moveRequest.SetLookTarget( lookTarget );
moveRequest.SetAimTarget( lookTarget );
if (m_curInput.deltaMovement.GetLengthSquared() > sqr(0.2f)) // 0.2f is almost stopped
moveRequest.SetBodyTarget( distantTarget );
else
moveRequest.ClearBodyTarget();
}
moveRequest.SetAllowStrafing(true);
float pseudoSpeed = 0.0f;
if (m_curInput.deltaMovement.len2() > 0.0f)
{
pseudoSpeed = m_pPlayer->CalculatePseudoSpeed(m_curInput.sprint);
}
moveRequest.SetPseudoSpeed(pseudoSpeed);
float lean=0.0f;
if (m_curInput.leanl)
lean-=1.0f;
if (m_curInput.leanr)
lean+=1.0f;
if (fabsf(lean)>0.01f)
moveRequest.SetLean(lean);
else
moveRequest.ClearLean();
m_pPlayer->GetMovementController()->RequestMovement(moveRequest);
if (m_curInput.sprint)
m_pPlayer->m_actions |= ACTION_SPRINT;
else
m_pPlayer->m_actions &= ~ACTION_SPRINT;
if (m_curInput.leanl)
m_pPlayer->m_actions |= ACTION_LEANLEFT;
else
m_pPlayer->m_actions &= ~ACTION_LEANLEFT;
if (m_curInput.leanr)
m_pPlayer->m_actions |= ACTION_LEANRIGHT;
else
m_pPlayer->m_actions &= ~ACTION_LEANRIGHT;
// debug..
if (g_pGameCVars->g_debugNetPlayerInput & 2)
{
IPersistantDebug * pPD = gEnv->pGame->GetIGameFramework()->GetIPersistantDebug();
pPD->Begin( string("update_player_input_") + m_pPlayer->GetEntity()->GetName(), true );
Vec3 wp = m_pPlayer->GetEntity()->GetWorldPos();
wp.z += 2.0f;
pPD->AddSphere( moveRequest.GetLookTarget(), 0.5f, ColorF(1,0,1,0.3f), 1.0f );
// pPD->AddSphere( moveRequest.GetMoveTarget(), 0.5f, ColorF(1,1,0,0.3f), 1.0f );
pPD->AddDirection( m_pPlayer->GetEntity()->GetWorldPos() + Vec3(0,0,2), 1, m_curInput.deltaMovement, ColorF(1,0,0,0.3f), 1.0f );
}
//m_curInput.deltaMovement.zero();
}
