scripting/ScriptManager.cpp

Go to the documentation of this file.

// /////////////////////////////////////////////////////////////////////////////
//
// Name:            ScriptManager.cpp
// Author:          Michael Bartsch (ZCCdark203)
//
// Desc :           The Script Manager is the central interface point to all
//                  script related functions of this program.
//
// License:         Copyright (C) 2009 Michael Bartsch and Contributors
//
//                  This program is free software: you can redistribute it
//                  and/or modify it under the terms of the zlib/libpng License.
//                  See main.cpp for conditions of distribution and use.
//
// /////////////////////////////////////////////////////////////////////////////

// Include files
#include "ScriptManager.h"
#include "irrlicht/asIrrlicht.h"
#include "../core/GameManager.h"


// ScriptManager class
// Constructor of the ScriptManager class.
ScriptManager::ScriptManager()
{
}

// Deconstructor of the ScriptManager class.
ScriptManager::~ScriptManager()
{
}

// Initialises the Script Manager.
void ScriptManager::init()
{
    // Initialise the AngelScript engine.
    pEngine = asCreateScriptEngine(ANGELSCRIPT_VERSION);

    RegisterScriptString(pEngine);
    pEngine->SetMessageCallback(asFUNCTION(MessageCallback), 0, asCALL_CDECL);

    // Register typedefs.
    pEngine->RegisterTypedef("c8",  "int8");
    pEngine->RegisterTypedef("f32", "float");
    pEngine->RegisterTypedef("f64", "double");
    pEngine->RegisterTypedef("s16", "int16");
    pEngine->RegisterTypedef("s32", "int");
    pEngine->RegisterTypedef("u16", "uint16");
    pEngine->RegisterTypedef("u32", "uint");
    pEngine->RegisterTypedef("u8",  "uint8");

    // Register Irrlicht.
    bindIrrlicht(pEngine);

    // Register classes and functions.
    bindEntity(pEngine);
    bindEntityComponent(pEngine);
    bindComponents(pEngine);
    bindEntityManager(pEngine);
    bindEventManager(pEngine);
    bindDataStack(pEngine);
    bindDataStore(pEngine);
    bindSoundManager(pEngine);
    bindScript(pEngine);
    bindScriptManager(pEngine);
    bindGameState(pEngine);
    bindGameManager(pEngine);
}

// Clears the Script Manager.
void ScriptManager::clear()
{
    // Remove scripts.
    removeAllScripts();

    // Remove script sections.
    mScriptSections.clear();

    // Deinitialise the AngelScript engine.
    pEngine->Release();
}

// Angelscript: Increases the reference counter.
void ScriptManager::refAdd()
{
    // Dummy function.
}

// Angelscript: Decreases the reference counter.
void ScriptManager::refRelease()
{
    // Dummy function.
}

// Gets the AngelScript engine.
asIScriptEngine* ScriptManager::getEngine() const
{
    return pEngine;
}

// Adds a script to the Script Manager.
bool ScriptManager::addScript(Script *script)
{
    // Did we get a valid pointer?
    if(script == NULL)
      return false;

    // Look if a script with given name doesn't already exist.
    if(getScript(script->getName()))
      return false;

    // Add the script.
    mScripts.push_back(script);

    return true;
}

// Adds a script section to the Script Manager.
bool ScriptManager::addScriptSection(const std::string &name, const std::string &section)
{
    // Does the script section already exist?
    if(mScriptSections.find(name) != mScriptSections.end())
      return false;

    // Add the new script section.
    mScriptSections[name] = section;

    return true;
}

// Adds the standard script sections to the given script.
void ScriptManager::addScriptSectionsToScript(Script *script)
{
    // Did we get a valid pointer?
    if(script == NULL)
      return;

    // Add the sections.
    asIScriptModule *module = script->getModule();
    std::map<std::string, std::string>::iterator it;

    for(it = mScriptSections.begin(); it != mScriptSections.end(); it++)
      module->AddScriptSection((it->first).c_str(), (it->second).c_str());
}

// Creates (and adds) an script with the given name.
Script* ScriptManager::createScript(const std::string &name)
{
    // Look if a script with given name doesn't already exist.
    if(getScript(name))
      return NULL;

    // Add the script.
    Script *script = new Script(name);
    mScripts.push_back(script);
    return script;
}

// Creates an script with the given name, loaded from the given file.
Script* ScriptManager::createScriptFromFile(const std::string &fileName)
{
    // Get pointer to the File System of Irrlicht.
    IFileSystem *fileSystem = GameManager::Instance()->getDevice()->getFileSystem();

    // Retrieve base name.
    core::stringw wFilename = core::stringw(fileName.c_str());
    std::string fileBase = (fileSystem->getFileBasename(wFilename)).c_str();

    // Look if a script with given name doesn't already exist.
    if(getScript(fileBase))
      return NULL;

    // Add the script.
    Script *script = new Script(fileBase);
    script->loadScript(fileName);
    mScripts.push_back(script);
    return script;
}

// Gets the script with the given ID.
Script* ScriptManager::getScript(const u32 id)
{
    for(u32 i = 0; i < mScripts.size(); i++)
    {
       if(mScripts[i]->getID() == id)
         return mScripts[i];
    }

    return NULL;
}

// Gets the script with the given name.
Script* ScriptManager::getScript(const std::string &name)
{
    for(u32 i = 0; i < mScripts.size(); i++)
    {
       if(mScripts[i]->getName() == name)
         return mScripts[i];
    }

    return NULL;
}

// Removes all scripts.
void ScriptManager::removeAllScripts()
{
    for(u32 i = 0; i < mScripts.size(); i++)
      delete mScripts[i];

    mScripts.clear();
}

// Removes all script sections,
void ScriptManager::removeAllScriptSections()
{
    mScriptSections.clear();
}

// Removes the given script.
bool ScriptManager::removeScript(Script *script)
{
    // Did we get a valid pointer?
    if(script == NULL)
      return false;

    // Try to remove the script.
    vector<Script*>::iterator it;

    for(it = mScripts.begin(); it < mScripts.end(); it++)
    {
        Script *scr = *it;

        if(scr == script)
        {
           delete scr;
           mScripts.erase(it);
           return true;
        }
    }

    // We couldn't find the script and thus couldn't remove it.
    return false;
}

// Removes the script with the given ID.
bool ScriptManager::removeScript(const u32 id)
{
    // Try to remove the script.
    vector<Script*>::iterator it;

    for(it = mScripts.begin(); it < mScripts.end(); it++)
    {
        Script *scr = *it;

        if(scr->getID() == id)
        {
           delete scr;
           mScripts.erase(it);
           return true;
        }
    }

    // We couldn't find the script and thus couldn't remove it.
    return false;
}

// Removes the script with the given name.
bool ScriptManager::removeScript(const std::string &name)
{
    // Try to remove the script.
    vector<Script*>::iterator it;

    for(it = mScripts.begin(); it < mScripts.end(); it++)
    {
        Script *scr = *it;

        if(scr->getName() == name)
        {
           delete scr;
           mScripts.erase(it);
           return true;
        }
    }

    // We couldn't find the script and thus couldn't remove it.
    return false;
}

// Removes the script section with the given name.
bool ScriptManager::removeScriptSection(const std::string &name)
{
    // Try to remove the script.
    std::map<std::string, std::string>::iterator it;
    it = mScriptSections.find(name);

    if(it != mScriptSections.end())
    {
       mScriptSections.erase(it);
       return true;
    }

    // We couldn't find the script section and thus couldn't remove it.
    return false;
}


// ScriptManager Angelscript binding.
void bindScriptManager(asIScriptEngine *engine)
{
    // Forward declarations.
    int r;

    // Bind DataStore class.
    r = engine->RegisterObjectType("ScriptManager", sizeof(ScriptManager), asOBJ_REF); assert(r >= 0);

    // Set DataStore behaviour.
    r = engine->RegisterObjectBehaviour("ScriptManager", asBEHAVE_ADDREF, "void f()",
                                        asMETHOD(ScriptManager, refAdd), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectBehaviour("ScriptManager", asBEHAVE_RELEASE, "void f()",
                                        asMETHOD(ScriptManager, refRelease), asCALL_THISCALL); assert(r >= 0);

    // Bind DataStore class functions.
    r = engine->RegisterObjectMethod("ScriptManager", "void init()",
                                     asMETHOD(ScriptManager, init), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("ScriptManager", "void clear()",
                                     asMETHOD(ScriptManager, clear), asCALL_THISCALL); assert(r >= 0);

    r = engine->RegisterObjectMethod("ScriptManager", "bool addScript(Script @)",
                                     asMETHOD(ScriptManager, addScript), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("ScriptManager", "Script@ createScript(const string &)",
                                     asMETHOD(ScriptManager, createScript), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("ScriptManager", "Script@ createScriptFromFile(const string &)",
                                     asMETHOD(ScriptManager, createScriptFromFile), asCALL_THISCALL); assert(r >= 0);

    r = engine->RegisterObjectMethod("ScriptManager", "Script@ getScript(const u32)",
                                     asMETHODPR(ScriptManager, getScript, (const u32), Script*),
                                     asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("ScriptManager", "Script@ getScript(const string &)",
                                     asMETHODPR(ScriptManager, getScript, (const std::string &), Script*),
                                     asCALL_THISCALL); assert(r >= 0);

    r = engine->RegisterObjectMethod("ScriptManager", "void removeAllScripts()",
                                     asMETHOD(ScriptManager, removeAllScripts), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("ScriptManager", "bool removeScript(Script @)",
                                     asMETHODPR(ScriptManager, removeScript, (Script*), bool),
                                     asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("ScriptManager", "bool removeScript(const u32)",
                                     asMETHODPR(ScriptManager, removeScript, (const u32), bool),
                                     asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("ScriptManager", "bool removeScript(const string &)",
                                     asMETHODPR(ScriptManager, removeScript, (const std::string &), bool),
                                     asCALL_THISCALL); assert(r >= 0);
}

// AngelScript functions
// Implement a simple message callback function
void MessageCallback(const asSMessageInfo *msg, void *param)
{
  const char *type = "ERR ";
  if(msg->type == asMSGTYPE_WARNING)
    type = "WARN";
  else if(msg->type == asMSGTYPE_INFORMATION)
    type = "INFO";
  printf("%s (%d, %d) : %s : %s\n", msg->section, msg->row, msg->col, type, msg->message);
}

// End of File

---