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;
}
void CScriptbind_Console::OnMonoCmd(IConsoleCmdArgs *cmdArgs)
{
IMonoArray *pArgs = CreateMonoArray(1);
pArgs->Insert(cmdArgs->GetCommandLine());
g_pScriptSystem->GetCryBraryAssembly()->GetClass("ConsoleCommand")->InvokeArray(NULL, "OnCommand", pArgs);
}
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();
}
CMonoFlowNode::~CMonoFlowNode()
{
IMonoClass *pFlowNodeClass = g_pScriptSystem->GetCryBraryAssembly()->GetClass("FlowNode", "CryEngine.Flowgraph");
IMonoArray *pParams = CreateMonoArray(1);
pParams->Insert(m_scriptId);
pFlowNodeClass->InvokeArray(nullptr, "InternalRemove", pParams);
}
void CMonoActor::FullSerialize(TSerialize ser)
{
ser.BeginGroup("ManagedActor");
IMonoArray *pArgs = CreateMonoArray(1);
pArgs->InsertNativePointer(&ser);
m_pScript->GetClass()->InvokeArray(m_pScript, "InternalFullSerialize", pArgs);
ser.EndGroup();
}
void CInput::OnHardwareMouseEvent(int iX,int iY,EHARDWAREMOUSEEVENT eHardwareMouseEvent, int wheelDelta)
{
IMonoArray *pParams = CreateMonoArray(4);
pParams->Insert(iX);
pParams->Insert(iY);
pParams->Insert(eHardwareMouseEvent);
pParams->Insert(wheelDelta);
GetClass()->InvokeArray(NULL, "OnMouseEvent", pParams);
SAFE_RELEASE(pParams);
}
bool CInput::OnInputEvent(const SInputEvent &event)
{
IMonoArray *pParams = CreateMonoArray(2);
pParams->Insert(event.keyName.c_str());
pParams->Insert(event.value);
GetClass()->InvokeArray(NULL, "OnKeyEvent", pParams);
SAFE_RELEASE(pParams);
return false;
}
void CScriptbind_Input::OnHardwareMouseEvent(int iX,int iY,EHARDWAREMOUSEEVENT eHardwareMouseEvent, int wheelDelta)
{
IMonoArray *pParams = CreateMonoArray(4);
pParams->Insert(iX);
pParams->Insert(iY);
pParams->Insert(eHardwareMouseEvent);
pParams->Insert(wheelDelta);
IMonoClass *pInputClass = g_pScriptSystem->GetCryBraryAssembly()->GetClass("Input", "CryEngine");
pInputClass->GetMethod("OnMouseEvent", 4)->InvokeArray(NULL, pParams);
SAFE_RELEASE(pParams);
}
bool CScriptbind_Input::OnInputEvent(const SInputEvent &event)
{
IMonoArray *pParams = CreateMonoArray(2);
pParams->Insert(event.keyName.c_str());
pParams->Insert(event.value);
IMonoClass *pInputClass = g_pScriptSystem->GetCryBraryAssembly()->GetClass("Input", "CryEngine");
pInputClass->GetMethod("OnKeyEvent", 2)->InvokeArray(NULL, pParams);
SAFE_RELEASE(pParams);
return false;
}
bool CInput::OnActionTriggered(EntityId entityId, const ActionId& actionId, int activationMode, float value)
{
IMonoArray *pParams = CreateMonoArray(3);
pParams->Insert(actionId.c_str());
pParams->Insert(activationMode);
pParams->Insert(value);
GetClass()->InvokeArray(NULL, "OnActionTriggered", pParams);
SAFE_RELEASE(pParams);
return false;
}
bool CScriptbind_Input::OnActionTriggered(EntityId entityId, const ActionId& actionId, int activationMode, float value)
{
IMonoArray *pParams = CreateMonoArray(3);
pParams->Insert(actionId.c_str());
pParams->Insert(activationMode);
pParams->Insert(value);
IMonoClass *pInputClass = g_pScriptSystem->GetCryBraryAssembly()->GetClass("Input", "CryEngine");
pInputClass->GetMethod("OnActionTriggered", 3)->InvokeArray(NULL, pParams);
SAFE_RELEASE(pParams);
return false;
}
IMPLEMENT_RMI(CMonoActor, ClScriptRMI)
{
IMonoClass *pActorClass = g_pScriptSystem->GetCryBraryAssembly()->GetClass("Entity");
IMonoArray *pNetworkArgs = CreateMonoArray(3);
pNetworkArgs->Insert(ToMonoString(params.methodName.c_str()));
pNetworkArgs->Insert(params.pArgs);
pNetworkArgs->Insert(params.targetId);
pActorClass->InvokeArray(nullptr, "OnRemoteInvocation", pNetworkArgs);
return true;
}
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(¶ms));
InitializeScriptInstance(pInstance, pArgs);
SAFE_RELEASE(pArgs);
}
for each(auto listener in m_listeners)
listener->OnScriptInstanceCreated(scriptName, scriptFlags, pInstance);
return pInstance;
}
IMPLEMENT_RMI(CMonoEntityExtension, SvScriptRMI)
{
IMonoClass *pEntityClass = g_pScriptSystem->GetCryBraryAssembly()->GetClass("Entity");
IMonoArray *pNetworkArgs = CreateMonoArray(3);
pNetworkArgs->Insert(ToMonoString(params.methodName.c_str()));
pNetworkArgs->InsertMonoObject(params.args);
pNetworkArgs->Insert(params.targetId);
pEntityClass->InvokeArray(nullptr, "OnRemoteInvocation", pNetworkArgs);
pNetworkArgs->Release();
return true;
}
void CScriptSystem::OnPostUpdate(float fDeltaTime)
{
FUNCTION_PROFILER_FAST(GetISystem(), PROFILE_SCRIPT, gEnv->bProfilerEnabled);
IMonoArray *pArgs = CreateMonoArray(5);
pArgs->Insert(fDeltaTime);
pArgs->Insert(gEnv->pTimer->GetFrameStartTime().GetMilliSeconds());
pArgs->Insert(gEnv->pTimer->GetAsyncTime().GetMilliSeconds());
pArgs->Insert(gEnv->pTimer->GetFrameRate());
pArgs->Insert(gEnv->pTimer->GetTimeScale());
// Updates all scripts and sets Time.FrameTime.
m_pScriptManager->CallMethod("OnUpdate", fDeltaTime, gEnv->pTimer->GetFrameStartTime().GetMilliSeconds(), gEnv->pTimer->GetAsyncTime().GetMilliSeconds(), gEnv->pTimer->GetFrameRate(), gEnv->pTimer->GetTimeScale());
}
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;
}
IMonoAssembly *CScriptDomain::LoadAssembly(const char *file, bool shadowCopy, bool convertPdbToMdb)
{
const char *path;
if(shadowCopy)
path = GetTempPath().append(PathUtil::GetFile(file));
else
path = file;
for each(auto assembly in m_assemblies)
{
if(!strcmp(path, assembly->GetPath()))
return assembly;
}
if(shadowCopy)
CopyFile(file, path, false);
string sAssemblyPath(path);
#ifndef _RELEASE
if(g_pMonoCVars->mono_generateMdbIfPdbIsPresent != 0 && convertPdbToMdb && sAssemblyPath.find("pdb2mdb")==-1)
{
if (IMonoAssembly *pDebugDatabaseCreator = static_cast<CScriptSystem *>(GetMonoScriptSystem())->GetDebugDatabaseCreator())
{
if(IMonoClass *pDriverClass = pDebugDatabaseCreator->GetClass("Driver", ""))
{
if(IMonoMethod *pConvertMethod = pDriverClass->GetMethod("Convert", 1))
{
IMonoArray *pArgs = CreateMonoArray(1);
pArgs->Insert(path);
pConvertMethod->InvokeArray(nullptr, pArgs);
SAFE_RELEASE(pArgs);
}
}
}
}
#endif
if(MonoAssembly *pMonoAssembly = mono_domain_assembly_open(m_pDomain, path))
{
CScriptAssembly *pAssembly = new CScriptAssembly(this, mono_assembly_get_image(pMonoAssembly), path);
m_assemblies.push_back(pAssembly);
return pAssembly;
}
return nullptr;
}
mono::object CScriptbind_Physics::SimulateExplosion(pe_explosion explosion)
{
gEnv->pPhysicalWorld->SimulateExplosion(&explosion);
if(explosion.nAffectedEnts > 0)
{
IMonoArray *pAffectedEnts = CreateMonoArray(explosion.nAffectedEnts);
for(int i = 0; i < explosion.nAffectedEnts; i++)
pAffectedEnts->InsertNativePointer(explosion.pAffectedEnts[i]);
pAffectedEnts->Release();
return pAffectedEnts->GetManagedObject();
}
return NULL;
}
bool CScriptbind_Entity::OnRemove(IEntity *pIEntity)
{
if(IMonoClass *pEntityClass = g_pScriptSystem->GetCryBraryAssembly()->GetClass("Entity"))
{
IMonoArray *pArgs = CreateMonoArray(1);
pArgs->Insert(pIEntity->GetId());
auto result = pEntityClass->InvokeArray(NULL, "InternalRemove", pArgs)->Unbox<bool>();
SAFE_RELEASE(pArgs);
if(!result)
return false;
}
return true;
}
bool CScriptbind_Entity::OnRemove(IEntity *pIEntity)
{
if(m_pEntityClass == nullptr)
return true;
IMonoArray *pArgs = CreateMonoArray(1);
pArgs->Insert(pIEntity->GetId());
IMonoObject *pResult = *m_pEntityClass->GetMethod("InternalRemove", 1)->InvokeArray(NULL, pArgs);
auto result = pResult->Unbox<bool>();
SAFE_RELEASE(pArgs);
SAFE_RELEASE(pResult);
return result;
return true;
}
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;
}
void CCryScriptInstance::OnReloadComplete()
{
if(m_scriptId == 0)
return;
IMonoObject *pScriptManager = g_pScriptSystem->GetScriptManager();
IMonoArray *pArgs = CreateMonoArray(2);
pArgs->Insert(m_scriptId);
pArgs->Insert(m_flags);
if(mono::object result = pScriptManager->GetClass()->InvokeArray(pScriptManager->GetManagedObject(), "GetScriptInstanceById", pArgs))
{
SetManagedObject((MonoObject *)result, true);
}
else
MonoWarning("Failed to locate script instance %i after reload!", m_scriptId);
pArgs->Release();
}
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;
}
IMonoAssembly *CScriptDomain::LoadAssembly(const char *file, bool shadowCopy, bool convertPdbToMdb)
{
const char *path;
if(shadowCopy)
path = GetTempPath().append(PathUtil::GetFile(file));
else
path = file;
for each(auto assembly in m_assemblies)
{
if(!strcmp(path, assembly->GetPath()))
return assembly;
}
if(shadowCopy)
CopyFile(file, path, false);
string sAssemblyPath(path);
#ifndef _RELEASE
if(convertPdbToMdb && sAssemblyPath.find("pdb2mdb")==-1)
{
if(IMonoAssembly *pDebugDatabaseCreator = g_pScriptSystem->GetDebugDatabaseCreator())
{
if(IMonoClass *pDriverClass = pDebugDatabaseCreator->GetClass("Driver", ""))
{
IMonoArray *pArgs = CreateMonoArray(1);
pArgs->Insert(path);
pDriverClass->InvokeArray(NULL, "Convert", pArgs);
SAFE_RELEASE(pArgs);
}
}
}
#endif
MonoAssembly *pMonoAssembly = mono_domain_assembly_open(m_pDomain, path);
CRY_ASSERT(pMonoAssembly);
CScriptAssembly *pAssembly = new CScriptAssembly(this, mono_assembly_get_image(pMonoAssembly), path);
m_assemblies.push_back(pAssembly);
return pAssembly;
}
void CMonoEntityExtension::FullSerialize(TSerialize ser)
{
IEntity *pEntity = GetEntity();
ser.BeginGroup("Properties");
auto pPropertyHandler = static_cast<CEntityPropertyHandler *>(pEntity->GetClass()->GetPropertyHandler());
for(int i = 0; i < pPropertyHandler->GetPropertyCount(); i++)
{
if(ser.IsWriting())
{
IEntityPropertyHandler::SPropertyInfo propertyInfo;
pPropertyHandler->GetPropertyInfo(i, propertyInfo);
ser.Value(propertyInfo.name, pPropertyHandler->GetProperty(pEntity, i));
}
else
{
IEntityPropertyHandler::SPropertyInfo propertyInfo;
pPropertyHandler->GetPropertyInfo(i, propertyInfo);
char *propertyValue = nullptr;
ser.ValueChar(propertyInfo.name, propertyValue, 0);
pPropertyHandler->SetProperty(pEntity, i, propertyValue);
}
}
ser.EndGroup();
ser.BeginGroup("ManagedEntity");
IMonoArray *pArgs = CreateMonoArray(1);
pArgs->InsertNativePointer(&ser);
m_pScript->GetClass()->InvokeArray(m_pScript->GetManagedObject(), "InternalFullSerialize", pArgs);
pArgs->Release();
ser.EndGroup();
}
void CScriptbind_ActorSystem::OnSpawn(IEntity *pEntity,SEntitySpawnParams ¶ms)
{
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);
}
}
}
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 = g_pScriptSystem->GetCryBraryAssembly()->GetClass("EntityId");
if(query.nCount > 0)
{
IMonoArray *pEntities = CreateMonoArray(query.nCount);
for(int i = 0; i < query.nCount; i++)
pEntities->Insert(pEntityIdClass->BoxObject(&mono::entityId(query.pEntities[i]->GetId())));
return pEntities->GetManagedObject();
}
return nullptr;
}
bool CScriptSystem::Reload()
{
if((!m_bFirstReload && g_pMonoCVars->mono_realtimeScripting == 0) || m_bReloading)
return false;
m_bReloading = true;
if(!m_bFirstReload)
{
for each(auto listener in m_listeners)
listener->OnReloadStart();
m_pScriptManager->CallMethod("Serialize");
}
IMonoDomain *pScriptDomain = CreateDomain("ScriptDomain", nullptr, true);
IMonoAssembly *pCryBraryAssembly = pScriptDomain->LoadAssembly(PathUtils::GetBinaryPath() + "CryBrary.dll");
IMonoArray *pCtorParams = CreateMonoArray(2);
pCtorParams->InsertAny(m_bFirstReload);
pCtorParams->InsertMonoString(ToMonoString(PathUtils::GetConfigPath()));
IMonoObject *pScriptManager = *pCryBraryAssembly->GetClass("ScriptManager", "CryEngine.Initialization")->CreateInstance(pCtorParams);
SAFE_RELEASE(pCtorParams);
auto result = pScriptManager->CallMethod("Initialize", m_bFirstReload);
if(result == nullptr)
return false;
IMonoObject *pResult = *result;
auto reloadResult = pResult->Unbox<EScriptReloadResult>();
SAFE_RELEASE(pResult);
switch(reloadResult)
{
case EScriptReloadResult_Success:
{
// revert previous domain
if(!m_bFirstReload)
m_pScriptDomain->Release();
m_pScriptDomain = pScriptDomain;
m_pScriptManager = pScriptManager;
m_pCryBraryAssembly = pCryBraryAssembly;
CacheManagedResources();
if(!m_bFirstReload)
m_pScriptManager->CallMethod("Deserialize");
// Set Network.Editor etc.
IMonoClass *pClass = m_pCryBraryAssembly->GetClass("Game");
IMonoArray *pArgs = CreateMonoArray(2);
pArgs->Insert(gEnv->IsEditor());
pArgs->Insert(gEnv->IsDedicated());
pClass->GetMethod("InitializeGameStatics", 2)->InvokeArray(nullptr, pArgs);
SAFE_RELEASE(pArgs);
m_pScriptManager->CallMethod("ProcessWaitingScripts", m_bFirstReload);
for each(auto listener in m_listeners)
listener->OnReloadComplete();
if(!m_bFirstReload && gEnv->IsEditor())
gEnv->pFlowSystem->ReloadAllNodeTypes();
m_bReloading = false;
m_bDetectedChanges = false;
return true;
}
break;
case EScriptReloadResult_Retry:
{
m_bReloading = false;
return Reload();
}
case EScriptReloadResult_Revert:
{
pScriptDomain->Release();
m_pScriptDomain->SetActive();
m_bReloading = false;
m_bDetectedChanges = false;
return false;
}
break;
case EScriptReloadResult_Abort:
{
gEnv->pSystem->Quit();
m_bReloading = false;
}
break;
}
return false;
}
void CMonoFlowNode::ProcessEvent(EFlowEvent event, SActivationInfo *pActInfo)
{
m_pActInfo = pActInfo;
if(m_pHookedGraph && m_pScript != nullptr)
{
m_pHookedGraph->UnregisterHook(this);
m_pHookedGraph = nullptr;
}
switch(event)
{
case eFE_Activate:
{
IFlowNodeData *pNodeData = pActInfo->pGraph->GetNodeData(pActInfo->myID);
if(!pNodeData)
return;
int numInputPorts = pNodeData->GetNumInputPorts();
if(m_flags & EFLN_TARGET_ENTITY)
numInputPorts--; // last input is the entity port.
for(int i = 0; i < numInputPorts; i++)
{
if(IsPortActive(i))
{
switch(GetPortType(pActInfo, i))
{
case eFDT_Void:
m_pScript->CallMethod("OnPortActivated", i);
break;
case eFDT_Int:
m_pScript->CallMethod("OnPortActivated", i, CFlowBaseNodeInternal::GetPortInt(pActInfo, i));
break;
case eFDT_Float:
m_pScript->CallMethod("OnPortActivated", i, CFlowBaseNodeInternal::GetPortFloat(pActInfo, i));
break;
case eFDT_EntityId:
m_pScript->CallMethod("OnPortActivated", i, CFlowBaseNodeInternal::GetPortEntityId(pActInfo, i));
break;
case eFDT_Vec3:
m_pScript->CallMethod("OnPortActivated", i, CFlowBaseNodeInternal::GetPortVec3(pActInfo, i));
break;
case eFDT_String:
m_pScript->CallMethod("OnPortActivated", i, CFlowBaseNodeInternal::GetPortString(pActInfo, i));
break;
case eFDT_Bool:
m_pScript->CallMethod("OnPortActivated", i, CFlowBaseNodeInternal::GetPortBool(pActInfo, i));
break;
default:
break;
}
}
}
}
break;
case eFE_Initialize:
m_pScript->CallMethod("OnInit");
break;
case eFE_SetEntityId:
{
if(pActInfo->pEntity)
{
IMonoArray *pParams = CreateMonoArray(2);
pParams->InsertNativePointer(pActInfo->pEntity);
pParams->Insert(pActInfo->pEntity->GetId());
m_pScript->GetClass()->GetMethod("InternalSetTargetEntity", 2)->InvokeArray(m_pScript->GetManagedObject(), pParams);
pParams->Release();
}
}
break;
case eFE_Update:
m_pScript->CallMethod("OnNodeUpdate");
break;
}
}
bool CMonoActor::NetSerialize( TSerialize ser, EEntityAspects aspect, uint8 profile, int pflags )
{
if (aspect == eEA_Physics)
{
pe_type type = PE_NONE;
switch (profile)
{
case eAP_NotPhysicalized:
type = PE_NONE;
break;
case eAP_Spectator:
type = PE_LIVING;
break;
case eAP_Alive:
type = PE_LIVING;
break;
case eAP_Sleep:
type = PE_ARTICULATED;
break;
case eAP_Frozen:
type = PE_RIGID;
break;
case eAP_Ragdoll:
type = PE_ARTICULATED;
break;
case eAP_Linked: //if actor is attached to a vehicle - don't serialize actor physics additionally
return true;
break;
default:
return false;
}
// TODO: remove this when craig fixes it in the network system
if (profile==eAP_Spectator)
{
int x=0;
ser.Value("unused", x, 'skip');
}
else if (profile==eAP_Sleep)
{
int x=0;
ser.Value("unused1", x, 'skip');
ser.Value("unused2", x, 'skip');
}
if (type == PE_NONE)
return true;
IEntityPhysicalProxy * pEPP = (IEntityPhysicalProxy *) GetEntity()->GetProxy(ENTITY_PROXY_PHYSICS);
if (ser.IsWriting())
{
if (!pEPP || !pEPP->GetPhysicalEntity() || pEPP->GetPhysicalEntity()->GetType() != type)
{
gEnv->pPhysicalWorld->SerializeGarbageTypedSnapshot( ser, type, 0 );
return true;
}
}
else if (!pEPP)
{
return false;
}
// PLAYERPREDICTION
if(type!=PE_LIVING)
{
pEPP->SerializeTyped( ser, type, pflags );
}
// ~PLAYERPREDICTION
}
ser.BeginGroup("ManagedActor");
IMonoArray *pArgs = CreateMonoArray(4);
pArgs->InsertNativePointer(&ser);
pArgs->Insert(aspect);
pArgs->Insert(profile);
pArgs->Insert(pflags);
m_pScript->GetClass()->InvokeArray(m_pScript, "InternalNetSerialize", pArgs);
ser.EndGroup();
return true;
}
