Code/Sandbox/EditorQt/Objects/EntityScript.cpp

   1 // Copyright 2001-2018 Crytek GmbH / Crytek Group. All rights reserved.
   2
   3 #include "StdAfx.h"
   4 #include "EntityScript.h"
   5 #include "EntityObject.h"
   6 #include "CryEdit.h"
   7 #include <CryScriptSystem/IScriptSystem.h>
   8 #include <CryEntitySystem/IEntitySystem.h>
   9 #include "LuaCommentParser.h"
  10 #include "CryEdit.h"
  11
  12 struct CScriptMethodsDump : public IScriptTableDumpSink
  13 {
  14         std::vector<string> methods;
  15         std::vector<string> events;
  16
  17         virtual void OnElementFound(int nIdx, ScriptVarType type) {}
  18
  19         virtual void OnElementFound(const char* sName, ScriptVarType type)
  20         {
  21                 if (type == svtFunction)
  22                 {
  23                         if (strncmp(sName, EVENT_PREFIX, 6) == 0)
  24                         {
  25                                 events.push_back(sName + 6);
  26                         }
  27                         else
  28                         {
  29                                 methods.push_back(sName);
  30                         }
  31                 }
  32         }
  33 };
  34
  35 enum EScriptParamFlags
  36 {
  37         SCRIPTPARAM_POSITIVE = 0x01,
  38 };
  39
  40 //////////////////////////////////////////////////////////////////////////
  41 static struct
  42 {
  43         const char*          prefix;
  44         IVariable::EType     type;
  45         IVariable::EDataType dataType;
  46         int                  flags;
  47         bool                 bExactName;
  48 } s_scriptParamTypes[] =
  49 {
  50         { "n",                   IVariable::INT,    IVariable::DT_SIMPLE,                SCRIPTPARAM_POSITIVE, false },
  51         { "i",                   IVariable::INT,    IVariable::DT_SIMPLE,                0,                    false },
  52         { "b",                   IVariable::BOOL,   IVariable::DT_SIMPLE,                0,                    false },
  53         { "f",                   IVariable::FLOAT,  IVariable::DT_SIMPLE,                0,                    false },
  54         { "s",                   IVariable::STRING, IVariable::DT_SIMPLE,                0,                    false },
  55
  56         { "ei",                  IVariable::INT,    IVariable::DT_UIENUM,                0,                    false },
  57         { "es",                  IVariable::STRING, IVariable::DT_UIENUM,                0,                    false },
  58
  59         { "shader",              IVariable::STRING, IVariable::DT_SHADER,                0,                    false },
  60         { "clr",                 IVariable::VECTOR, IVariable::DT_COLOR,                 0,                    false },
  61         { "color",               IVariable::VECTOR, IVariable::DT_COLOR,                 0,                    false },
  62
  63         { "vector",              IVariable::VECTOR, IVariable::DT_SIMPLE,                0,                    false },
  64
  65         { "tex",                 IVariable::STRING, IVariable::DT_TEXTURE,               0,                    false },
  66         { "texture",             IVariable::STRING, IVariable::DT_TEXTURE,               0,                    false },
  67
  68         { "obj",                 IVariable::STRING, IVariable::DT_OBJECT,                0,                    false },
  69         { "object",              IVariable::STRING, IVariable::DT_OBJECT,                0,                    false },
  70
  71         { "file",                IVariable::STRING, IVariable::DT_FILE,                  0,                    false },
  72         { "aibehavior",          IVariable::STRING, IVariable::DT_AI_BEHAVIOR,           0,                    false },
  73 #ifdef USE_DEPRECATED_AI_CHARACTER_SYSTEM
  74         { "aicharacter",         IVariable::STRING, IVariable::DT_AI_CHARACTER,          0,                    false },
  75 #endif
  76         { "aipfpropertieslist",  IVariable::STRING, IVariable::DT_AI_PFPROPERTIESLIST,   0,                    false },
  77         { "aientityclasses",     IVariable::STRING, IVariable::DT_AIENTITYCLASSES,       0,                    false },
  78         { "aiterritory",         IVariable::STRING, IVariable::DT_AITERRITORY,           0,                    false },
  79         { "aiwave",              IVariable::STRING, IVariable::DT_AIWAVE,                0,                    false },
  80
  81         { "text",                IVariable::STRING, IVariable::DT_LOCAL_STRING,          0,                    false },
  82         { "equip",               IVariable::STRING, IVariable::DT_EQUIP,                 0,                    false },
  83         { "reverbpreset",        IVariable::STRING, IVariable::DT_REVERBPRESET,          0,                    false },
  84         { "eaxpreset",           IVariable::STRING, IVariable::DT_REVERBPRESET,          0,                    false },
  85
  86         { "aianchor",            IVariable::STRING, IVariable::DT_AI_ANCHOR,             0,                    false },
  87
  88         { "soclass",             IVariable::STRING, IVariable::DT_SOCLASS,               0,                    false },
  89         { "soclasses",           IVariable::STRING, IVariable::DT_SOCLASSES,             0,                    false },
  90         { "sostate",             IVariable::STRING, IVariable::DT_SOSTATE,               0,                    false },
  91         { "sostates",            IVariable::STRING, IVariable::DT_SOSTATES,              0,                    false },
  92         { "sopattern",           IVariable::STRING, IVariable::DT_SOSTATEPATTERN,        0,                    false },
  93         { "soaction",            IVariable::STRING, IVariable::DT_SOACTION,              0,                    false },
  94         { "sohelper",            IVariable::STRING, IVariable::DT_SOHELPER,              0,                    false },
  95         { "sonavhelper",         IVariable::STRING, IVariable::DT_SONAVHELPER,           0,                    false },
  96         { "soanimhelper",        IVariable::STRING, IVariable::DT_SOANIMHELPER,          0,                    false },
  97         { "soevent",             IVariable::STRING, IVariable::DT_SOEVENT,               0,                    false },
  98         { "sotemplate",          IVariable::STRING, IVariable::DT_SOTEMPLATE,            0,                    false },
  99         { "customaction",        IVariable::STRING, IVariable::DT_CUSTOMACTION,          0,                    false },
 100         { "gametoken",           IVariable::STRING, IVariable::DT_GAMETOKEN,             0,                    false },
 101         { "seq_",                IVariable::STRING, IVariable::DT_SEQUENCE,              0,                    false },
 102         { "mission_",            IVariable::STRING, IVariable::DT_MISSIONOBJ,            0,                    false },
 103         { "seqid_",              IVariable::INT,    IVariable::DT_SEQUENCE_ID,           0,                    false },
 104         { "flare_",              IVariable::STRING, IVariable::DT_FLARE,                 0,                    false },
 105         { "ParticleEffect",      IVariable::STRING, IVariable::DT_PARTICLE_EFFECT,       0,                    true  },
 106         { "geomcache",           IVariable::STRING, IVariable::DT_GEOM_CACHE,            0,                    false },
 107         { "material",            IVariable::STRING, IVariable::DT_MATERIAL,              0 },
 108         { "audioTrigger",        IVariable::STRING, IVariable::DT_AUDIO_TRIGGER,         0 },
 109         { "audioSwitch",         IVariable::STRING, IVariable::DT_AUDIO_SWITCH,          0 },
 110         { "audioSwitchState",    IVariable::STRING, IVariable::DT_AUDIO_SWITCH_STATE,    0 },
 111         { "audioRTPC",           IVariable::STRING, IVariable::DT_AUDIO_RTPC,            0 },
 112         { "audioEnvironment",    IVariable::STRING, IVariable::DT_AUDIO_ENVIRONMENT,     0 },
 113         { "audioPreloadRequest", IVariable::STRING, IVariable::DT_AUDIO_PRELOAD_REQUEST, 0 },
 114 };
 115
 116 //////////////////////////////////////////////////////////////////////////
 117 struct CScriptPropertiesDump : public IScriptTableDumpSink
 118 {
 119 private:
 120         struct Variable
 121         {
 122                 string        name;
 123                 ScriptVarType type;
 124         };
 125
 126         std::vector<Variable> m_elements;
 127
 128         CVarBlock*            m_varBlock;
 129         IVariable*            m_parentVar;
 130
 131 public:
 132         explicit CScriptPropertiesDump(CVarBlock* pVarBlock, IVariable* pParentVar = NULL)
 133         {
 134                 m_varBlock = pVarBlock;
 135                 m_parentVar = pParentVar;
 136         }
 137
 138         //////////////////////////////////////////////////////////////////////////
 139         inline bool IsPropertyTypeMatch(const char* type, const char* name, int nameLen, bool exactName)
 140         {
 141                 if (exactName)
 142                 {
 143                         return strcmp(type, name) == 0;
 144                 }
 145
 146                 // if starts from capital no type encoded.
 147                 int typeLen = strlen(type);
 148                 if (typeLen < nameLen && name[0] == tolower(name[0]))
 149                 {
 150                         // After type name Must follow Upper case or _.
 151                         if (name[typeLen] != tolower(name[typeLen]) || name[typeLen] == '_')
 152                         {
 153                                 if (strncmp(name, type, strlen(type)) == 0)
 154                                 {
 155                                         return true;
 156                                 }
 157                         }
 158                 }
 159                 return false;
 160         }
 161
 162         //////////////////////////////////////////////////////////////////////////
 163         IVariable* CreateVarByType(IVariable::EType type)
 164         {
 165                 switch (type)
 166                 {
 167                 case IVariable::FLOAT:
 168                         return new CVariable<float>;
 169                 case IVariable::INT:
 170                         return new CVariable<int>;
 171                 case IVariable::STRING:
 172                         return new CVariable<string>;
 173                 case IVariable::BOOL:
 174                         return new CVariable<bool>;
 175                 case IVariable::VECTOR:
 176                         return new CVariable<Vec3>;
 177                 case IVariable::QUAT:
 178                         return new CVariable<Quat>;
 179                 default:
 180                         assert(0);
 181                 }
 182                 return NULL;
 183         }
 184
 185         //////////////////////////////////////////////////////////////////////////
 186         IVariable* CreateVar(const char* name, IVariable::EType defaultType, const char*& displayName)
 187         {
 188                 displayName = name;
 189                 // Resolve type from variable name.
 190                 int nameLen = strlen(name);
 191
 192                 int nFlags = 0;
 193                 int iStartIndex = 0;
 194                 if (name[0] == '_')
 195                 {
 196                         nFlags |= IVariable::UI_INVISIBLE;
 197                         iStartIndex++;
 198                 }
 199
 200                 {
 201                         // Try to detect type.
 202                         for (int i = 0; i < CRY_ARRAY_COUNT(s_scriptParamTypes); i++)
 203                         {
 204                                 if (IsPropertyTypeMatch(s_scriptParamTypes[i].prefix, name + iStartIndex, nameLen - iStartIndex, s_scriptParamTypes[i].bExactName))
 205                                 {
 206                                         displayName = name + strlen(s_scriptParamTypes[i].prefix) + iStartIndex;
 207                                         if (displayName[0] == '_')
 208                                         {
 209                                                 displayName++;
 210                                         }
 211                                         if (displayName[0] == '\0')
 212                                         {
 213                                                 displayName = name;
 214                                         }
 215
 216                                         IVariable::EType type = s_scriptParamTypes[i].type;
 217                                         IVariable::EDataType dataType = s_scriptParamTypes[i].dataType;
 218
 219                                         IVariable* var;
 220                                         if (type == IVariable::STRING &&
 221                                             (dataType == IVariable::DT_AITERRITORY || dataType == IVariable::DT_AIWAVE))
 222                                         {
 223                                                 var = new CVariableEnum<string>;
 224                                         }
 225                                         else
 226                                         {
 227                                                 var = CreateVarByType(type);
 228                                         }
 229
 230                                         if (!var)
 231                                         {
 232                                                 continue;
 233                                         }
 234
 235                                         var->SetName(name);
 236                                         var->SetHumanName(displayName);
 237                                         var->SetDataType(s_scriptParamTypes[i].dataType);
 238                                         var->SetFlags(nFlags);
 239                                         if (s_scriptParamTypes[i].flags & SCRIPTPARAM_POSITIVE)
 240                                         {
 241                                                 float lmin = 0, lmax = 10000;
 242                                                 var->GetLimits(lmin, lmax);
 243                                                 // set min Limit to 0 hard, to make it positive only value.
 244                                                 var->SetLimits(0, lmax, true, false);
 245                                         }
 246                                         return var;
 247                                 }
 248                         }
 249                 }
 250                 if (defaultType != IVariable::UNKNOWN)
 251                 {
 252                         IVariable* var = CreateVarByType(defaultType);
 253                         var->SetName(name);
 254                         return var;
 255                 }
 256                 return 0;
 257         }
 258
 259         //////////////////////////////////////////////////////////////////////////
 260         virtual void OnElementFound(int nIdx, ScriptVarType type)
 261         {
 262                 /* ignore non string indexed values */
 263         }
 264
 265         //////////////////////////////////////////////////////////////////////////
 266         virtual void OnElementFound(const char* sName, ScriptVarType type)
 267         {
 268                 if (sName && sName[0] != 0)
 269                 {
 270                         Variable var;
 271                         var.name = sName;
 272                         var.type = type;
 273                         m_elements.push_back(var);
 274                 }
 275         }
 276
 277         //////////////////////////////////////////////////////////////////////////
 278         void Dump(IScriptTable* pObject, string sTablePath)
 279         {
 280                 m_elements.reserve(20);
 281                 pObject->Dump(this);
 282                 typedef std::map<string, IVariablePtr, stl::less_stricmp<string>> NodesMap;
 283                 NodesMap nodes;
 284                 NodesMap listNodes;
 285
 286                 for (int i = 0; i < m_elements.size(); i++)
 287                 {
 288                         const char* sName = m_elements[i].name;
 289                         ScriptVarType type = m_elements[i].type;
 290
 291                         const char* sDisplayName = sName;
 292
 293                         if (type == svtNumber)
 294                         {
 295                                 float fVal;
 296                                 pObject->GetValue(sName, fVal);
 297                                 IVariable* var = CreateVar(sName, IVariable::FLOAT, sDisplayName);
 298                                 if (var)
 299                                 {
 300                                         var->Set(fVal);
 301
 302                                         //use lua comment parser to read comment about limit settings
 303                                         float minVal, maxVal, stepVal;
 304                                         string desc;
 305                                         if (LuaCommentParser::GetInstance()->ParseComment(sTablePath, sName, &minVal, &maxVal, &stepVal, &desc))
 306                                         {
 307                                                 var->SetLimits(minVal, maxVal, stepVal);
 308                                                 var->SetDescription(desc);
 309                                         }
 310
 311                                         nodes[sDisplayName] = var;
 312                                 }
 313                         }
 314                         else if (type == svtString)
 315                         {
 316                                 const char* sVal;
 317                                 pObject->GetValue(sName, sVal);
 318                                 IVariable* var = CreateVar(sName, IVariable::STRING, sDisplayName);
 319                                 if (var)
 320                                 {
 321                                         var->Set(sVal);
 322                                         nodes[sDisplayName] = var;
 323                                 }
 324                         }
 325                         else if (type == svtBool)
 326                         {
 327                                 bool val = false;
 328                                 pObject->GetValue(sName, val);
 329                                 IVariable* pVar = CreateVar(sName, IVariable::BOOL, sDisplayName);
 330                                 if (pVar)
 331                                 {
 332                                         pVar->Set(val);
 333                                         nodes[sDisplayName] = pVar;
 334                                 }
 335                         }
 336                         else if (type == svtFunction)
 337                         {
 338                                 // Ignore functions.
 339                         }
 340                         else if (type == svtObject)
 341                         {
 342                                 // Some Table.
 343                                 SmartScriptTable pTable(GetIEditorImpl()->GetSystem()->GetIScriptSystem(), true);
 344                                 if (pObject->GetValue(sName, pTable))
 345                                 {
 346                                         IVariable* var = CreateVar(sName, IVariable::UNKNOWN, sDisplayName);
 347                                         if (var && var->GetType() == IVariable::VECTOR)
 348                                         {
 349                                                 nodes[sDisplayName] = var;
 350                                                 float x, y, z;
 351                                                 if (pTable->GetValue("x", x) && pTable->GetValue("y", y) && pTable->GetValue("z", z))
 352                                                 {
 353                                                         var->Set(Vec3(x, y, z));
 354                                                 }
 355                                                 else
 356                                                 {
 357                                                         pTable->GetAt(1, x);
 358                                                         pTable->GetAt(2, y);
 359                                                         pTable->GetAt(3, z);
 360                                                         var->Set(Vec3(x, y, z));
 361                                                 }
 362                                         }
 363                                         else
 364                                         {
 365                                                 if (var)
 366                                                 {
 367                                                         var->Release();
 368                                                 }
 369
 370                                                 var = new CVariableArray;
 371                                                 var->SetName(sName);
 372                                                 listNodes[sName] = var;
 373
 374                                                 CScriptPropertiesDump dump(m_varBlock, var);
 375                                                 dump.Dump(*pTable, sTablePath + "." + string(sName));
 376                                         }
 377                                 }
 378                         }
 379                 }
 380
 381                 for (NodesMap::iterator nit = nodes.begin(); nit != nodes.end(); nit++)
 382                 {
 383                         if (m_parentVar)
 384                         {
 385                                 m_parentVar->AddVariable(nit->second);
 386                         }
 387                         else
 388                         {
 389                                 m_varBlock->AddVariable(nit->second);
 390                         }
 391                 }
 392
 393                 for (NodesMap::iterator nit1 = listNodes.begin(); nit1 != listNodes.end(); nit1++)
 394                 {
 395                         if (m_parentVar)
 396                         {
 397                                 m_parentVar->AddVariable(nit1->second);
 398                         }
 399                         else
 400                         {
 401                                 m_varBlock->AddVariable(nit1->second);
 402                         }
 403                 }
 404         }
 405 };
 406
 407 //////////////////////////////////////////////////////////////////////////
 408 //////////////////////////////////////////////////////////////////////////
 409
 410 //////////////////////////////////////////////////////////////////////////
 411 CEntityScript::CEntityScript(IEntityClass* pClass)
 412 {
 413         SetClass(pClass);
 414         m_bValid = false;
 415         m_haveEventsTable = false;
 416         m_visibilityMask = 0;
 417
 418         m_nFlags = 0;
 419         m_pOnPropertyChangedFunc = 0;
 420 }
 421
 422 //////////////////////////////////////////////////////////////////////////
 423 CEntityScript::~CEntityScript()
 424 {
 425         if (m_pOnPropertyChangedFunc)
 426                 gEnv->pScriptSystem->ReleaseFunc(m_pOnPropertyChangedFunc);
 427 }
 428
 429 //////////////////////////////////////////////////////////////////////////
 430 void CEntityScript::SetClass(IEntityClass* pClass)
 431 {
 432         assert(pClass);
 433         m_pClass = pClass;
 434         m_usable = !(pClass->GetFlags() & ECLF_INVISIBLE);
 435 }
 436
 437 //////////////////////////////////////////////////////////////////////////
 438 string CEntityScript::GetName() const
 439 {
 440         return m_pClass->GetName();
 441 }
 442
 443 //////////////////////////////////////////////////////////////////////////
 444 string CEntityScript::GetFile() const
 445 {
 446         if (IEntityScriptFileHandler* pScriptFileHandler = m_pClass->GetScriptFileHandler())
 447                 return pScriptFileHandler->GetScriptFile();
 448
 449         return m_pClass->GetScriptFile();
 450 }
 451
 452 //////////////////////////////////////////////////////////////////////////
 453 int CEntityScript::GetEventCount()
 454 {
 455         if (IEntityEventHandler* pEventHandler = m_pClass->GetEventHandler())
 456                 return pEventHandler->GetEventCount();
 457
 458         return (int)m_events.size();
 459 }
 460
 461 //////////////////////////////////////////////////////////////////////////
 462 const char* CEntityScript::GetEvent(int i)
 463 {
 464         if (IEntityEventHandler* pEventHandler = m_pClass->GetEventHandler())
 465         {
 466                 IEntityEventHandler::SEventInfo info;
 467                 pEventHandler->GetEventInfo(i, info);
 468
 469                 return info.name;
 470         }
 471
 472         return m_events[i];
 473 }
 474
 475 //////////////////////////////////////////////////////////////////////////
 476 int CEntityScript::GetEmptyLinkCount()
 477 {
 478         return (int)m_emptyLinks.size();
 479 }
 480
 481 //////////////////////////////////////////////////////////////////////////
 482 const string& CEntityScript::GetEmptyLink(int i)
 483 {
 484         return m_emptyLinks[i];
 485 }
 486
 487 //////////////////////////////////////////////////////////////////////////
 488 bool CEntityScript::Load()
 489 {
 490         m_bValid = true;
 491
 492         if (strlen(m_pClass->GetScriptFile()) > 0)
 493         {
 494                 if (m_pClass->LoadScript(false))
 495                 {
 496                         //Feed script file to the lua comment parser for processing
 497                         LuaCommentParser::GetInstance()->OpenScriptFile(m_pClass->GetScriptFile());
 498
 499                         // If class have script parse this script.
 500                         m_bValid = ParseScript();
 501
 502                         LuaCommentParser::GetInstance()->CloseScriptFile();
 503                 }
 504                 else
 505                         CryWarning(VALIDATOR_MODULE_EDITOR, VALIDATOR_WARNING, "Entity class %s failed to load, (script: %s could not be loaded)", m_pClass->GetName(), m_pClass->GetScriptFile());
 506         }
 507         else
 508         {
 509                 // No script file: parse the script tables
 510                 // which should have been specified by game code.
 511                 ParseScript();
 512         }
 513
 514         return m_bValid;
 515 }
 516
 517 //////////////////////////////////////////////////////////////////////////
 518 bool CEntityScript::ParseScript()
 519 {
 520         // Parse .lua file.
 521         IScriptSystem* script = GetIEditorImpl()->GetSystem()->GetIScriptSystem();
 522
 523         SmartScriptTable pEntity(script, true);
 524         if (!script->GetGlobalValue(GetName(), pEntity))
 525         {
 526                 return false;
 527         }
 528
 529         m_bValid = true;
 530
 531         pEntity->GetValue("OnPropertyChange", m_pOnPropertyChangedFunc);
 532
 533         CScriptMethodsDump dump;
 534         pEntity->Dump(&dump);
 535         m_methods = dump.methods;
 536         m_events = dump.events;
 537
 538         //! Sort methods and events.
 539         std::sort(m_methods.begin(), m_methods.end());
 540         std::sort(m_events.begin(), m_events.end());
 541
 542         m_emptyLinks.clear();
 543
 544         {
 545                 // Normal properties.
 546                 m_pDefaultProperties = 0;
 547                 SmartScriptTable pProps(script, true);
 548                 if (pEntity->GetValue(PROPERTIES_TABLE, pProps))
 549                 {
 550                         // Properties found in entity.
 551                         m_pDefaultProperties = new CVarBlock;
 552                         CScriptPropertiesDump dump(m_pDefaultProperties);
 553                         dump.Dump(*pProps, PROPERTIES_TABLE);
 554                 }
 555         }
 556
 557         {
 558                 // Second set of properties.
 559                 m_pDefaultProperties2 = 0;
 560                 SmartScriptTable pProps(script, true);
 561                 if (pEntity->GetValue(PROPERTIES2_TABLE, pProps))
 562                 {
 563                         // Properties found in entity.
 564                         m_pDefaultProperties2 = new CVarBlock;
 565                         CScriptPropertiesDump dump(m_pDefaultProperties2);
 566                         dump.Dump(*pProps, PROPERTIES2_TABLE);
 567                 }
 568         }
 569
 570         // Destroy variable block if empty.
 571         /*if ( m_pDefaultProperties && m_pDefaultProperties->IsEmpty() )
 572            {
 573            m_pDefaultProperties = nullptr;
 574            }
 575
 576            // Destroy variable block if empty.
 577            if ( m_pDefaultProperties2 && m_pDefaultProperties2->IsEmpty() )
 578            {
 579            m_pDefaultProperties2 = nullptr;
 580            }*/
 581
 582         if (m_pDefaultProperties != 0 && m_pDefaultProperties->GetNumVariables() < 1)
 583         {
 584                 m_pDefaultProperties = 0;
 585         }
 586
 587         // Destroy variable block if empty.
 588         if (m_pDefaultProperties2 != 0 && m_pDefaultProperties2->GetNumVariables() < 1)
 589         {
 590                 m_pDefaultProperties2 = 0;
 591         }
 592
 593         // Load visual object.
 594         SmartScriptTable pEditorTable(script, true);
 595         if (pEntity->GetValue("Editor", pEditorTable))
 596         {
 597                 SEditorClassInfo classInfo = m_pClass->GetEditorClassInfo();
 598
 599                 const char* modelName;
 600                 if (pEditorTable->GetValue("Model", modelName))
 601                 {
 602                         classInfo.sHelper = modelName;
 603                 }
 604
 605                 bool bShowBounds = false;
 606                 pEditorTable->GetValue("ShowBounds", bShowBounds);
 607                 if (bShowBounds)
 608                 {
 609                         m_nFlags |= ENTITY_SCRIPT_SHOWBOUNDS;
 610                 }
 611                 else
 612                 {
 613                         m_nFlags &= ~ENTITY_SCRIPT_SHOWBOUNDS;
 614                 }
 615
 616                 bool isScalable = true;
 617                 pEditorTable->GetValue("IsScalable", isScalable);
 618                 if (!isScalable)
 619                 {
 620                         m_nFlags |= ENTITY_SCRIPT_ISNOTSCALABLE;
 621                 }
 622                 else
 623                 {
 624                         m_nFlags &= ~ENTITY_SCRIPT_ISNOTSCALABLE;
 625                 }
 626
 627                 bool isRotatable = true;
 628                 pEditorTable->GetValue("IsRotatable", isRotatable);
 629                 if (!isRotatable)
 630                 {
 631                         m_nFlags |= ENTITY_SCRIPT_ISNOTROTATABLE;
 632                 }
 633                 else
 634                 {
 635                         m_nFlags &= ~ENTITY_SCRIPT_ISNOTROTATABLE;
 636                 }
 637
 638                 bool bAbsoluteRadius = false;
 639                 pEditorTable->GetValue("AbsoluteRadius", bAbsoluteRadius);
 640                 if (bAbsoluteRadius)
 641                 {
 642                         m_nFlags |= ENTITY_SCRIPT_ABSOLUTERADIUS;
 643                 }
 644                 else
 645                 {
 646                         m_nFlags &= ~ENTITY_SCRIPT_ABSOLUTERADIUS;
 647                 }
 648
 649                 const char* iconName = "";
 650                 if (pEditorTable->GetValue("Icon", iconName))
 651                 {
 652                         classInfo.sIcon = PathUtil::Make("%EDITOR%/ObjectIcons", iconName);
 653                 }
 654
 655                 classInfo.bIconOnTop = false;
 656                 pEditorTable->GetValue("IconOnTop", classInfo.bIconOnTop);
 657
 658                 bool bArrow = false;
 659                 pEditorTable->GetValue("DisplayArrow", bArrow);
 660                 if (bArrow)
 661                 {
 662                         m_nFlags |= ENTITY_SCRIPT_DISPLAY_ARROW;
 663                 }
 664                 else
 665                 {
 666                         m_nFlags &= ~ENTITY_SCRIPT_DISPLAY_ARROW;
 667                 }
 668
 669                 SmartScriptTable pLinksTable(script, true);
 670                 if (pEditorTable->GetValue("Links", pLinksTable))
 671                 {
 672                         IScriptTable::Iterator iter = pLinksTable->BeginIteration();
 673                         while (pLinksTable->MoveNext(iter))
 674                         {
 675                                 if (iter.value.GetType() == EScriptAnyType::String)
 676                                 {
 677                                         const char* sLinkName = iter.value.GetString();
 678                                         m_emptyLinks.push_back(sLinkName);
 679                                 }
 680                         }
 681                         pLinksTable->EndIteration(iter);
 682                 }
 683
 684                 const char* editorPath = "";
 685                 if (pEditorTable->GetValue("EditorPath", editorPath))
 686                 {
 687                         m_userPath = editorPath;
 688                 }
 689
 690                 m_pClass->SetEditorClassInfo(classInfo);
 691         }
 692
 693         return true;
 694 }
 695
 696 //////////////////////////////////////////////////////////////////////////
 697 void CEntityScript::Reload()
 698 {
 699         if (IEntityScriptFileHandler* pScriptFileHandler = m_pClass->GetScriptFileHandler())
 700                 pScriptFileHandler->ReloadScriptFile();
 701
 702         bool bReloaded = false;
 703         IEntityScript* pScript = m_pClass->GetIEntityScript();
 704         if (pScript)
 705         {
 706                 // First try compiling script and see if it have any errors.
 707                 bool bLoadScript = CFileUtil::CompileLuaFile(m_pClass->GetScriptFile());
 708                 if (bLoadScript)
 709                 {
 710                         bReloaded = m_pClass->LoadScript(true);
 711                 }
 712         }
 713
 714         if (bReloaded)
 715         {
 716                 // Script compiled successfully.
 717                 Load();
 718         }
 719 }
 720
 721 //////////////////////////////////////////////////////////////////////////
 722 void CEntityScript::GotoMethod(const string& method)
 723 {
 724         string line;
 725         line.Format("%s:%s", (const char*)GetName(), (const char*)method);
 726
 727         // Search this line in script file.
 728         int lineNum = FindLineNum(line);
 729         if (lineNum >= 0)
 730         {
 731                 // Open UltraEdit32 with this line.
 732                 CFileUtil::EditTextFile(GetFile(), lineNum);
 733         }
 734 }
 735
 736 void CEntityScript::AddMethod(const string& method)
 737 {
 738         // Add a new method to the file. and start Editing it.
 739         FILE* f = fopen(GetFile(), "at");
 740         if (f)
 741         {
 742                 fprintf(f, "\n");
 743                 fprintf(f, "-------------------------------------------------------\n");
 744                 fprintf(f, "function %s:%s()\n", (const char*)m_pClass->GetName(), (const char*)method);
 745                 fprintf(f, "end\n");
 746                 fclose(f);
 747         }
 748 }
 749
 750 const string& CEntityScript::GetDisplayPath()
 751 {
 752         if (m_userPath.IsEmpty())
 753         {
 754                 IScriptSystem* script = GetIEditorImpl()->GetSystem()->GetIScriptSystem();
 755
 756                 SmartScriptTable pEntity(script, true);
 757                 if (!script->GetGlobalValue(GetName(), pEntity))
 758                 {
 759                         m_userPath = "Default/" + GetName();
 760                         return m_userPath;
 761                 }
 762
 763                 SmartScriptTable pEditorTable(script, true);
 764                 if (pEntity->GetValue("Editor", pEditorTable))
 765                 {
 766                         const char* editorPath = "";
 767                         if (pEditorTable->GetValue("EditorPath", editorPath))
 768                         {
 769                                 m_userPath = editorPath;
 770                         }
 771                 }
 772         }
 773
 774         return m_userPath;
 775 }
 776
 777 //////////////////////////////////////////////////////////////////////////
 778 int CEntityScript::FindLineNum(const string& line)
 779 {
 780         FILE* fileHandle = fopen(GetFile(), "rb");
 781         if (!fileHandle)
 782         {
 783                 return -1;
 784         }
 785
 786         int lineFound = -1;
 787         int lineNum = 1;
 788
 789         fseek(fileHandle, 0, SEEK_END);
 790         int size = ftell(fileHandle);
 791         fseek(fileHandle, 0, SEEK_SET);
 792
 793         char* text = new char[size + 16];
 794         fread(text, size, 1, fileHandle);
 795         text[size] = 0;
 796
 797         char* token = strtok(text, "\n");
 798         while (token)
 799         {
 800                 if (strstr(token, line) != 0)
 801                 {
 802                         lineFound = lineNum;
 803                         break;
 804                 }
 805                 token = strtok(NULL, "\n");
 806                 lineNum++;
 807         }
 808
 809         fclose(fileHandle);
 810         delete[]text;
 811
 812         return lineFound;
 813 }
 814
 815 //////////////////////////////////////////////////////////////////////////
 816 void CEntityScript::CopyPropertiesToScriptTable(IEntity* pEntity, CVarBlock* pVarBlock, bool bCallUpdate)
 817 {
 818         CopyPropertiesToScriptInternal(pEntity, pVarBlock, bCallUpdate, PROPERTIES_TABLE);
 819 }
 820
 821 //////////////////////////////////////////////////////////////////////////
 822 void CEntityScript::CopyProperties2ToScriptTable(IEntity* pEntity, CVarBlock* pVarBlock, bool bCallUpdate)
 823 {
 824         CopyPropertiesToScriptInternal(pEntity, pVarBlock, bCallUpdate, PROPERTIES2_TABLE);
 825 }
 826
 827 //////////////////////////////////////////////////////////////////////////
 828 void CEntityScript::CopyPropertiesToScriptInternal(IEntity* pEntity, CVarBlock* pVarBlock, bool bCallUpdate, const char* tableKey)
 829 {
 830         if (!IsValid())
 831         {
 832                 return;
 833         }
 834
 835         assert(pEntity != 0);
 836         assert(pVarBlock != 0);
 837
 838         IScriptTable* scriptTable = pEntity->GetScriptTable();
 839         if (!scriptTable)
 840         {
 841                 // ENTITY TODO: Don't create CEntityScript in this case
 842                 return;
 843         }
 844
 845         IScriptSystem* pScriptSystem = GetIEditorImpl()->GetSystem()->GetIScriptSystem();
 846
 847         SmartScriptTable table(pScriptSystem, true);
 848         if (!scriptTable->GetValue(tableKey, table))
 849         {
 850                 return;
 851         }
 852
 853         for (int i = 0; i < pVarBlock->GetNumVariables(); i++)
 854         {
 855                 VarToScriptTable(pVarBlock->GetVariable(i), table);
 856         }
 857
 858         if (bCallUpdate)
 859         {
 860                 CallOnPropertyChange(pEntity);
 861         }
 862 }
 863
 864 //////////////////////////////////////////////////////////////////////////
 865 void CEntityScript::CallOnPropertyChange(IEntity* pEntity)
 866 {
 867         if (!IsValid())
 868         {
 869                 return;
 870         }
 871
 872         if (m_pOnPropertyChangedFunc)
 873         {
 874                 assert(pEntity != 0);
 875                 IScriptTable* pScriptObject = pEntity->GetScriptTable();
 876                 if (!pScriptObject)
 877                         return;
 878                 Script::CallMethod(pScriptObject, m_pOnPropertyChangedFunc);
 879         }
 880
 881         SEntityEvent entityEvent(ENTITY_EVENT_EDITOR_PROPERTY_CHANGED);
 882         pEntity->SendEvent(entityEvent);
 883 }
 884
 885 //////////////////////////////////////////////////////////////////////////
 886 void CEntityScript::VarToScriptTable(IVariable* pVariable, IScriptTable* pScriptTable)
 887 {
 888         assert(pVariable);
 889
 890         IScriptSystem* pScriptSystem = GetIEditorImpl()->GetSystem()->GetIScriptSystem();
 891
 892         if (pVariable->GetType() == IVariable::ARRAY)
 893         {
 894                 int type = pScriptTable->GetValueType(pVariable->GetName());
 895                 if (type != svtObject)
 896                 {
 897                         return;
 898                 }
 899
 900                 SmartScriptTable table(pScriptSystem, true);
 901                 if (pScriptTable->GetValue(pVariable->GetName(), table))
 902                 {
 903                         for (int i = 0; i < pVariable->GetNumVariables(); i++)
 904                         {
 905                                 IVariable* child = pVariable->GetVariable(i);
 906                                 VarToScriptTable(child, table);
 907                         }
 908                 }
 909                 return;
 910         }
 911
 912         const char* name = pVariable->GetName();
 913         int type = pScriptTable->GetValueType(name);
 914
 915         if (type == svtString)
 916         {
 917                 string value;
 918                 pVariable->Get(value);
 919                 pScriptTable->SetValue(name, (const char*)value);
 920         }
 921         else if (type == svtNumber)
 922         {
 923                 float val = 0;
 924                 pVariable->Get(val);
 925                 pScriptTable->SetValue(name, val);
 926         }
 927         else if (type == svtBool)
 928         {
 929                 bool val = false;
 930                 pVariable->Get(val);
 931                 pScriptTable->SetValue(name, val);
 932         }
 933         else if (type == svtObject)
 934         {
 935                 // Probably Color/Vector.
 936                 SmartScriptTable table(pScriptSystem, true);
 937                 if (pScriptTable->GetValue(name, table))
 938                 {
 939                         if (pVariable->GetType() == IVariable::VECTOR)
 940                         {
 941                                 Vec3 vec;
 942                                 pVariable->Get(vec);
 943
 944                                 float temp;
 945                                 if (table->GetValue("x", temp))
 946                                 {
 947                                         // Named vector.
 948                                         table->SetValue("x", vec.x);
 949                                         table->SetValue("y", vec.y);
 950                                         table->SetValue("z", vec.z);
 951                                 }
 952                                 else
 953                                 {
 954                                         // Indexed vector.
 955                                         table->SetAt(1, vec.x);
 956                                         table->SetAt(2, vec.y);
 957                                         table->SetAt(3, vec.z);
 958                                 }
 959                         }
 960                 }
 961         }
 962 }
 963
 964 //////////////////////////////////////////////////////////////////////////
 965 void CEntityScript::CopyPropertiesFromScriptTable(IEntity* pEntity, CVarBlock* pVarBlock)
 966 {
 967         CopyPropertiesFromScriptInternal(pEntity, pVarBlock, PROPERTIES_TABLE);
 968 }
 969
 970 //////////////////////////////////////////////////////////////////////////
 971 void CEntityScript::CopyProperties2FromScriptTable(IEntity* pEntity, CVarBlock* pVarBlock)
 972 {
 973         CopyPropertiesFromScriptInternal(pEntity, pVarBlock, PROPERTIES2_TABLE);
 974 }
 975
 976 //////////////////////////////////////////////////////////////////////////
 977 void CEntityScript::CopyPropertiesFromScriptInternal(IEntity* pEntity, CVarBlock* pVarBlock, const char* tableKey)
 978 {
 979         if (!IsValid())
 980         {
 981                 return;
 982         }
 983
 984         assert(pEntity != 0);
 985         assert(pVarBlock != 0);
 986
 987         IScriptTable* scriptTable = pEntity->GetScriptTable();
 988         if (!scriptTable)
 989         {
 990                 return;
 991         }
 992
 993         IScriptSystem* pScriptSystem = GetIEditorImpl()->GetSystem()->GetIScriptSystem();
 994
 995         SmartScriptTable table(pScriptSystem, true);
 996         if (!scriptTable->GetValue(tableKey, table))
 997         {
 998                 return;
 999         }
1000
1001         for (int i = 0; i < pVarBlock->GetNumVariables(); i++)
1002         {
1003                 ScriptTableToVar(table, pVarBlock->GetVariable(i));
1004         }
1005 }
1006
1007 //////////////////////////////////////////////////////////////////////////
1008 void CEntityScript::ScriptTableToVar(IScriptTable* pScriptTable, IVariable* pVariable)
1009 {
1010         assert(pVariable);
1011
1012         IScriptSystem* pScriptSystem = GetIEditorImpl()->GetSystem()->GetIScriptSystem();
1013
1014         if (pVariable->GetType() == IVariable::ARRAY)
1015         {
1016                 int type = pScriptTable->GetValueType(pVariable->GetName());
1017                 if (type != svtObject)
1018                 {
1019                         return;
1020                 }
1021
1022                 SmartScriptTable table(pScriptSystem, true);
1023                 if (pScriptTable->GetValue(pVariable->GetName(), table))
1024                 {
1025                         for (int i = 0; i < pVariable->GetNumVariables(); i++)
1026                         {
1027                                 IVariable* child = pVariable->GetVariable(i);
1028                                 ScriptTableToVar(table, child);
1029                         }
1030                 }
1031                 return;
1032         }
1033
1034         const char* name = pVariable->GetName();
1035         int type = pScriptTable->GetValueType(name);
1036
1037         if (type == svtString)
1038         {
1039                 const char* value;
1040                 pScriptTable->GetValue(name, value);
1041                 pVariable->Set(value);
1042         }
1043         else if (type == svtNumber)
1044         {
1045                 float val = 0;
1046                 pScriptTable->GetValue(name, val);
1047                 pVariable->Set(val);
1048         }
1049         else if (type == svtBool)
1050         {
1051                 bool val = false;
1052                 pScriptTable->GetValue(name, val);
1053                 pVariable->Set(val);
1054         }
1055         else if (type == svtObject)
1056         {
1057                 // Probably Color/Vector.
1058                 SmartScriptTable table(pScriptSystem, true);
1059                 if (pScriptTable->GetValue(name, table))
1060                 {
1061                         if (pVariable->GetType() == IVariable::VECTOR)
1062                         {
1063                                 Vec3 vec;
1064
1065                                 float temp;
1066                                 if (table->GetValue("x", temp))
1067                                 {
1068                                         // Named vector.
1069                                         table->GetValue("x", vec.x);
1070                                         table->GetValue("y", vec.y);
1071                                         table->GetValue("z", vec.z);
1072                                 }
1073                                 else
1074                                 {
1075                                         // Indexed vector.
1076                                         table->GetAt(1, vec.x);
1077                                         table->GetAt(2, vec.y);
1078                                         table->GetAt(3, vec.z);
1079                                 }
1080
1081                                 pVariable->Set(vec);
1082                         }
1083                 }
1084         }
1085 }
1086
1087 //////////////////////////////////////////////////////////////////////////
1088 void CEntityScript::RunMethod(IEntity* pEntity, const string& method)
1089 {
1090         if (!IsValid())
1091         {
1092                 return;
1093         }
1094
1095         assert(pEntity != 0);
1096
1097         IScriptTable* scriptTable = pEntity->GetScriptTable();
1098         if (!scriptTable)
1099         {
1100                 return;
1101         }
1102
1103         IScriptSystem* scriptSystem = GetIEditorImpl()->GetSystem()->GetIScriptSystem();
1104
1105         Script::CallMethod(scriptTable, (const char*)method);
1106 }
1107
1108 //////////////////////////////////////////////////////////////////////////
1109 void CEntityScript::SendEvent(IEntity* pEntity, const string& method)
1110 {
1111         if (IEntityEventHandler* pEventHandler = m_pClass->GetEventHandler())
1112                 pEventHandler->SendEvent(pEntity, method);
1113
1114         // Fire event on Entity.
1115         IEntityScriptComponent* pScriptProxy = (IEntityScriptComponent*)pEntity->GetProxy(ENTITY_PROXY_SCRIPT);
1116         if (pScriptProxy)
1117         {
1118                 pScriptProxy->CallEvent(method);
1119         }
1120 }
1121
1122 //////////////////////////////////////////////////////////////////////////
1123 void CEntityScript::SetEventsTable(CEntityObject* pEntity)
1124 {
1125         if (!IsValid())
1126         {
1127                 return;
1128         }
1129         assert(pEntity != 0);
1130
1131         IEntity* ientity = pEntity->GetIEntity();
1132         if (!ientity)
1133         {
1134                 return;
1135         }
1136
1137         IScriptTable* scriptTable = ientity->GetScriptTable();
1138         if (!scriptTable)
1139         {
1140                 return;
1141         }
1142
1143         // If events target table is null, set event table to null either.
1144         if (pEntity->GetEventTargetCount() == 0)
1145         {
1146                 if (m_haveEventsTable)
1147                 {
1148                         scriptTable->SetToNull("Events");
1149                 }
1150                 m_haveEventsTable = false;
1151                 return;
1152         }
1153
1154         IScriptSystem* scriptSystem = GetIEditorImpl()->GetSystem()->GetIScriptSystem();
1155         SmartScriptTable pEvents(scriptSystem, false);
1156
1157         scriptTable->SetValue("Events", *pEvents);
1158         m_haveEventsTable = true;
1159
1160         std::set<string> sourceEvents;
1161         for (int i = 0; i < pEntity->GetEventTargetCount(); i++)
1162         {
1163                 CEntityEventTarget& et = pEntity->GetEventTarget(i);
1164                 sourceEvents.insert(et.sourceEvent);
1165         }
1166         for (std::set<string>::iterator it = sourceEvents.begin(); it != sourceEvents.end(); it++)
1167         {
1168                 SmartScriptTable pTrgEvents(scriptSystem, false);
1169                 string sourceEvent = *it;
1170
1171                 pEvents->SetValue(sourceEvent, *pTrgEvents);
1172
1173                 // Put target events to table.
1174                 int trgEventIndex = 1;
1175                 for (int i = 0; i < pEntity->GetEventTargetCount(); i++)
1176                 {
1177                         CEntityEventTarget& et = pEntity->GetEventTarget(i);
1178                         if (stricmp(et.sourceEvent, sourceEvent) == 0)
1179                         {
1180                                 EntityId entityId = 0;
1181                                 if (et.target)
1182                                 {
1183                                         if (et.target->IsKindOf(RUNTIME_CLASS(CEntityObject)))
1184                                         {
1185                                                 entityId = ((CEntityObject*)et.target)->GetEntityId();
1186                                         }
1187                                 }
1188
1189                                 SmartScriptTable pTrgEvent(scriptSystem, false);
1190                                 pTrgEvents->SetAt(trgEventIndex, *pTrgEvent);
1191                                 trgEventIndex++;
1192
1193                                 ScriptHandle idHandle;
1194                                 idHandle.n = entityId;
1195
1196                                 pTrgEvent->SetAt(1, idHandle);
1197                                 pTrgEvent->SetAt(2, (const char*)et.event);
1198                         }
1199                 }
1200         }
1201 }
1202
1203 //////////////////////////////////////////////////////////////////////////
1204 void CEntityScript::UpdateTextureIcon(IEntity* pEntity)
1205 {
1206         if (pEntity)
1207         {
1208                 // Try to call a function GetEditorIcon on the script, to give it a change to return
1209                 // a custom icon.
1210                 IScriptTable* pScriptTable = pEntity->GetScriptTable();
1211                 if (pScriptTable != NULL && pScriptTable->GetValueType("GetEditorIcon") == svtFunction)
1212                 {
1213                         SmartScriptTable iconData(gEnv->pScriptSystem);
1214                         if (Script::CallMethod(pScriptTable, "GetEditorIcon", iconData))
1215                         {
1216                                 const char* iconName = NULL;
1217                                 iconData->GetValue("Icon", iconName);
1218
1219                                 SEditorClassInfo classInfo = m_pClass->GetEditorClassInfo();
1220                                 classInfo.sIcon = PathUtil::Make("%EDITOR%/ObjectIcons", iconName);
1221                                 m_pClass->SetEditorClassInfo(classInfo);
1222                         }
1223                 }
1224         }
1225 }
1226
1227 //////////////////////////////////////////////////////////////////////////
1228 // CEntityScriptRegistry implementation.
1229 //////////////////////////////////////////////////////////////////////////
1230 CEntityScriptRegistry* CEntityScriptRegistry::m_instance = 0;
1231
1232 CEntityScriptRegistry::CEntityScriptRegistry() :
1233         m_needsScriptReload(false)
1234 {
1235         gEnv->pEntitySystem->GetClassRegistry()->RegisterListener(this);
1236         GetIEditorImpl()->RegisterNotifyListener(this);
1237 }
1238
1239 CEntityScriptRegistry::~CEntityScriptRegistry()
1240 {
1241         m_instance = 0;
1242         m_scripts.clear();
1243         gEnv->pEntitySystem->GetClassRegistry()->UnregisterListener(this);
1244         GetIEditorImpl()->UnregisterNotifyListener(this);
1245 }
1246
1247 //////////////////////////////////////////////////////////////////////////
1248 void CEntityScriptRegistry::OnEntityClassRegistryEvent(EEntityClassRegistryEvent event, const IEntityClass* pEntityClass)
1249 {
1250         switch (event)
1251         {
1252         case ECRE_CLASS_REGISTERED:
1253         case ECRE_CLASS_MODIFIED:
1254                 {
1255                         auto pEntityScript = Find(pEntityClass->GetName());
1256                         if (pEntityScript != nullptr)
1257                         {
1258                                 pEntityScript->SetClass(const_cast<IEntityClass*>(pEntityClass));
1259                         }
1260                         else
1261                         {
1262                                 pEntityScript = Insert(const_cast<IEntityClass*>(pEntityClass));
1263                         }
1264
1265                         if (pEntityScript)
1266                         {
1267                                 if (event == ECRE_CLASS_REGISTERED)
1268                                 {
1269                                         m_scriptAdded(pEntityScript.get());
1270                                 }
1271                                 else
1272                                 {
1273                                         m_scriptChanged(pEntityScript.get());
1274                                 }
1275                         }
1276
1277                         // We only need to reload entities in case a script class was changed, since schematyc handles reloading themself.
1278                         if (pEntityClass->GetScriptFile() != nullptr && pEntityClass->GetScriptFile()[0] != '\0')
1279                         {
1280                                 m_needsScriptReload = true;
1281                         }
1282                 }
1283                 break;
1284         case ECRE_CLASS_UNREGISTERED:
1285                 {
1286                         auto pEntityScript = Find(pEntityClass->GetName());
1287
1288                         m_scriptRemoved(pEntityScript.get());
1289                         m_scripts.erase(pEntityClass->GetName());
1290                 }
1291                 break;
1292         }
1293 }
1294
1295 void CEntityScriptRegistry::OnEditorNotifyEvent(EEditorNotifyEvent event)
1296 {
1297         if (event == eNotify_OnIdleUpdate && m_needsScriptReload)
1298         {
1299                 m_needsScriptReload = false;
1300                 GetIEditorImpl()->GetICommandManager()->Execute("entity.reload_all_scripts");
1301         }
1302 }
1303
1304 std::shared_ptr<CEntityScript> CEntityScriptRegistry::Find(const char* szName) const
1305 {
1306         auto it = m_scripts.find(szName);
1307         if (it != m_scripts.end())
1308         {
1309                 return it->second;
1310         }
1311
1312         return nullptr;
1313 }
1314
1315 std::shared_ptr<CEntityScript> CEntityScriptRegistry::Insert(IEntityClass* pClass, const char* szAlias)
1316 {
1317         if (strlen(szAlias) == 0)
1318         {
1319                 szAlias = pClass->GetName();
1320         }
1321
1322         auto scriptIt = m_scripts.find(szAlias);
1323
1324         // Check if inserting already exist script, if so ignore.
1325         if (scriptIt != m_scripts.end())
1326         {
1327                 Error("Inserting duplicate Entity Script %s", szAlias);
1328                 return scriptIt->second;
1329         }
1330
1331         scriptIt = m_scripts.emplace(std::make_pair(string(szAlias), std::make_shared<CEntityScript>(pClass))).first;
1332
1333         SetClassCategory(scriptIt->second.get());
1334         return scriptIt->second;
1335 }
1336
1337 void CEntityScriptRegistry::SetClassCategory(CEntityScript* script)
1338 {
1339         IScriptSystem* scriptSystem = GetIEditorImpl()->GetSystem()->GetIScriptSystem();
1340
1341         SmartScriptTable pEntity(scriptSystem, true);
1342         if (!scriptSystem->GetGlobalValue(script->GetName(), pEntity))
1343                 return;
1344
1345         SmartScriptTable pEditor(scriptSystem, true);
1346         if (pEntity->GetValue("Editor", pEditor))
1347         {
1348                 const char* clsCategory;
1349                 if (pEditor->GetValue("Category", clsCategory))
1350                 {
1351                         SEditorClassInfo editorClassInfo(script->GetClass()->GetEditorClassInfo());
1352                         editorClassInfo.sCategory = clsCategory;
1353                         script->GetClass()->SetEditorClassInfo(editorClassInfo);
1354                 }
1355         }
1356 }
1357
1358 void CEntityScriptRegistry::IterateOverScripts(std::function<void(CEntityScript&)> callback)
1359 {
1360         for (auto it = m_scripts.begin(); it != m_scripts.end(); ++it)
1361         {
1362                 callback(*it->second);
1363         }
1364 }
1365
1366 //////////////////////////////////////////////////////////////////////////
1367 void CEntityScriptRegistry::Reload()
1368 {
1369         IEntityClassRegistry* pClassRegistry = gEnv->pEntitySystem->GetClassRegistry();
1370         pClassRegistry->LoadClasses("entities.xml", true);
1371         LoadScripts();
1372 }
1373
1374 //////////////////////////////////////////////////////////////////////////
1375 void CEntityScriptRegistry::LoadScripts()
1376 {
1377         m_scripts.clear();
1378
1379         IEntityClassRegistry* pClassRegistry = gEnv->pEntitySystem->GetClassRegistry();
1380         IEntityClass* pClass = NULL;
1381         pClassRegistry->IteratorMoveFirst();
1382         while (pClass = pClassRegistry->IteratorNext())
1383         {
1384                 Insert(pClass);
1385         }
1386 }
1387
1388 //////////////////////////////////////////////////////////////////////////
1389 CEntityScriptRegistry* CEntityScriptRegistry::Instance()
1390 {
1391         if (!m_instance)
1392         {
1393                 m_instance = new CEntityScriptRegistry;
1394         }
1395         return m_instance;
1396 }
1397
1398 //////////////////////////////////////////////////////////////////////////
1399 void CEntityScriptRegistry::Release()
1400 {
1401         if (m_instance)
1402         {
1403                 delete m_instance;
1404         }
1405         m_instance = 0;
1406 }