ScriptMgr.h

#ifndef _SCRIPTMGR_H_
#define _SCRIPTMGR_H_

#include <stdio.h>
#include <io.h>
#include <set>
// AngelScript
#include "ZakEngine/Messages.h"
#include "ZakEngine/FileLog.h"
#include "ZakEngine/defines.h"
#include "ZakEngine/MathUtil.h"
#include "ZakEngine/Input.h"
#include "ZakEngine/list.h"
#include "angelscript.h"
#include "asvectorhelper.h"
#include "Script.h"

#ifdef _DEBUG
#pragma comment(lib, "angelscriptd.lib")
#else
#pragma comment(lib, "angelscript.lib")
#endif 

namespace zak { 

class Script;

class BinaryOutput : public asIBinaryStream {

        FILE *_file;

        BinaryOutput(){}

public:
        void Read(void *ptr, asUINT size) {
                fread(ptr, 1, size, _file);
        }
        void Write(const void *ptr, asUINT size) {
                fwrite(ptr, 1, size, _file);
        }

        BinaryOutput(const char* fname, const char* mode) {
                fopen_s(&_file, fname, mode); 
        }
        ~BinaryOutput() { if (_file) fclose(_file); _file = NULL; }
};

class ZAKENGINE_API ScriptMgr
{ 
public:

        static bool StartUp();

        static void Shutdown();

        static int RegisterGlobalProperty(char *szDecl, void* var) 
        { 
                return _asEngine->RegisterGlobalProperty(szDecl, var); 
        }

        static int RegisterGlobalFunction(char *szDecl, asUPtr funcPointer, asDWORD callConv) 
        { 
                return _asEngine->RegisterGlobalFunction(szDecl, funcPointer, callConv); 
        }

        static int RegisterObjectType (const char *szClassName, int iSize, asDWORD flags) 
        { 
                return _asEngine->RegisterObjectType(szClassName, iSize, flags); 
        }

        static int RegisterObjectProperty (const char *szClassName, const char *szPropertyDecl, int byteOffset) 
        { 
                return _asEngine->RegisterObjectProperty(szClassName, szPropertyDecl, byteOffset); 
        }

        static int RegisterObjectMethod(const char *szClassName, const char *szDecl, asUPtr funcPointer, asDWORD callConv) 
        {
                return _asEngine->RegisterObjectMethod(szClassName, szDecl, funcPointer, callConv); 
        }

        static int RegisterObjectBehaviour(const char *szClassName, asDWORD behaviour, const char *szDeclaration, asUPtr funcPointer, asDWORD callConv) 
        {
                return _asEngine->RegisterObjectBehaviour(szClassName, behaviour, szDeclaration, funcPointer, callConv);
        }

        static Script*  AddScript(char *szModule, char *szSection);

        static bool             RemoveScript(Script *script);

        static bool             ClearScriptList();

        static bool             CompileModule(char *szModule);

        static bool             ExecuteString(char *szModule, char *script) { return ExecuteString(szModule, script, NULL); }


        static bool LoadByteCode (char *szModule, char *szFilename); // TODO
        static bool SaveByteCode (char *szModule, char *szFilename); // TODO

        static asIScriptEngine *GetEngine() { return _asEngine; }

private: 
        static bool RegisterClasses();

        static void ConsoleTrace(string str) { Console::Trace(str); }
        static void ConsoleTrace(float var) { Console::Trace("%3.5f",var); }
        static void ConsoleTrace(double var) { Console::Trace("%3.5e",var); }
        static void ConsoleTrace(int var) { Console::Trace("%d",var); }
        static void ConsoleTrace(bool var) { (var?Console::Trace("true"):Console::Trace("false")); }
        static void ConsoleTrace(asUINT var) { Console::Trace("%u",var); }
        static void LogTrace(string str) { Log.Trace("%s\n", str.c_str()); }
        static void LogTrace(float var) { Log.Trace("%3.5f\n", var); }
        static void LogTrace(bool var) { (var?Log.Trace("true\n"):Log.Trace("false\n")); }
        static void LogTrace(double var) { Log.Trace("%3.5e\n", var); }
        static void LogTrace(int var) { Log.Trace("%d\n", var); }
        static void LogTrace(asUINT var) { Log.Trace("%u\n", var); }

        static float scriptRadToDegree(float angle);
        static float scriptDegreeToRad(float angle);

        static BYTE scriptKeyDown(BYTE key);
        static BYTE scriptKeyUp(BYTE key);
        static BYTE scriptKeyPressed(BYTE key);

        static BYTE scriptMousePress(BYTE btn);
        static bool scriptMouseClick(BYTE btn);
        static long scriptMouseRelPos(BYTE btn);
        static long scriptMouseAbsPos(BYTE btn);
        static long scriptMouseWorldPos(BYTE btn);
        static float scriptMouseRelPosf(BYTE btn);
        static float scriptMouseAbsPosf(BYTE btn);
        static float scriptMouseWorldPosf(BYTE btn);

        static long scriptJoystickPos(int devNum, int axis);
        static long scriptJoystickRot(int devNum, int axis);
        static float scriptJoystickPosf(int devNum, int axis); 
        static float scriptJoystickRotf(int devNum, int axis);
        static BYTE scriptJoystickButtons(int devNum, int button);
        static int scriptJoystickCount();

        static void ConsoleExecute(string arg);
        static void ConsoleExecuteM(string arg);
        static void ConsoleGet(string arg);

        static void ConstructIntArray(vector<int> *self) {
                new(self) vector<int>();
        }

        static void ConstructIntArray(int length, vector<int> *self) {
                new(self) vector<int>(length);
        }

        static void DestructIntArray(vector<int> *self) {
                self->~vector();
        }


        static void ConstructBoolArray(vector<bool> *self) {
                new(self) vector<bool>();
        }

        static void ConstructBoolArray(int length, vector<bool> *self) {
                new(self) vector<bool>(length);
        }

        static void DestructBoolArray(vector<bool> *self) {
                self->~vector();
        }

        static void ConstructDoubleArray(vector<double> *self) {
                new(self) vector<double>();
        }

        static void ConstructDoubleArray(int length, vector<double> *self) {
                new(self) vector<double>(length);
        }

        static void DestructDoubleArray(vector<double> *self) {
                self->~vector();
        }

        static void ConstructULongArray(vector<unsigned long> *self) {
                new(self) vector<unsigned long>();
        }

        static void ConstructULongArray(int length, vector<unsigned long> *self) {
                new(self) vector<unsigned long>(length);
        }

        static void DestructULongArray(vector<unsigned long> *self) {
                self->~vector();
        }

        static void ConstructUInt8Array(vector<unsigned char> *self) {
                new(self) vector<unsigned char>();
        }

        static void ConstructUInt8Array(int length, vector<unsigned char> *self) {
                new(self) vector<unsigned char>(length);
        }

        static void DestructUInt8Array(vector<unsigned char> *self) {
                self->~vector();
        }


        static void ConstructUInt16Array(vector<unsigned short> *self) {
                new(self) vector<unsigned short>();
        }

        static void ConstructUInt16Array(int length, vector<unsigned short> *self) {
                new(self) vector<unsigned short>(length);
        }

        static void DestructUInt16Array(vector<unsigned short> *self) {
                self->~vector();
        }

        static void ConstructInt8Array(vector<char> *self) {
                new(self) vector<char>();
        }

        static void ConstructInt8Array(int length, vector<char> *self) {
                new(self) vector<char>(length);
        }

        static void DestructInt8Array(vector<char> *self) {
                self->~vector();
        }


        static void ConstructInt16Array(vector<short> *self) {
                new(self) vector<short>();
        }

        static void ConstructInt16Array(int length, vector<short> *self) {
                new(self) vector<short>(length);
        }

        static void DestructInt16Array(vector<short> *self) {
                self->~vector();
        }

        static void ConstructLongArray(vector<long> *self);
        static void ConstructLongArray(int length, vector<long> *self);
        static void DestructLongArray(vector<long> *self);

        static void ConstructFloatArray(vector<float> *self);
        static void ConstructFloatArray(int length, vector<float> *self);
        static void DestructFloatArray(vector<float> *self);

        static bool LoadScript (char *szFilename, char *szModule, char *szSection);
        static bool LoadScript (char *szFilename, string &script, string &dir);


        static int  ProcessInclude (string &script, string &dir);

        static asIScriptContext* CreateContext() { return _asEngine->CreateContext(); }

        static int ReleaseContext(asIScriptContext *gsContext) { return gsContext->Release(); }
        static int Prepare(asIScriptContext *asContext, int iFunctionId) { return asContext->Prepare(iFunctionId); }
        static int Execute (asIScriptContext *asContext) { return asContext->Execute(); }
        static bool ExecuteString (char *szModule, char *script, asIScriptContext **asContext, asDWORD flags=0); 

        static int GetFuncIDByDecl(char *szModule, char *szFuncDecl) { return _asEngine->GetFunctionIDByDecl(szModule, szFuncDecl); }
        static const char *GetFuncDeclaration(int funcId) { return _asEngine->GetFunctionDeclaration(funcId);}

        static void MessageCallback(const asSMessageInfo *msg, void *param);

        static asIScriptEngine  *_asEngine;
        static List<Script*>    _list;
        static set<string>              _includedScripts;


        friend class Script;
};

} // end namespace 

#endif // _SCRIPTMGR_H_

---