Beispiel #1
0
void CAntiCheatManager::ParseAntiCheatConfig(const char * filename)
{
	CCryFile file;

	CryFixedStringT<128> realFileName;
	realFileName.Format("%s/%s", PathUtil::GetGameFolder().c_str(), filename);
	if (file.Open( realFileName.c_str(), "rb", ICryPak::FOPEN_HINT_QUIET | ICryPak::FOPEN_ONDISK ))
	{
		const size_t fileSize = file.GetLength();
		char* pBuffer = new char [fileSize];

		file.ReadRaw(pBuffer, fileSize);

		XmlNodeRef xmlData = gEnv->pSystem->LoadXmlFromBuffer(pBuffer, fileSize);

		SAFE_DELETE_ARRAY(pBuffer);

		if(xmlData)
		{
			CryLog("Parsing Anti-Cheat Configuration...");
			ParseAntiCheatConfig(xmlData);
		}
		else
		{
			CryLog("Unable to parse Anti-Cheat Configuration");
		}
	}
	else
	{
		CryLog("Unable to load '%s'", realFileName.c_str());
	}
}
Beispiel #2
0
string CLuaRemoteDebug::GetLineFromFile( const char *sFilename,int nLine )
{
	CCryFile file;

	if (!file.Open(sFilename,"rb"))
	{
		return "";
	}
	int nLen = file.GetLength();
	char *sScript = new char [nLen + 1];
	char *sString = new char [nLen + 1];
	file.ReadRaw( sScript,nLen );
	sScript[nLen] = '\0';

	int nCurLine = 1;
	string strLine;

	strcpy( sString,"" );

	const char *strLast = sScript+nLen;

	const char *str = sScript;
	while (str < strLast)
	{
		char *s = sString;
		while (str < strLast && *str != '\n' && *str != '\r')
		{
			*s++ = *str++;
		}
		*s = '\0';
		if (str + 2 <= strLast && str[0] == '\r' && str[1] == '\n')
		{
			// Skip \r\n (Windows style line endings)
			str += 2;
		}
		else
		{
			// Skip \n or \r (Unix/Mac style line endings)
			str += 1;
		}

		if (nCurLine == nLine)
		{
			strLine = sString;
			strLine.replace( '\t',' ' );
			strLine.Trim();
			break;
		}
		nCurLine++;
	}

	delete []sString;
	delete []sScript;

	return strLine;
}
	static inline void WriteFccCodes(CCryFile& file, const TFourCCSet& fccs, uint32 keyword)
	{
		uint32 fcc = keyword;
		file.Write( &fcc, sizeof(fcc) );
		for ( TFourCCSet::const_iterator it = fccs.begin(); it != fccs.end(); ++it )
		{
			fcc = *it;
			file.Write( &fcc, sizeof(fcc) );
		}
		fcc = eBK_void;
		file.Write( &fcc, sizeof(fcc) );
	}
void CGameVolumesManager::Export( const char* fileName ) const
{
	CCryFile file;
	if( false != file.Open( fileName, "wb" ) )
	{
		const uint32 maxVertices = 512;
		Vec3 writeVertexBuffer[maxVertices];

		// File version
		uint32 nFileVersion = GAME_VOLUMES_FILE_VERSION;
		file.Write( &nFileVersion,sizeof(nFileVersion) );


		// Save volume info
		uint32 nVolumeCount = (uint32)m_volumesData.size();
		file.Write( &nVolumeCount, sizeof(nVolumeCount) );

		for (uint32 i = 0; i < nVolumeCount; ++i)
		{
			const EntityVolume& volumeInfo = m_volumesData[i];

			CRY_ASSERT ( volumeInfo.vertices.size() < maxVertices );

			uint32 nVertexCount = min( (uint32)volumeInfo.vertices.size(), maxVertices );
			uint32 nEntityId = volumeInfo.entityId;
			f32    fHeight = volumeInfo.height;
			bool   bClosed = volumeInfo.closed;

			file.Write( &nEntityId, sizeof(nEntityId) );
			file.Write( &fHeight, sizeof(fHeight) );
			if( nFileVersion > 1 )
			{
				file.Write( &bClosed, sizeof(bClosed) );
			}
			file.Write( &nVertexCount, sizeof(nVertexCount) );

			if (nVertexCount > 0)
			{
				for (uint32 v = 0; v < nVertexCount; ++v)
				{
					writeVertexBuffer[v] = volumeInfo.vertices[v];
				}
				file.Write( &writeVertexBuffer[0], sizeof(writeVertexBuffer[0]) * nVertexCount );
			}
		}

		file.Close();
	}
}
void CLedgeManager::Load( const char* fileName )
{
	// Clear in case there is anything left
	Reset();

	// In editor we don't load exported data, entities will recreate on load
	if (m_editorManager.IsInEditorMode())
		return;

	CCryFile file;
	if( false != file.Open( fileName, "rb" ) )
	{
		// File version
		uint32 nFileVersion;
		file.ReadType( &nFileVersion );

		if (nFileVersion != LEDGE_DATA_FILE_VERSION)
		{
			GameWarning("!LedgeManager: Level data could not be loaded, file %s has version %d, expected %d. Level needs re-export", fileName, nFileVersion, LEDGE_DATA_FILE_VERSION);
			return;
		}

		// Ledges and markers info
		uint32 totalLedgeObjectsCount, totalLedgeMarkersCount;
		file.ReadType( &totalLedgeObjectsCount );
		file.ReadType( &totalLedgeMarkersCount );

		m_levelLedges.Allocate( totalLedgeObjectsCount, totalLedgeMarkersCount );

		file.ReadType( &m_levelLedges.m_pLedgeObjects[0], totalLedgeObjectsCount );
		file.ReadType( &m_levelLedges.m_pMarkers[0], totalLedgeMarkersCount );
	
		file.Close();
	}
}
void CLedgeManagerEdit::Export( const char* fileName ) const
{
	const uint32 totalLedgeObjectsCount = m_ledgeObjects.size();

	if (totalLedgeObjectsCount > 0)
	{
		CCryFile file;
		if( false != file.Open( fileName, "wb" ) )
		{
			// Count number of markers ...
			uint32 totalLedgeMarkersCount = 0;
			for (uint32 objectIdx = 0; objectIdx < totalLedgeObjectsCount; ++objectIdx)
			{
				totalLedgeMarkersCount += m_ledgeObjects[objectIdx].m_markers.size();
			}

			// Prepare buffers ...
			SLedgeObject ledgeObjectBuffer[MAX_LEDGE_ENTITIES];
			SLedgeMarkerBuffer ledgeMarkersBuffer(totalLedgeMarkersCount);

			uint32 currentMarkerIdx = 0;
			for (uint32 objectIdx = 0; objectIdx < totalLedgeObjectsCount; ++objectIdx)
			{
				SLedgeObject& ledgeObject = ledgeObjectBuffer[objectIdx];
				const SLedgeObjectEditor& ledgeObjectEdit = m_ledgeObjects[objectIdx];

				ledgeObject.m_entityId = ((ledgeObjectEdit.m_ledgeFlags[LedgeSide_In] & kLedgeFlag_static) == 0) ? ledgeObjectEdit.m_entityId : 0;
				ledgeObject.m_ledgeFlags[LedgeSide_In]  = ledgeObjectEdit.m_ledgeFlags[LedgeSide_In];
				ledgeObject.m_ledgeFlags[LedgeSide_Out] = ledgeObjectEdit.m_ledgeFlags[LedgeSide_Out];
				ledgeObject.m_ledgeCornerEndAdjustAmount = ledgeObjectEdit.m_ledgeCornerEndAdjustAmount;
				ledgeObject.m_markersStartIdx = currentMarkerIdx;
				ledgeObject.m_markersCount = ledgeObjectEdit.m_markers.size();

				CRY_ASSERT((ledgeObject.m_markersStartIdx + ledgeObject.m_markersCount) <= totalLedgeMarkersCount);

				for(size_t markerIdx = 0; markerIdx < ledgeObjectEdit.m_markers.size(); ++markerIdx)
				{
					ledgeMarkersBuffer.InsertAt( ledgeObjectEdit.m_markers[markerIdx], currentMarkerIdx + markerIdx );
				}
				currentMarkerIdx += ledgeObject.m_markersCount;
			}

			// Write to file...

			// File version
			uint32 nFileVersion = LEDGE_DATA_FILE_VERSION;
			file.Write( &nFileVersion,sizeof(nFileVersion) );

			// Ledges and markers info
			file.Write( &totalLedgeObjectsCount, sizeof(totalLedgeObjectsCount) );
			file.Write( &totalLedgeMarkersCount, sizeof(totalLedgeMarkersCount) );

			file.Write( &ledgeObjectBuffer[0], sizeof(ledgeObjectBuffer[0]) * totalLedgeObjectsCount );
			file.Write( &ledgeMarkersBuffer.pMarkers[0], sizeof(ledgeMarkersBuffer.pMarkers[0]) * ledgeMarkersBuffer.bufferSize );

			file.Close();
		}
	}
}
	static inline bool ReadFccCodes(CCryFile& file, TFourCCSet& fccs, uint32 keyword)
	{
		uint32 fcc = 0;
		if ( file.ReadRaw(&fcc, sizeof(fcc)) != sizeof(fcc) )
			return false;
		if (fcc != keyword)
			return false;
		while (true)
		{
			if ( file.ReadRaw(&fcc, sizeof(fcc)) != sizeof(fcc) )
				return false;
			if (fcc == eBK_tags || fcc == eBK_typs)
				return false;
			if (fcc == eBK_void)
				break;
			fccs.insert(fcc);
		}
		return true;
	}
Beispiel #8
0
void CAreaProxy::ReadPolygonsForAreaSolid( CCryFile& file, int numberOfPolygons, bool bObstruction )
{
	static const int numberOfStaticVertices(200);
	Vec3 pStaticVertices[numberOfStaticVertices];

	for( int i = 0; i < numberOfPolygons; ++i )
	{
		int numberOfVertices(0);
		file.ReadType(&numberOfVertices);
		Vec3* pVertices(NULL);
		if( numberOfVertices > numberOfStaticVertices )
			pVertices = new Vec3[numberOfVertices];
		else
			pVertices = pStaticVertices;
		for( int k = 0; k < numberOfVertices; ++k )
			file.ReadType(&pVertices[k]);
		m_pArea->AddConvexHullToSolid(pVertices, bObstruction, numberOfVertices);
		if( pVertices != pStaticVertices )
			delete [] pVertices;
	}
}
void CGameVolumesManager::Load( const char* fileName )
{
	//////////////////////////////////////////////////////////////////////////
	/// Free any left data (it should be empty though...)
	Reset();

	//////////////////////////////////////////////////////////////////////////
	/// No need to load in editor
	/// The saved entities will restore the data inside the manager
	if (gEnv->IsEditor())
		return;

	CCryFile file;
	if( false != file.Open( fileName, "rb" ) )
	{
		uint32 nFileVersion = GAME_VOLUMES_FILE_VERSION;
		file.ReadType( &nFileVersion );

		// Verify version...
		if ((nFileVersion >= 1) && (nFileVersion <= GAME_VOLUMES_FILE_VERSION))
		{
			const uint32 maxVertices = 512;
			Vec3 readVertexBuffer[maxVertices];

			// Read volumes
			uint32 nVolumeCount = 0;
			file.ReadType( &nVolumeCount );

			m_volumesData.resize( nVolumeCount );

			for (uint32 i = 0; i < nVolumeCount; ++i)
			{
				EntityVolume& volumeInfo = m_volumesData[i];

				uint32 nVertexCount = 0;
				uint32 nEntityId = 0;
				f32    fHeight = 0;
				bool   bClosed = false;

				file.ReadType( &nEntityId );
				file.ReadType( &fHeight );
				if( nFileVersion > 1 )
				{
					file.ReadType( &bClosed );
				}
				file.ReadType( &nVertexCount );

				volumeInfo.entityId = (EntityId)nEntityId;
				volumeInfo.height = fHeight;
				volumeInfo.closed = bClosed;
				volumeInfo.vertices.resize( nVertexCount );
				if (nVertexCount > 0)
				{
					file.ReadType( &readVertexBuffer[0], nVertexCount );

					for (uint32 v = 0; v < nVertexCount; ++v)
					{
						volumeInfo.vertices[v] = readVertexBuffer[v];
					}
				}
			}
		}
		else
		{
			GameWarning("GameVolumesManger:Load - Failed to load file '%s'. Version mis-match, try to re-export your level", fileName);
		}

		file.Close();
	}
}
Beispiel #10
0
void CAreaProxy::SerializeXML( XmlNodeRef &entityNode,bool bLoading )
{
	if (m_nFlags & FLAG_NOT_SERIALIZE)
		return;

	if (bLoading)
	{
		XmlNodeRef areaNode = entityNode->findChild( "Area" );
		if (!areaNode)
			return;

		int nId=0,nGroup=0,nPriority=0;
		float fProximity = 0;
		float fHeight = 0;
		
		areaNode->getAttr( "Id",nId );
		areaNode->getAttr( "Group",nGroup );
		areaNode->getAttr( "Proximity",fProximity );
		areaNode->getAttr( "Priority",nPriority );
		m_pArea->SetID(nId);
		m_pArea->SetGroup(nGroup);
		m_pArea->SetProximity(fProximity);
		m_pArea->SetPriority(nPriority);
		const char* token(0);

		XmlNodeRef pointsNode = areaNode->findChild( "Points" );
		if (pointsNode)
		{
			for (int i = 0; i < pointsNode->getChildCount(); i++)
			{
				XmlNodeRef pntNode = pointsNode->getChild(i);
				Vec3 pos;
				if (pntNode->getAttr( "Pos",pos ))
					m_localPoints.push_back(pos);

				// Get sound obstruction 
				bool bObstructSound = 0;
				pntNode->getAttr("ObstructSound", bObstructSound);
				m_abObstructSound.push_back(bObstructSound);
			}
			m_pArea->SetAreaType( ENTITY_AREA_TYPE_SHAPE );

			areaNode->getAttr( "Height",fHeight );
			m_pArea->SetHeight(fHeight);
			// Set points.
			OnMove();
		}
		else if (areaNode->getAttr("SphereRadius",m_fRadius))
		{
			// Sphere.
			areaNode->getAttr("SphereCenter",m_vCenter);
			m_pArea->SetSphere( m_pEntity->GetWorldTM().TransformPoint(m_vCenter),m_fRadius );
		}
		else if (areaNode->getAttr("VolumeRadius",m_fRadius))
		{
			areaNode->getAttr("Gravity",m_fGravity);
			areaNode->getAttr("DontDisableInvisible", m_bDontDisableInvisible);

			AABB box;
			box.Reset();

			// Bezier Volume.
			pointsNode = areaNode->findChild( "BezierPoints" );
			if (pointsNode)
			{
				for (int i = 0; i < pointsNode->getChildCount(); i++)
				{
					XmlNodeRef pntNode = pointsNode->getChild(i);
					Vec3 pt;
					if (pntNode->getAttr( "Pos",pt))
					{
						m_bezierPoints.push_back(pt);
						box.Add( pt );
					}
				}
			}
			m_pArea->SetAreaType( ENTITY_AREA_TYPE_GRAVITYVOLUME );
			if (!m_pEntity->GetRenderProxy())
			{
				IEntityRenderProxyPtr pRenderProxy = crycomponent_cast<IEntityRenderProxyPtr>(m_pEntity->CreateProxy( ENTITY_PROXY_RENDER ));
				m_pEntity->SetFlags(m_pEntity->GetFlags() | ENTITY_FLAG_SEND_RENDER_EVENT);

				if (box.min.x > box.max.x)
					box.min = box.max = Vec3(0,0,0);
				box.min-=Vec3(m_fRadius, m_fRadius, m_fRadius);
				box.max+=Vec3(m_fRadius, m_fRadius, m_fRadius);

				Matrix34 tm = m_pEntity->GetWorldTM_Fast();

				box.SetTransformedAABB( m_pEntity->GetWorldTM_Fast().GetInverted(),box );

				pRenderProxy->SetLocalBounds(box, true);
			}

			OnEnable(m_bIsEnable);
		}
		else if (areaNode->getAttr("AreaSolidFileName",&token))
		{
			CCryFile file;

			int nAliasLen = sizeof("%level%")-1;
			const char* areaSolidFileName;
			if (strncmp(token,"%level%",nAliasLen) == 0)
				areaSolidFileName = GetIEntitySystem()->GetSystem()->GetI3DEngine()->GetLevelFilePath(token+nAliasLen);
			else
				areaSolidFileName = token;

			if( file.Open(areaSolidFileName,"rb") )
			{
				int numberOfClosedPolygon = 0;
				int numberOfOpenPolygon = 0;

				m_pArea->BeginSettingSolid(m_pEntity->GetWorldTM());

				file.ReadType(&numberOfClosedPolygon);
				file.ReadType(&numberOfOpenPolygon);

				ReadPolygonsForAreaSolid( file, numberOfClosedPolygon, true );
				ReadPolygonsForAreaSolid( file, numberOfOpenPolygon, false );

				m_pArea->EndSettingSolid();
			}
		}
		else
		{
			// Box.
			Vec3 bmin(0,0,0),bmax(0,0,0);
			areaNode->getAttr("BoxMin",bmin);
			areaNode->getAttr("BoxMax",bmax);
			m_pArea->SetBox( bmin,bmax,m_pEntity->GetWorldTM() );

			// Get sound obstruction
			XmlNodeRef const pNodeSoundData = areaNode->findChild("SoundData");
			if (pNodeSoundData)
			{
				assert(m_abObstructSound.size() == 0);

				for (int i = 0; i < pNodeSoundData->getChildCount(); ++i)
				{
					XmlNodeRef const pNodeSide = pNodeSoundData->getChild(i);

					if (pNodeSide)
					{
						bool bObstructSound = false;
						pNodeSide->getAttr("ObstructSound", bObstructSound);
						m_abObstructSound.push_back(bObstructSound);
					}
				}
			}

			OnMove();
		}

		m_pArea->ClearEntities();
		XmlNodeRef entitiesNode = areaNode->findChild( "Entities" );
		// Export Entities.
		if (entitiesNode)
		{
			for (int i = 0; i < entitiesNode->getChildCount(); i++)
			{
				XmlNodeRef entNode = entitiesNode->getChild(i);
				EntityId entityId;
				EntityGUID entityGuid;
				if(gEnv->pEntitySystem->EntitiesUseGUIDs())
				{
					if (entNode->getAttr( "Guid",entityGuid ))
						m_pArea->AddEntity( entityGuid );
				}
				else
				{
					if (entNode->getAttr( "Id",entityId ))
						m_pArea->AddEntity( entityId );
				}
			}
		}
	}
	else
	{
		// Save points.
		XmlNodeRef areaNode = entityNode->newChild( "Area" );
		areaNode->setAttr( "Id",m_pArea->GetID() );
		areaNode->setAttr( "Group",m_pArea->GetGroup() );
		areaNode->setAttr( "Proximity",m_pArea->GetProximity() );
		areaNode->setAttr( "Priority", m_pArea->GetPriority() );
		EEntityAreaType type = m_pArea->GetAreaType();
		if (type == ENTITY_AREA_TYPE_SHAPE)
		{
			XmlNodeRef pointsNode = areaNode->newChild( "Points" );
			for (unsigned int i = 0; i < m_localPoints.size(); i++)
			{
				XmlNodeRef pntNode = pointsNode->newChild("Point");
				pntNode->setAttr( "Pos",m_localPoints[i] );
				pntNode->setAttr("ObstructSound", m_abObstructSound[i]);
			}
			areaNode->setAttr( "Height",m_pArea->GetHeight() );
		}
		else if (type == ENTITY_AREA_TYPE_SPHERE)
		{
			// Box.
			areaNode->setAttr("SphereCenter",m_vCenter);
			areaNode->setAttr("SphereRadius",m_fRadius);
		}
		else if (type == ENTITY_AREA_TYPE_BOX)
		{
			// Box.
			Vec3 bmin,bmax;
			m_pArea->GetBox(bmin,bmax);
			areaNode->setAttr("BoxMin",bmin);
			areaNode->setAttr("BoxMax",bmax);

			// Set sound obstruction
			XmlNodeRef const pNodeSoundData = areaNode->newChild("SoundData");
			if (pNodeSoundData)
			{
				assert(m_abObstructSound.size() == 6);
				size_t nIndex = 0;
				tSoundObstructionIterConst const ItEnd = m_abObstructSound.end();
				for (tSoundObstructionIterConst It = m_abObstructSound.begin(); It != ItEnd ; ++It)
				{
					bool const bObstructed = (bool)(*It);
					stack_string sTemp;
					sTemp.Format("Side%d", ++nIndex);

					XmlNodeRef const pNodeSide = pNodeSoundData->newChild(sTemp.c_str());
					pNodeSide->setAttr("ObstructSound", bObstructed);
				}
			}
		}
		else if (type == ENTITY_AREA_TYPE_GRAVITYVOLUME)
		{
			areaNode->setAttr("VolumeRadius",m_fRadius);
			areaNode->setAttr("Gravity",m_fGravity);
			areaNode->setAttr("DontDisableInvisible", m_bDontDisableInvisible);
			XmlNodeRef pointsNode = areaNode->newChild( "BezierPoints" );
			for (unsigned int i = 0; i < m_bezierPoints.size(); i++)
			{
				XmlNodeRef pntNode = pointsNode->newChild("Point");
				pntNode->setAttr( "Pos",m_bezierPoints[i] );
			}
		}

#ifdef SW_ENTITY_ID_USE_GUID
		const std::vector<EntityGUID>& entGUIDs=*m_pArea->GetEntitiesGuid();
		// Export Entities.
		if (!entGUIDs.empty())
		{
			XmlNodeRef nodes = areaNode->newChild( "Entities" );
			for (uint32 i = 0; i < entGUIDs.size(); i++)
			{
				EntityGUID guid = entGUIDs[i];
				XmlNodeRef entNode = nodes->newChild( "Entity" );
				entNode->setAttr( "Guid",guid );
				entNode->setAttr( "Id",gEnv->pEntitySystem->GenerateEntityIdFromGuid(guid) );
			}
		}
#else
		const std::vector<EntityId>& entIDs=*m_pArea->GetEntities();
		// Export Entities.
		if (!entIDs.empty())
		{
			XmlNodeRef nodes = areaNode->newChild( "Entities" );
			for (uint32 i = 0; i < entIDs.size(); i++)
			{
				int entityId = entIDs[i];
				XmlNodeRef entNode = nodes->newChild( "Entity" );
				entNode->setAttr( "Id",entityId );
			}
		}
#endif
	}
}