Пример #1
0
mono::object CScriptbind_Entity::GetEntitiesByClass(mono::string _class)
{
	IEntityClass *pDesiredClass = gEnv->pEntitySystem->GetClassRegistry()->FindClass(ToCryString(_class));

	std::vector<EntityId> classEntities;

	IEntityItPtr pIt = gEnv->pEntitySystem->GetEntityIterator();
	pIt->MoveFirst();

	while(!pIt->IsEnd())
	{
		if(IEntity *pEntity = pIt->Next())
		{
			if(pEntity->GetClass() == pDesiredClass)
				classEntities.push_back(pEntity->GetId());
		}
	}

	if(classEntities.size()<1)
		return nullptr;

	IMonoClass *pEntityIdClass = g_pScriptSystem->GetCryBraryAssembly()->GetClass("EntityId");

	IMonoArray *pArray = CreateMonoArray(classEntities.size());

	for(auto it = classEntities.begin(); it != classEntities.end(); ++it)
		pArray->Insert(pEntityIdClass->BoxObject(&mono::entityId(*it)));

	return pArray->GetManagedObject();
}
Пример #2
0
mono::object CScriptbind_Entity::QueryAreas(EntityId id, Vec3 vPos, int maxResults, bool forceCalculation)
{
	SAreaManagerResult *pResults = new SAreaManagerResult[maxResults];

	int numResults = 0;
	gEnv->pEntitySystem->GetAreaManager()->QueryAreas(id, vPos, pResults, maxResults, numResults);

	IMonoArray *pArray = CreateDynamicMonoArray();
	IMonoClass *pClass = GetMonoScriptSystem()->GetCryBraryAssembly()->GetClass("AreaQueryResult");

	for(int i = 0; i < numResults; i++)
	{
		auto result = pResults[i];

		if(result.pArea != nullptr)
			pArray->InsertMonoObject(pClass->BoxObject(&result));
	}

	delete[] pResults;

	mono::object managedArray = pArray->GetManagedObject();
	pArray->Release(false);

	return managedArray;
}
Пример #3
0
bool CMonoFlowNode::CreatedNode(TFlowNodeId id, const char *name, TFlowNodeTypeId typeId, IFlowNodePtr pNode) 
{ 
	if(pNode==this)
	{
		const char *typeName = gEnv->pFlowSystem->GetTypeName(typeId);

		IMonoObject *pScript = g_pScriptSystem->InstantiateScript(gEnv->pFlowSystem->GetTypeName(typeId), eScriptFlag_FlowNode);

		IMonoClass *pNodeInfo = g_pScriptSystem->GetCryBraryAssembly()->GetClass("NodeInitializationParams", "CryEngine.Flowgraph.Native");
		
		IMonoArray *pArgs = CreateMonoArray(1);
		pArgs->InsertMonoObject(pNodeInfo->BoxObject(&SMonoNodeInfo(this, id, m_pActInfo->pGraph->GetGraphId())));

		mono::object result = g_pScriptSystem->InitializeScriptInstance(pScript, pArgs);
		pArgs->Release();
		
		m_pScript = pScript;
		if(result)
		{
			IMonoObject *pResult = *result;
			bool bResult = pResult->Unbox<bool>();
			SAFE_RELEASE(pResult);

			return bResult;
		}

		CryLogAlways("Failed to create node %s", gEnv->pFlowSystem->GetTypeName(typeId));
		return false;
	}

	return true; 
}
Пример #4
0
mono::object CScriptDomain::BoxAnyValue(MonoAnyValue &any)
{
	switch(any.type)
	{
	case eMonoAnyType_Boolean:
		return (mono::object)mono_value_box(m_pDomain, mono_get_boolean_class(), &any.b);
	case eMonoAnyType_Integer:
		return (mono::object)mono_value_box(m_pDomain, mono_get_int32_class(), &any.i);
	case eMonoAnyType_UnsignedInteger:
		return (mono::object)mono_value_box(m_pDomain, mono_get_uint32_class(), &any.u);
	case eMonoAnyType_Short:
		return (mono::object)mono_value_box(m_pDomain, mono_get_int16_class(), &any.i);
	case eMonoAnyType_UnsignedShort:
		return (mono::object)mono_value_box(m_pDomain, mono_get_uint16_class(), &any.u);
	case eMonoAnyType_Float:
		return (mono::object)mono_value_box(m_pDomain, mono_get_single_class(), &any.f);
	case eMonoAnyType_String:
		return (mono::object)CreateMonoString(any.str);
	case eMonoAnyType_EntityId:
		{
			IMonoClass *pEntityIdClass = g_pScriptSystem->GetCryBraryAssembly()->GetClass("EntityId");
			return pEntityIdClass->BoxObject(&mono::entityId(any.u), this);
		}
	case eMonoAnyType_Vec3:
		{
			IMonoClass *pVec3Class = g_pScriptSystem->GetCryBraryAssembly()->GetClass("Vec3");
			
			Vec3 vec3(any.vec4.x, any.vec4.y, any.vec4.z);
			return pVec3Class->BoxObject(&vec3, this);
		}
		break;
	case eMonoAnyType_Quat:
		{
			IMonoClass *pQuatClass = g_pScriptSystem->GetCryBraryAssembly()->GetClass("Quat");
			
			return pQuatClass->BoxObject(&any.vec4, this);
		}
		break;
	case eMonoAnyType_Array:
	case eMonoAnyType_Unknown:
		return any.monoObject;
	}

	return nullptr;
}
Пример #5
0
mono::object CScriptDomain::BoxAnyValue(MonoAnyValue &any)
{
	switch(any.type)
	{
	case eMonoAnyType_Boolean:
		return (mono::object)mono_value_box(m_pDomain, mono_get_boolean_class(), &any.b);
	case eMonoAnyType_Integer:
		return (mono::object)mono_value_box(m_pDomain, mono_get_int32_class(), &any.i);
	case eMonoAnyType_UnsignedInteger:
		return (mono::object)mono_value_box(m_pDomain, mono_get_uint32_class(), &any.u);
	case eMonoAnyType_EntityId:
		{
			IMonoClass *pEntityIdClass = g_pScriptSystem->GetCryBraryAssembly()->GetClass("EntityId");
			return pEntityIdClass->BoxObject(&mono::entityId(any.u), this)->GetManagedObject();
		}
	case eMonoAnyType_Short:
		return (mono::object)mono_value_box(m_pDomain, mono_get_int16_class(), &any.i);
	case eMonoAnyType_UnsignedShort:
		return (mono::object)mono_value_box(m_pDomain, mono_get_uint16_class(), &any.u);
	case eMonoAnyType_Float:
		return (mono::object)mono_value_box(m_pDomain, mono_get_single_class(), &any.f);
	case eMonoAnyType_String:
		MonoWarning("IMonoConverter::BoxAnyValue does not support strings, utilize ToMonoString instead");
	case eMonoAnyType_Vec3:
		{
			IMonoClass *pVec3Class = g_pScriptSystem->GetCryBraryAssembly()->GetClass("Vec3");
			
			Vec3 vec3(any.vec4.x, any.vec4.y, any.vec4.z);
			return pVec3Class->BoxObject(&vec3, this)->GetManagedObject();
		}
		break;
	case eMonoAnyType_Quat:
		{
			IMonoClass *pQuatClass = g_pScriptSystem->GetCryBraryAssembly()->GetClass("Quat");
			
			return pQuatClass->BoxObject(&any.vec4, this)->GetManagedObject();
		}
		break;
	}

	return nullptr;
}
Пример #6
0
int CScriptbind_Physics::RayWorldIntersection(Vec3 origin, Vec3 dir, int objFlags, unsigned int flags, int maxHits, mono::object skipEntities, mono::object &hits)
{
	IPhysicalEntity **pSkipEnts = NULL;
	int numSkipEnts = 0;

	if(skipEntities)
	{
		IMonoArray *pSkipEntities = *skipEntities;
		numSkipEnts = pSkipEntities->GetSize();

		pSkipEnts = new IPhysicalEntity*[numSkipEnts];

		for(int i = 0; i < numSkipEnts; i++)
		{
			IMonoObject *pItem = *pSkipEntities->GetItem(i);

#ifndef RELEASE
			if(!pItem)
				g_pScriptSystem->GetCryBraryAssembly()->GetException("CryEngine", "NullPointerException")->Throw();
#endif

			pSkipEnts[i] = pItem->Unbox<IPhysicalEntity *>();
			SAFE_RELEASE(pItem);
		}

		pSkipEntities->Release();
	}

	ray_hit *pHits = new ray_hit[maxHits];
	int numHits = gEnv->pPhysicalWorld->RayWorldIntersection(origin, dir, objFlags, flags, pHits, maxHits, pSkipEnts, numSkipEnts);

	SAFE_DELETE_ARRAY(pSkipEnts);

	if(numHits > 0)
	{
		IMonoClass *pRayHitClass = g_pScriptSystem->GetCryBraryAssembly()->GetClass("RaycastHit");

		IMonoArray *pRayHits = CreateMonoArray(numHits);//, pRayHitClass);
		for(int i = 0; i < numHits; i++)
			pRayHits->InsertMonoObject(pRayHitClass->BoxObject(&pHits[i]));

		hits = pRayHits->GetManagedObject();
		pRayHits->Release();
	}

	delete[] pHits;

	return numHits;
}
Пример #7
0
bool CFlowNode::CreatedNode(TFlowNodeId id, const char *name, TFlowNodeTypeId typeId, IFlowNodePtr pNode) 
{ 
	if(pNode==this)
	{
		IMonoObject *pScript = g_pScriptSystem->InstantiateScript(gEnv->pFlowSystem->GetTypeName(typeId), eScriptFlag_FlowNode);

		IMonoClass *pNodeInfo = g_pScriptSystem->GetCryBraryAssembly()->GetClass("NodeInfo", "CryEngine.FlowSystem.Native");
		pScript->CallMethod("InternalInitialize", pNodeInfo->BoxObject(&SMonoNodeInfo(this, id, m_pActInfo->pGraph->GetGraphId())));

		m_pScript = pScript;

		return pScript != nullptr;
	}

	return true; 
}
Пример #8
0
mono::object CScriptbind_Entity::GetEntitiesInBox(AABB bbox, int objTypes)
{
	IPhysicalEntity **pEnts = nullptr;

	IMonoClass *pEntityIdClass = GetMonoScriptSystem()->GetCryBraryAssembly()->GetClass("EntityId");

	int numEnts = gEnv->pPhysicalWorld->GetEntitiesInBox(bbox.min, bbox.max, pEnts, objTypes);
	
	IMonoArray *pEntities = CreateDynamicMonoArray();

	for(int i = 0; i < numEnts; i++)
		pEntities->InsertMonoObject(pEntityIdClass->BoxObject(&mono::entityId(gEnv->pPhysicalWorld->GetPhysicalEntityId(pEnts[i]))));

	auto result = pEntities->GetManagedObject();
	pEntities->Release();

	return result;
}
Пример #9
0
mono::object CScriptbind_Entity::GetEntitiesInBox(AABB bbox, int objTypes)
{
	IPhysicalEntity **pEnts = nullptr;

	IMonoClass *pEntityIdClass = g_pScriptSystem->GetCryBraryAssembly()->GetClass("EntityId");

	int numEnts = gEnv->pPhysicalWorld->GetEntitiesInBox(bbox.min, bbox.max, pEnts, objTypes);
	
	if(numEnts > 0)
		{
		IMonoArray *pEntities = CreateMonoArray(numEnts);

		for(int i = 0; i < numEnts; i++)
			pEntities->Insert(pEntityIdClass->BoxObject(&mono::entityId(gEnv->pPhysicalWorld->GetPhysicalEntityId(pEnts[i]))));

		return pEntities->GetManagedObject();
	}

	return nullptr;
}
Пример #10
0
bool CMonoEntityExtension::Init(IGameObject *pGameObject)
{
	SetGameObject(pGameObject);

	pGameObject->EnablePhysicsEvent( true, eEPE_OnPostStepImmediate );

	if (!GetGameObject()->BindToNetwork())
		return false;

	IEntity *pEntity = GetEntity();
	IEntityClass *pEntityClass = pEntity->GetClass();

	m_pScript = g_pScriptSystem->InstantiateScript(pEntityClass->GetName(), eScriptFlag_Entity);

	IMonoClass *pEntityInfoClass = g_pScriptSystem->GetCryBraryAssembly()->GetClass("EntityInitializationParams", "CryEngine.Native");

	SMonoEntityInfo entityInfo(pEntity);

	IMonoArray *pArgs = CreateMonoArray(1);
	pArgs->InsertMonoObject(pEntityInfoClass->BoxObject(&entityInfo));

	g_pScriptSystem->InitializeScriptInstance(m_pScript, pArgs);
	pArgs->Release();

	int numProperties;
	auto pProperties = static_cast<CEntityPropertyHandler *>(pEntityClass->GetPropertyHandler())->GetQueuedProperties(pEntity->GetId(), numProperties);

	if(pProperties)
	{
		for(int i = 0; i < numProperties; i++)
		{
			auto queuedProperty = pProperties[i];

			SetPropertyValue(queuedProperty.propertyInfo, queuedProperty.value.c_str());
		}
	}

	m_bInitialized = true;

	return true;
}
Пример #11
0
void CActorSystem::OnSpawn(IEntity *pEntity,SEntitySpawnParams &params)
{
	EMonoActorType actorType = GetMonoActorType(pEntity->GetClass()->GetName());

	if(actorType != EMonoActorType_None)
	{
		if(IActor *pActor = gEnv->pGameFramework->GetIActorSystem()->GetActor(pEntity->GetId()))
		{
			IMonoObject *pScript  = g_pScriptSystem->InstantiateScript(pEntity->GetClass()->GetName(), eScriptFlag_Actor);

			IMonoClass *pActorInfoClass = g_pScriptSystem->GetCryBraryAssembly()->GetClass("ActorInfo");

			SMonoActorInfo actorInfo(pActor);

			pScript->CallMethod("InternalSpawn", pActorInfoClass->BoxObject(&actorInfo));

			if(actorType == EMonoActorType_Managed)
				static_cast<CActor *>(pActor)->SetScript(pScript);
		}
	}
}
Пример #12
0
ICryScriptInstance *CScriptSystem::InstantiateScript(const char *scriptName, EMonoScriptFlags scriptFlags, IMonoArray *pConstructorParameters, bool throwOnFail)
{
	FUNCTION_PROFILER_FAST(GetISystem(), PROFILE_SCRIPT, gEnv->bProfilerEnabled);

	auto *pInstance = new CCryScriptInstance(scriptFlags);

	IMonoArray *pScriptCreationArgs = CreateMonoArray(5);
	pScriptCreationArgs->Insert(scriptName);
	pScriptCreationArgs->Insert(scriptFlags);
	pScriptCreationArgs->InsertNativePointer(pInstance);
	pScriptCreationArgs->InsertMonoObject((pConstructorParameters != nullptr ? pConstructorParameters->GetManagedObject() : nullptr));
	pScriptCreationArgs->Insert(throwOnFail);

	auto result = m_pScriptManager->GetClass()->GetMethod("CreateScriptInstance", 5)->InvokeArray(m_pScriptManager->GetManagedObject(), pScriptCreationArgs);
	SAFE_RELEASE(pScriptCreationArgs);

	if(!result)
		return nullptr;
	
	pInstance->SetManagedObject((MonoObject *)result, true);

	if(scriptFlags & eScriptFlag_GameRules)
	{
		IMonoClass *pGameRulesInitParamsClass = m_pCryBraryAssembly->GetClass("GameRulesInitializationParams");

		IMonoArray *pArgs = CreateMonoArray(1);

		SGameRulesInitializationParams params;
		pArgs->InsertMonoObject(pGameRulesInitParamsClass->BoxObject(&params));

		InitializeScriptInstance(pInstance, pArgs);
		SAFE_RELEASE(pArgs);
	}

	for each(auto listener in m_listeners)
		listener->OnScriptInstanceCreated(scriptName, scriptFlags, pInstance);

	return pInstance;
}
Пример #13
0
void CScriptbind_ActorSystem::OnSpawn(IEntity *pEntity,SEntitySpawnParams &params)
{
	EMonoActorType actorType = GetMonoActorType(pEntity->GetClass()->GetName());

	if(actorType != EMonoActorType_None)
	{
		if(IActor *pActor = static_cast<CScriptSystem *>(GetMonoScriptSystem())->GetIGameFramework()->GetIActorSystem()->GetActor(pEntity->GetId()))
		{
			ICryScriptInstance *pScript  = GetMonoScriptSystem()->InstantiateScript(pEntity->GetClass()->GetName(), eScriptFlag_Actor);

			IMonoClass *pActorInfoClass = GetMonoScriptSystem()->GetCryBraryAssembly()->GetClass("ActorInitializationParams", "CryEngine.Native");

			SMonoActorInfo actorInfo(pActor);

			IMonoArray *pArgs = CreateMonoArray(1);
			pArgs->InsertMonoObject(pActorInfoClass->BoxObject(&actorInfo));

			static_cast<CScriptSystem *>(GetMonoScriptSystem())->InitializeScriptInstance(pScript, pArgs);
			SAFE_RELEASE(pArgs);
		}
	}
}
Пример #14
0
mono::object CScriptbind_Entity::QueryProximity(AABB box, mono::string className, uint32 nEntityFlags)
{
	SEntityProximityQuery query;

	if(className != nullptr)
		query.pEntityClass = gEnv->pEntitySystem->GetClassRegistry()->FindClass(ToCryString(className));

	query.box = box;
	query.nEntityFlags = nEntityFlags;

	gEnv->pEntitySystem->QueryProximity(query);

	IMonoClass *pEntityIdClass = GetMonoScriptSystem()->GetCryBraryAssembly()->GetClass("EntityId");
	IMonoArray *pEntities = CreateDynamicMonoArray();

	for(int i = 0; i < query.nCount; i++)
		pEntities->InsertMonoObject(pEntityIdClass->BoxObject(&mono::entityId(query.pEntities[i]->GetId())));

	auto result = pEntities->GetManagedObject();
	pEntities->Release();

	return result;
}
Пример #15
0
mono::object CScriptbind_Entity::GetEntitiesByClasses(mono::object classes)
{
	IMonoArray *pClassArray = *classes;

	int numClasses = pClassArray->GetSize();
	IEntityClass **pClasses = new IEntityClass *[numClasses];
	for(int i = 0; i < numClasses; i++)
		pClasses[i] = gEnv->pEntitySystem->GetClassRegistry()->FindClass(ToCryString((mono::string)pClassArray->GetManagedObject()));

	IEntityItPtr pIt = gEnv->pEntitySystem->GetEntityIterator();

	IMonoClass *pEntityIdClass = GetMonoScriptSystem()->GetCryBraryAssembly()->GetClass("EntityId");
	IMonoArray *pEntities = CreateDynamicMonoArray();
	
	pIt->MoveFirst();
	while(!pIt->IsEnd())
	{
		if(IEntity *pEntity = pIt->Next())
		{
			IEntityClass *pEntityClass = pEntity->GetClass();
			for(int i = 0; i < numClasses; i++)
			{
				if(pEntityClass == pClasses[i])
				{
					pEntities->InsertMonoObject(pEntityIdClass->BoxObject(&mono::entityId(pEntity->GetId())));
					break;
				}
			}
		}
	}

	auto result = pEntities->GetManagedObject();
	pEntities->Release();

	return result;
}
Пример #16
0
mono::object CScriptbind_Entity::GetEntitiesByClass(mono::string _class)
{
	IEntityClass *pDesiredClass = gEnv->pEntitySystem->GetClassRegistry()->FindClass(ToCryString(_class));

	IEntityItPtr pIt = gEnv->pEntitySystem->GetEntityIterator();

	IMonoClass *pEntityIdClass = GetMonoScriptSystem()->GetCryBraryAssembly()->GetClass("EntityId");
	IMonoArray *pEntities = CreateDynamicMonoArray();

	pIt->MoveFirst();
	while(!pIt->IsEnd())
	{
		if(IEntity *pEntity = pIt->Next())
		{
			if(pEntity->GetClass() == pDesiredClass)
				pEntities->InsertMonoObject(pEntityIdClass->BoxObject(&mono::entityId(pEntity->GetId())));
		}
	}

	auto result = pEntities->GetManagedObject();
	pEntities->Release();

	return result;
}
Пример #17
0
void CEntityEventHandler::HandleEntityEvent(EEntityType type, SEntityEvent &event, IEntity *pEntity, mono::object managedObject)
{
	switch(event.event)
	{
	case ENTITY_EVENT_RESET:
		{
			bool enterGamemode = event.nParam[0]==1;

			if(!enterGamemode && pEntity->GetFlags() & ENTITY_FLAG_NO_SAVE)
			{
				gEnv->pEntitySystem->RemoveEntity(pEntity->GetId());
				return;
			}

			IMonoArray *pParams = CreateMonoArray(1);
			pParams->Insert(enterGamemode);
			m_pClass[type]->GetMethod("OnEditorReset", 1)->InvokeArray(managedObject, pParams);

			SAFE_RELEASE(pParams);
		}
		break;
	case ENTITY_EVENT_COLLISION:
		{
			EventPhysCollision *pCollision = (EventPhysCollision *)event.nParam[0];

			SMonoColliderInfo source = SMonoColliderInfo(pCollision, 0);
			SMonoColliderInfo target = SMonoColliderInfo(pCollision, 1);

			IMonoClass *pColliderInfoClass = g_pScriptSystem->GetCryBraryAssembly()->GetClass("ColliderInfo");

			IMonoArray *pArgs = CreateMonoArray(6);

			pArgs->InsertMonoObject(pColliderInfoClass->BoxObject(&source));
			pArgs->InsertMonoObject(pColliderInfoClass->BoxObject(&target));

			pArgs->Insert(pCollision->pt);
			pArgs->Insert(pCollision->n);

			pArgs->Insert(pCollision->penetration);
			pArgs->Insert(pCollision->radius);

			m_pClass[type]->GetMethod("OnCollision", 6)->InvokeArray(managedObject, pArgs);
			SAFE_RELEASE(pArgs);
		}
		break;
	case ENTITY_EVENT_START_GAME:
		m_pClass[type]->GetMethod("OnStartGame")->Invoke(managedObject);
		break;
	case ENTITY_EVENT_START_LEVEL:
		m_pClass[type]->GetMethod("OnStartLevel")->Invoke(managedObject);
		break;
	case ENTITY_EVENT_LEVEL_LOADED:
		m_pClass[type]->GetMethod("OnLevelLoaded")->Invoke(managedObject);
		break;
	case ENTITY_EVENT_ENTERAREA:
		m_pClass[type]->GetMethod("OnEnterArea", 3)->Call(managedObject, (EntityId)event.nParam[0], (int)event.nParam[1], (EntityId)event.nParam[2]);
		break;
	case ENTITY_EVENT_MOVEINSIDEAREA:
		m_pClass[type]->GetMethod("OnMoveInsideArea", 3)->Call(managedObject, (EntityId)event.nParam[0], (int)event.nParam[1], (EntityId)event.nParam[2]);
		break;
	case ENTITY_EVENT_LEAVEAREA:
		m_pClass[type]->GetMethod("OnLeaveArea", 3)->Call(managedObject, (EntityId)event.nParam[0], (int)event.nParam[1], (EntityId)event.nParam[2]);
		break;
	case ENTITY_EVENT_ENTERNEARAREA:
		m_pClass[type]->GetMethod("OnEnterNearArea", 3)->Call(managedObject, (EntityId)event.nParam[0], (int)event.nParam[1], (EntityId)event.nParam[2]);
		break;
	case ENTITY_EVENT_MOVENEARAREA:
		m_pClass[type]->GetMethod("OnMoveNearArea", 4)->Call(managedObject, (EntityId)event.nParam[0], (int)event.nParam[1], (EntityId)event.nParam[2], event.fParam[0]);
		break;
	case ENTITY_EVENT_LEAVENEARAREA:
		m_pClass[type]->GetMethod("OnLeaveNearArea", 3)->Call(managedObject, (EntityId)event.nParam[0], (int)event.nParam[1], (EntityId)event.nParam[2]);
		break;
	case ENTITY_EVENT_XFORM:
		m_pClass[type]->GetMethod("OnMove", 1)->Call(managedObject, (EEntityXFormFlags)event.nParam[0]);
		break;
	case ENTITY_EVENT_ATTACH:
		m_pClass[type]->GetMethod("OnAttach", 1)->Call(managedObject, (EntityId)event.nParam[0]);
		break;
	case ENTITY_EVENT_DETACH:
		m_pClass[type]->GetMethod("OnDetach", 1)->Call(managedObject, (EntityId)event.nParam[0]);
		break;
	case ENTITY_EVENT_DETACH_THIS:
		m_pClass[type]->GetMethod("OnDetachThis", 1)->Call(managedObject, (EntityId)event.nParam[0]);
		break;
	case ENTITY_EVENT_ANIM_EVENT:
		{
			const AnimEventInstance* pAnimEvent = reinterpret_cast<const AnimEventInstance*>(event.nParam[0]);
			ICharacterInstance* pCharacter = reinterpret_cast<ICharacterInstance*>(event.nParam[1]);

			IMonoClass *pAnimationEventClass = g_pScriptSystem->GetCryBraryAssembly()->GetClass("AnimationEvent");

			SMonoAnimationEvent animEvent(pAnimEvent);

			IMonoArray *pArgs = CreateMonoArray(1);

			pArgs->InsertMonoObject(pAnimationEventClass->BoxObject(&animEvent));

			m_pClass[type]->GetMethod("OnAnimEvent", 1)->InvokeArray(managedObject, pArgs);
			SAFE_RELEASE(pArgs);
		}
		break;
	case ENTITY_EVENT_PREPHYSICSUPDATE:
		{
			m_pClass[type]->GetMethod("OnPrePhysicsUpdate")->Invoke(managedObject);
		}
		break;
	}
}