void CGameActions::CreateFilterVault()
{
	IActionMapManager* pActionMapMan = g_pGame->GetIGameFramework()->GetIActionMapManager();

	m_pFilterVault = pActionMapMan->CreateActionFilter("vault", eAFT_ActionFail);
	m_pFilterVault->Filter(rotateyaw);
	m_pFilterVault->Filter(v_rotateyaw);
	m_pFilterVault->Filter(rotatepitch);
	m_pFilterVault->Filter(v_rotatepitch);
	m_pFilterVault->Filter(nextitem);
	m_pFilterVault->Filter(previtem);
	m_pFilterVault->Filter(toggle_explosive);
	m_pFilterVault->Filter(toggle_weapon);
	m_pFilterVault->Filter(toggle_grenade);
	m_pFilterVault->Filter(handgrenade);
	m_pFilterVault->Filter(zoom);
	m_pFilterVault->Filter(reload);
	m_pFilterVault->Filter(use);
	m_pFilterVault->Filter(xi_grenade);
	m_pFilterVault->Filter(xi_handgrenade);
	m_pFilterVault->Filter(xi_zoom);
	m_pFilterVault->Filter(jump);
	m_pFilterVault->Filter(binoculars);

	m_pFilterVault->Filter(xi_rotateyaw);
	m_pFilterVault->Filter(xi_rotatepitch);
}
void CGameActions::CreateFilterMPWeaponCustomizationMenu()
{
	IActionMapManager* pActionMapMan = g_pGame->GetIGameFramework()->GetIActionMapManager();

	m_pFilterMPWeaponCustomizationMenu = pActionMapMan->CreateActionFilter("mp_weapon_customization_menu", eAFT_ActionPass);

	// Disabled all actions when in ingame menu, add any exceptions here

	// Menu actions
	m_pFilterMPWeaponCustomizationMenu->Filter(menu_open_customizeweapon);
	m_pFilterMPWeaponCustomizationMenu->Filter(menu_close_customizeweapon);

	m_pFilterMPWeaponCustomizationMenu->Filter(menu_scrollup);
	m_pFilterMPWeaponCustomizationMenu->Filter(menu_scrolldown);
	m_pFilterMPWeaponCustomizationMenu->Filter(menu_fcommand1);
	m_pFilterMPWeaponCustomizationMenu->Filter(menu_fcommand2);

	m_pFilterMPWeaponCustomizationMenu->Filter(menu_switchtab_left);
	m_pFilterMPWeaponCustomizationMenu->Filter(menu_switchtab_right);

	m_pFilterMPWeaponCustomizationMenu->Filter(menu_toggle_barrel);
	m_pFilterMPWeaponCustomizationMenu->Filter(menu_toggle_bottom);
	m_pFilterMPWeaponCustomizationMenu->Filter(menu_toggle_scope);
	m_pFilterMPWeaponCustomizationMenu->Filter(menu_toggle_ammo);

	m_pFilterMPWeaponCustomizationMenu->Filter(menu_confirm);
	m_pFilterMPWeaponCustomizationMenu->Filter(menu_confirm2);
	m_pFilterMPWeaponCustomizationMenu->Filter(menu_back);
	m_pFilterMPWeaponCustomizationMenu->Filter(menu_delete);
	m_pFilterMPWeaponCustomizationMenu->Filter(menu_apply);
	m_pFilterMPWeaponCustomizationMenu->Filter(menu_default);
	m_pFilterMPWeaponCustomizationMenu->Filter(menu_back_select);

	m_pFilterMPWeaponCustomizationMenu->Filter(menu_input_1);
	m_pFilterMPWeaponCustomizationMenu->Filter(menu_input_2);

	m_pFilterMPWeaponCustomizationMenu->Filter(menu_assetpause);
	m_pFilterMPWeaponCustomizationMenu->Filter(menu_assetzoom);

	m_pFilterMPWeaponCustomizationMenu->Filter(menu_toggle_index_finger);
	m_pFilterMPWeaponCustomizationMenu->Filter(menu_toggle_middle_finger);
	m_pFilterMPWeaponCustomizationMenu->Filter(menu_toggle_ring_finger);
	m_pFilterMPWeaponCustomizationMenu->Filter(menu_toggle_ring_finger_switched);
	m_pFilterMPWeaponCustomizationMenu->Filter(menu_toggle_pink);

	//movement
	m_pFilterMPWeaponCustomizationMenu->Filter(xi_rotateyaw);
	m_pFilterMPWeaponCustomizationMenu->Filter(xi_rotatepitch);
	m_pFilterMPWeaponCustomizationMenu->Filter(moveleft);
	m_pFilterMPWeaponCustomizationMenu->Filter(moveright);
	m_pFilterMPWeaponCustomizationMenu->Filter(moveforward);
	m_pFilterMPWeaponCustomizationMenu->Filter(moveback);
	m_pFilterMPWeaponCustomizationMenu->Filter(xi_movex);
	m_pFilterMPWeaponCustomizationMenu->Filter(xi_movey);

	m_pFilterMPWeaponCustomizationMenu->Filter(mouse_wheel_infiction_close);

	m_pFilterMPWeaponCustomizationMenu->Filter(special);
	m_pFilterMPWeaponCustomizationMenu->Filter(attack1_xi);
}
Exemple #3
0
void CEditorGame::InitActionEnums(IGameToEditorInterface* pGTE)
{
	// init ActionFilter enums
	IActionMapManager* pActionMapMgr = m_pGame->GetIGameFramework()->GetIActionMapManager();
	if (pActionMapMgr)
	{
		std::vector<string> filterNames;
		filterNames.push_back(""); // empty
		IActionFilterIteratorPtr pFilterIter = pActionMapMgr->CreateActionFilterIterator();
		while (IActionFilter* pFilter = pFilterIter->Next())
		{
			filterNames.push_back(pFilter->GetName());
		}
		size_t numFilters = 0;
		const char** allFilters = new const char*[filterNames.size()];
		std::vector<string>::const_iterator iter = filterNames.begin();
		std::vector<string>::const_iterator iterEnd = filterNames.end();
		while (iter != iterEnd)
		{
			allFilters[numFilters++] = iter->c_str();
			++iter;
		}
		pGTE->SetUIEnums("action_filter", allFilters, numFilters);
		delete[] allFilters;
	}
}
//----------------------------------------------------------------------
void CVehicleMountedWeapon::PerformRipOff(CActor* pOwner)
{
	IActionMapManager* pMapManager = gEnv->pGame->GetIGameFramework()->GetIActionMapManager();
	assert(pMapManager);
	pMapManager->EnableActionMap("vehicle_general", false);

	IVehicle *pVehicle = gEnv->pGame->GetIGameFramework()->GetIVehicleSystem()->GetVehicle(m_vehicleId);
	if(pVehicle)
	{
		SVehicleEventParams params;
		params.entityId = GetEntityId();

		pVehicle->BroadcastVehicleEvent(eVE_WeaponRemoved, params);

		if(pOwner)
		{
			if(gEnv->bMultiplayer)
			{
				const IEntity* pVehicleEnt = pVehicle->GetEntity();
				IEntity* pEntity		  = pOwner->GetEntity(); 
				const Matrix34& vehWMat   = pVehicleEnt->GetWorldTM(); 
				m_previousWSpaceOffsetPosition = pEntity->GetWorldPos();
				m_localRipUserOffset = vehWMat.GetInverted().TransformPoint(m_previousWSpaceOffsetPosition); 
			}

			pOwner->LinkToVehicle(0);
		}

		m_previousVehicleRotation = pVehicle->GetEntity()->GetWorldRotation();
	}

	CHeavyMountedWeapon::PerformRipOff(pOwner);
}
void CGameActions::CreateFilterCutscene()
{
	IActionMapManager* pActionMapMan = g_pGame->GetIGameFramework()->GetIActionMapManager();

	m_pFilterCutscene = pActionMapMan->CreateActionFilter("cutscene", eAFT_ActionFail);	
	m_pFilterCutscene->Filter(binoculars);
}
void CGameActions::CreateFilterNoFireModeSwitch()
{
	IActionMapManager* pActionMapMan = g_pGame->GetIGameFramework()->GetIActionMapManager();

	m_pFilterNoFireModeSwitch = pActionMapMan->CreateActionFilter("no_firemodeswitch", eAFT_ActionFail);
	m_pFilterNoFireModeSwitch->Filter(weapon_change_firemode);
}
void CGameActions::CreateFilterNoVehicleExit()
{
	IActionMapManager* pActionMapMan = g_pGame->GetIGameFramework()->GetIActionMapManager();

	m_pFilterNoVehicleExit = pActionMapMan->CreateActionFilter("no_vehicle_exit", eAFT_ActionFail);
	m_pFilterNoVehicleExit->Filter(use);
}
void CGameActions::CreateFilterNoConnectivity()
{
	IActionMapManager* pActionMapMan = g_pGame->GetIGameFramework()->GetIActionMapManager();

	m_pFilterNoConnectivity = pActionMapMan->CreateActionFilter("no_connectivity", eAFT_ActionPass);
	m_pFilterNoConnectivity->Filter(scores);
}
void CGameActions::CreateFilterNoWeaponCustomization()
{
	IActionMapManager* pActionMapMan = g_pGame->GetIGameFramework()->GetIActionMapManager();

	m_pFilterNoWeaponCustomization = pActionMapMan->CreateActionFilter("no_weaponcustomization", eAFT_ActionFail);
	m_pFilterNoWeaponCustomization->Filter(menu_open_customizeweapon);
}
void CGameActions::CreateFilterNoMouse()
{
	IActionMapManager* pActionMapMan = g_pGame->GetIGameFramework()->GetIActionMapManager();

	m_pFilterNoMouse = pActionMapMan->CreateActionFilter("no_mouse", eAFT_ActionFail);
	m_pFilterNoMouse->Filter(attack1);
	m_pFilterNoMouse->Filter(v_attack1);
	m_pFilterNoMouse->Filter(v_attack2);
	m_pFilterNoMouse->Filter(rotateyaw);
	m_pFilterNoMouse->Filter(v_rotateyaw);
	m_pFilterNoMouse->Filter(rotatepitch);
	m_pFilterNoMouse->Filter(v_rotatepitch);
	m_pFilterNoMouse->Filter(nextitem);
	m_pFilterNoMouse->Filter(previtem);
	m_pFilterNoMouse->Filter(toggle_explosive);
	m_pFilterNoMouse->Filter(toggle_weapon);
	m_pFilterNoMouse->Filter(toggle_grenade);
	m_pFilterNoMouse->Filter(handgrenade);
	m_pFilterNoMouse->Filter(zoom);
	m_pFilterNoMouse->Filter(reload);
	m_pFilterNoMouse->Filter(use);
	m_pFilterNoMouse->Filter(xi_grenade);
	m_pFilterNoMouse->Filter(xi_handgrenade);
	m_pFilterNoMouse->Filter(xi_zoom);
	m_pFilterNoMouse->Filter(jump);
	m_pFilterNoMouse->Filter(binoculars);
	m_pFilterNoMouse->Filter(attack1_xi);
	m_pFilterNoMouse->Filter(attack2_xi);
}
void CGameActions::CreateFilterMouseY()
{
	IActionMapManager* pActionMapMan = g_pGame->GetIGameFramework()->GetIActionMapManager();
	m_pFilterMouseY = pActionMapMan->CreateActionFilter("no_mouseY", eAFT_ActionFail);
	m_pFilterMouseY->Filter(rotatepitch);
	m_pFilterMouseY->Filter(xi_rotatepitch);
}
Exemple #12
0
void CEditorGame::InitActionMapsEnums(IGameToEditorInterface* pGTE)
{
	IActionMapManager* pAM = m_pGame->GetIGameFramework()->GetIActionMapManager();
	IActionMapIteratorPtr iter = pAM->CreateActionMapIterator();

	const int numActionMaps = pAM->GetActionMapsCount();

	if(numActionMaps == 0)
		return;

	const char** nameValueStrings = new const char*[numActionMaps];
	int curEntryIndex = 0;
	while (IActionMap* pMap = iter->Next())
	{
		assert(curEntryIndex < numActionMaps);
		PREFAST_ASSUME(curEntryIndex < numActionMaps);
		nameValueStrings[curEntryIndex++] = pMap->GetName();

		if (curEntryIndex > numActionMaps)
		{
			CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "[InitActionMapsEnums] Wrong number of Action Maps.");
			break;
		}
	}

	pGTE->SetUIEnums("action_maps", nameValueStrings, numActionMaps);

	delete[] nameValueStrings;
}
void CProceduralWeaponAnimation::UpdateDebugState()
{
	if ((g_pGameCVars->g_debugWeaponOffset==2) != m_debugInput)
	{
		IActionMapManager* pAMMgr = gEnv->pGame->GetIGameFramework()->GetIActionMapManager();

		if (g_pGameCVars->g_debugWeaponOffset == 2)
		{
			if (gEnv->pInput)
				gEnv->pInput->AddEventListener(m_weaponOffsetInput.get());
			if (pAMMgr)
				pAMMgr->Enable(false);
			m_weaponOffsetInput->SetRightDebugOffset(SWeaponOffset(m_rightOffset));
			m_weaponOffsetInput->SetLeftDebugOffset(SWeaponOffset(m_leftOffset));
		}
		else
		{
			if (gEnv->pInput)
				gEnv->pInput->RemoveEventListener(m_weaponOffsetInput.get());
			if (pAMMgr)
				pAMMgr->Enable(true);
		}
		m_debugInput = (g_pGameCVars->g_debugWeaponOffset == 2);
	}

	if (g_pGameCVars->g_debugWeaponOffset)
	{
		DrawCrossHairGuideLines();
	}
	if (m_debugInput)
	{
		m_weaponOffsetInput->Update();
	}
}
Exemple #14
0
void CGameActions::CreateFilterNoMouse()
{
	IActionMapManager *pActionMapMan = g_pGame->GetIGameFramework()->GetIActionMapManager();

	m_pFilterNoMouse = pActionMapMan->CreateActionFilter("no_mouse", eAFT_ActionFail);
	m_pFilterNoMouse->Filter(attack1);
	m_pFilterNoMouse->Filter(v_attack1);
	m_pFilterNoMouse->Filter(v_attack2);
	m_pFilterNoMouse->Filter(rotateyaw);
	m_pFilterNoMouse->Filter(v_rotateyaw);
	m_pFilterNoMouse->Filter(rotatepitch);
	m_pFilterNoMouse->Filter(v_rotatepitch);
	m_pFilterNoMouse->Filter(nextitem);
	m_pFilterNoMouse->Filter(previtem);
	m_pFilterNoMouse->Filter(small);
	m_pFilterNoMouse->Filter(medium);
	m_pFilterNoMouse->Filter(heavy);
	m_pFilterNoMouse->Filter(handgrenade);
	m_pFilterNoMouse->Filter(explosive);
	m_pFilterNoMouse->Filter(utility);
	m_pFilterNoMouse->Filter(zoom);
	m_pFilterNoMouse->Filter(reload);
	m_pFilterNoMouse->Filter(use);
	m_pFilterNoMouse->Filter(xi_use);
	m_pFilterNoMouse->Filter(xi_grenade);
	m_pFilterNoMouse->Filter(xi_handgrenade);
	m_pFilterNoMouse->Filter(xi_zoom);
	m_pFilterNoMouse->Filter(jump);
}
Exemple #15
0
void CGameActions::CreateFilterNoObjectivesOpen()
{
	IActionMapManager *pActionMapMan = g_pGame->GetIGameFramework()->GetIActionMapManager();

	m_pFilterNoObjectivesOpen = pActionMapMan->CreateActionFilter("no_objectives_open", eAFT_ActionFail);
	m_pFilterNoObjectivesOpen->Filter(scores);
}
void CGameActions::CreateFilterHostMigration()
{
	IActionMapManager* pActionMapMan = g_pGame->GetIGameFramework()->GetIActionMapManager();

	m_pFilterHostMigration = pActionMapMan->CreateActionFilter("hostmigration", eAFT_ActionPass);

	CommonCreateFilterFreeze(m_pFilterHostMigration);
}
void CGameActions::CreateFilterFreezeTime()
{
	IActionMapManager* pActionMapMan = g_pGame->GetIGameFramework()->GetIActionMapManager();

	m_pFilterFreezeTime = pActionMapMan->CreateActionFilter("freezetime", eAFT_ActionPass);

	CommonCreateFilterFreeze(m_pFilterFreezeTime);
}
Exemple #18
0
void CGameActions::CreateFilterCutsceneNoPlayer()
{
	IActionMapManager *pActionMapMan = g_pGame->GetIGameFramework()->GetIActionMapManager();

	m_pFilterCutsceneNoPlayer = pActionMapMan->CreateActionFilter("cutscene_no_player", eAFT_ActionPass);
	m_pFilterCutsceneNoPlayer->Filter(loadLastSave);
	m_pFilterCutsceneNoPlayer->Filter(load);
}
void CGameActions::CreateFilterMPChat()
{
	IActionMapManager* pActionMapMan = g_pGame->GetIGameFramework()->GetIActionMapManager();

	m_pFilterMPChat = pActionMapMan->CreateActionFilter("mp_chat", eAFT_ActionPass);

	// Disabled all actions when typing a chat message, add any exceptions here
}
Exemple #20
0
	EContextEstablishTaskResult OnStep( SContextEstablishState& state )
	{
		IActionMapManager *pActionMapMan = CCryAction::GetCryAction()->GetIActionMapManager();
		pActionMapMan->Enable(false);
		pActionMapMan->EnableActionMap("player", true);
		pActionMapMan->EnableFilter(0, false); // disable all actionfilters
		return eCETR_Ok;
	}
void CGameActions::CreateFilterUseKeyOnly()
{
	IActionMapManager* pActionMapMan = g_pGame->GetIGameFramework()->GetIActionMapManager();

	m_pFilterUseKeyOnly = pActionMapMan->CreateActionFilter("useKeyOnly", eAFT_ActionPass);

	m_pFilterUseKeyOnly->Filter(use);
}
Exemple #22
0
void CGameActions::CreateFilterTweakMenu()
{
	IActionMapManager* pActionMapMan = g_pGame->GetIGameFramework()->GetIActionMapManager();

	m_pFilterTweakMenu = pActionMapMan->CreateActionFilter("tweak_menu_active", eAFT_ActionFail);
	m_pFilterTweakMenu->Filter(toggle_explosive);
	m_pFilterTweakMenu->Filter(toggle_weapon);
	m_pFilterTweakMenu->Filter(toggle_grenade);
}
void CGameActions::CreateFilterNotYetSpawned()
{
	IActionMapManager* pActionMapMan = g_pGame->GetIGameFramework()->GetIActionMapManager();

	m_pFilterNotYetSpawned = pActionMapMan->CreateActionFilter("not_yet_spawned", eAFT_ActionFail);
	m_pFilterNotYetSpawned->Filter(binoculars);
	m_pFilterNotYetSpawned->Filter(zoom);
	m_pFilterNotYetSpawned->Filter(xi_zoom);
}
void CGameActions::CreateItemPickup()
{
	IActionMapManager* pActionMapMan = g_pGame->GetIGameFramework()->GetIActionMapManager();

	m_pFilterItemPickup = pActionMapMan->CreateActionFilter("ItemPickup", eAFT_ActionFail);
	m_pFilterItemPickup->Filter(use);
	m_pFilterItemPickup->Filter(heavyweaponremove);
	m_pFilterItemPickup->Filter(itemPickup);
}
void CGameActions::CreateFilterStrikePointer()
{
	IActionMapManager* pActionMapMan = g_pGame->GetIGameFramework()->GetIActionMapManager();

	m_pFilterStrikePointer = pActionMapMan->CreateActionFilter("strikePointerDeployed", eAFT_ActionFail);

	m_pFilterStrikePointer->Filter(attack1);
	m_pFilterStrikePointer->Filter(attack1_xi);
}
Exemple #26
0
void CUIInput::UnloadEventSystem()
{
	if (   gEnv->pGame 
		&& gEnv->pGame->GetIGameFramework() 
		&& gEnv->pGame->GetIGameFramework()->GetIActionMapManager() )
	{
		IActionMapManager* pAmMgr = gEnv->pGame->GetIGameFramework()->GetIActionMapManager();
		pAmMgr->RemoveExtraActionListener( this );
	}
}
void CGameActions::CreateFilterIngameMenu()
{
	IActionMapManager* pActionMapMan = g_pGame->GetIGameFramework()->GetIActionMapManager();

	m_pFilterIngameMenu = pActionMapMan->CreateActionFilter("ingame_menu", eAFT_ActionPass);

	// Disabled all actions when in ingame menu, add any exceptions here

	// Menu actions
	m_pFilterIngameMenu->Filter(menu_open_customizeweapon);
	m_pFilterIngameMenu->Filter(menu_close_customizeweapon);
	m_pFilterIngameMenu->Filter(menu_friends_open);
	
	m_pFilterIngameMenu->Filter(menu_map_zoomout);
	m_pFilterIngameMenu->Filter(menu_map_zoomin);

	m_pFilterIngameMenu->Filter(menu_scrollup);
	m_pFilterIngameMenu->Filter(menu_scrolldown);
	m_pFilterIngameMenu->Filter(menu_fcommand1);
	m_pFilterIngameMenu->Filter(menu_fcommand2);

	m_pFilterIngameMenu->Filter(menu_switchtab_left);
	m_pFilterIngameMenu->Filter(menu_switchtab_right);

	m_pFilterIngameMenu->Filter(menu_toggle_barrel);
	m_pFilterIngameMenu->Filter(menu_toggle_bottom);
	m_pFilterIngameMenu->Filter(menu_toggle_scope);
	m_pFilterIngameMenu->Filter(menu_toggle_ammo);

	m_pFilterIngameMenu->Filter(menu_confirm);
	m_pFilterIngameMenu->Filter(menu_confirm2);
	m_pFilterIngameMenu->Filter(menu_back);
	m_pFilterIngameMenu->Filter(menu_exit);
	m_pFilterIngameMenu->Filter(menu_delete);
	m_pFilterIngameMenu->Filter(menu_apply);
	m_pFilterIngameMenu->Filter(menu_default);
	m_pFilterIngameMenu->Filter(menu_back_select);

	m_pFilterIngameMenu->Filter(menu_input_1);
	m_pFilterIngameMenu->Filter(menu_input_2);
	
	m_pFilterIngameMenu->Filter(menu_assetpause);
	m_pFilterIngameMenu->Filter(menu_assetzoom);

	m_pFilterIngameMenu->Filter(menu_up);
	m_pFilterIngameMenu->Filter(menu_down);
	m_pFilterIngameMenu->Filter(menu_left);
	m_pFilterIngameMenu->Filter(menu_right);

	m_pFilterIngameMenu->Filter(voice_chat_talk);

	m_pFilterIngameMenu->Filter(skip_cutscene);
	m_pFilterIngameMenu->Filter(skip_loadingscreen);
	m_pFilterIngameMenu->Filter(skip_loadingscreen_switched);
}
Exemple #28
0
void CUIInput::UnloadEventSystem()
{
	if (g_pGame && g_pGame->GetIGameFramework())
	{
		IActionMapManager* pAMMgr = g_pGame->GetIGameFramework()->GetIActionMapManager();
		if (pAMMgr)
		{
			pAMMgr->RemoveAlwaysActionListener(shared_from_this());
		}
	}
}
void CGameActions::CreateTutorialNoMove()
{
	IActionMapManager* pActionMapMan = g_pGame->GetIGameFramework()->GetIActionMapManager();

	m_pFilterWarningPopup = pActionMapMan->CreateActionFilter("tutorial_no_move", eAFT_ActionFail);
	m_pFilterWarningPopup->Filter(moveforward);
	m_pFilterWarningPopup->Filter(moveback);
	m_pFilterWarningPopup->Filter(moveleft);
	m_pFilterWarningPopup->Filter(moveright);
	m_pFilterWarningPopup->Filter(xi_movey);
	m_pFilterWarningPopup->Filter(xi_movex);
}
void CGameActions::CreateFilterVehicleNoSeatChangeAndExit()
{
	IActionMapManager* pActionMapMan = g_pGame->GetIGameFramework()->GetIActionMapManager();

	m_pFilterVehicleNoSeatChangeAndExit = pActionMapMan->CreateActionFilter("vehicle_no_seat_change_and_exit", eAFT_ActionFail);
	m_pFilterVehicleNoSeatChangeAndExit->Filter(v_exit);
	m_pFilterVehicleNoSeatChangeAndExit->Filter(v_changeseat);
	m_pFilterVehicleNoSeatChangeAndExit->Filter(v_changeseat1);
	m_pFilterVehicleNoSeatChangeAndExit->Filter(v_changeseat2);
	m_pFilterVehicleNoSeatChangeAndExit->Filter(v_changeseat3);
	m_pFilterVehicleNoSeatChangeAndExit->Filter(v_changeseat4);
	m_pFilterVehicleNoSeatChangeAndExit->Filter(v_changeseat5);
}