void Engine::init() { _engine->SetMessageCallback(asMETHOD(Engine, messageCallback), this, asCALL_THISCALL); RegisterStdString(_engine); RegisterScriptHandle(_engine); RegisterScriptAny(_engine); }
void RectCollideService::registerToEngine(asIScriptEngine* e) { engine = e; RectCollideServiceDone::ID = engine->RegisterObjectType("RectCollideServiceDone", sizeof(RectCollideServiceDone), asOBJ_VALUE | asOBJ_POD); RegisterScriptHandle(engine); engine->RegisterObjectType("CollidableRect", sizeof(CollidableRect), asOBJ_REF | asOBJ_NOCOUNT); engine->RegisterObjectProperty("CollidableRect", "float x", asOFFSET(CollidableRect,x)); engine->RegisterObjectProperty("CollidableRect", "float y", asOFFSET(CollidableRect,y)); engine->RegisterObjectProperty("CollidableRect", "float w", asOFFSET(CollidableRect,w)); engine->RegisterObjectProperty("CollidableRect", "float h", asOFFSET(CollidableRect,h)); engine->RegisterObjectProperty("CollidableRect", "float vx", asOFFSET(CollidableRect,vx)); engine->RegisterObjectProperty("CollidableRect", "float vy", asOFFSET(CollidableRect,vy)); engine->RegisterObjectProperty("CollidableRect", "bool blockable", asOFFSET(CollidableRect,blockable)); engine->RegisterObjectProperty("CollidableRect", "bool blocking", asOFFSET(CollidableRect,blocking)); engine->RegisterObjectProperty("CollidableRect", "bool active", asOFFSET(CollidableRect,active)); engine->RegisterObjectProperty("CollidableRect", "ref@ object", asOFFSET(CollidableRect,objHandle)); engine->RegisterEnum("CollisionDirection"); engine->RegisterEnumValue("CollisionDirection", "UP", CollisionDirection::UP); engine->RegisterEnumValue("CollisionDirection", "DOWN", CollisionDirection::DOWN); engine->RegisterEnumValue("CollisionDirection", "LEFT", CollisionDirection::LEFT); engine->RegisterEnumValue("CollisionDirection", "RIGHT", CollisionDirection::RIGHT); RectCollision::ID = engine->RegisterObjectType("RectCollision", sizeof(RectCollision), asOBJ_REF | asOBJ_NOCOUNT); engine->RegisterObjectProperty("RectCollision", "CollidableRect a", asOFFSET(RectCollision,a)); engine->RegisterObjectProperty("RectCollision", "CollidableRect b", asOFFSET(RectCollision,b)); engine->RegisterObjectProperty("RectCollision", "CollisionDirection direction", asOFFSET(RectCollision,direction)); engine->RegisterObjectType("RectCollideServiceType", 0, asOBJ_REF | asOBJ_NOCOUNT); engine->RegisterObjectMethod("RectCollideServiceType", "CollidableRect@ createRect(?&in, float, float, float, float, float, float, bool, bool, bool)", asMETHOD(RectCollideService, createRect), asCALL_THISCALL); engine->RegisterGlobalProperty("RectCollideServiceType RectCollideService", this); }
bool Test() { RET_ON_MAX_PORT bool fail = false; int r; COutStream out; CBufferedOutStream bout; // asIScriptContext *ctx; asIScriptEngine *engine; // asIScriptModule *mod; // Test circular reference between grid and ref { engine = asCreateScriptEngine(); engine->SetMessageCallback(asMETHOD(COutStream, Callback), &out, asCALL_THISCALL); RegisterScriptHandle(engine); RegisterScriptGrid(engine); // Create the circular reference r = ExecuteString(engine, "grid<ref> a; a.resize(1,1); @a[0,0] = a;"); if (r != asEXECUTION_FINISHED) TEST_FAILED; engine->GarbageCollect(); asUINT currSize, totDestroy, totDetect; engine->GetGCStatistics(&currSize, &totDestroy, &totDetect); if (currSize != 0 || totDestroy != 1 || totDetect != 1) TEST_FAILED; engine->ShutDownAndRelease(); } // Test empty initialization list // http://www.gamedev.net/topic/658849-empty-array-initialization/ { engine = asCreateScriptEngine(ANGELSCRIPT_VERSION); engine->SetMessageCallback(asMETHOD(COutStream, Callback), &out, asCALL_THISCALL); RegisterScriptGrid(engine); r = ExecuteString(engine, "grid<int> a = {};"); // Valid 0x0 grid if( r != asEXECUTION_FINISHED ) TEST_FAILED; r = ExecuteString(engine, "grid<int> a = {{}};"); // Valid 0x1 grid if( r != asEXECUTION_FINISHED ) TEST_FAILED; r = ExecuteString(engine, "grid<int> a = {{},{}};"); // Valid 0x2 grid if( r != asEXECUTION_FINISHED ) TEST_FAILED; engine->Release(); } // Test grid object forcibly destroyed by garbage collector // http://www.gamedev.net/topic/657955-a-quite-specific-bug/ { engine = asCreateScriptEngine(ANGELSCRIPT_VERSION); engine->SetMessageCallback(asMETHOD(COutStream, Callback), &out, asCALL_THISCALL); RegisterScriptGrid(engine); RegisterScriptAny(engine); RegisterScriptArray(engine, false); asIScriptModule *mod = engine->GetModule("test", asGM_ALWAYS_CREATE); mod->AddScriptSection("test", "class B {} \n" "class A \n" "{ \n" " any a; \n" " grid<B@> t(10, 10); \n" " A() \n" " { \n" " a.store(@this); \n" " } \n" "} \n" "array<A@> arr; \n" "void main() \n" "{ \n" " arr.insertLast(@A()); \n" "} \n"); r = mod->Build(); if( r < 0 ) TEST_FAILED; // The type B is not really garbage collected asITypeInfo *t = mod->GetTypeInfoByDecl("B"); if( t == 0 || (t->GetFlags() & asOBJ_GC) ) TEST_FAILED; // grid<B> is not garbage collected since B is not t = mod->GetTypeInfoByDecl("grid<B>"); if( t == 0 || (t->GetFlags() & asOBJ_GC) ) TEST_FAILED; // grid<B@> is however garbage collected because it is not possible to know // that no class derived from B can't form a circular reference with it. t = mod->GetTypeInfoByDecl("grid<B@>"); if( t == 0 || !(t->GetFlags() & asOBJ_GC) ) TEST_FAILED; r = ExecuteString(engine, "main()", mod); if( r != asEXECUTION_FINISHED ) TEST_FAILED; engine->Release(); } // Test resize { engine = asCreateScriptEngine(ANGELSCRIPT_VERSION); engine->SetMessageCallback(asMETHOD(COutStream, Callback), &out, asCALL_THISCALL); RegisterScriptGrid(engine); RegisterStdString(engine); engine->RegisterGlobalFunction("void assert(bool)", asFUNCTION(Assert), asCALL_GENERIC); r = ExecuteString(engine, "grid<string> g; \n" "g.resize(1,1); \n" "g[0,0] = 'hello'; \n" "g.resize(2,2); \n" "assert( g[0,0] == 'hello' ); \n" "g[1,1] = 'there'; \n" "g.resize(1,1); \n" "assert( g.width() == 1 && g.height() == 1 ); \n"); if( r != asEXECUTION_FINISHED ) TEST_FAILED; engine->Release(); } // Test initialization lists { engine = asCreateScriptEngine(ANGELSCRIPT_VERSION); engine->SetMessageCallback(asMETHOD(COutStream, Callback), &out, asCALL_THISCALL); RegisterScriptGrid(engine); RegisterStdString(engine); engine->RegisterGlobalFunction("void assert(bool)", asFUNCTION(Assert), asCALL_GENERIC); r = ExecuteString(engine, "grid<int8> g = {{1,2,3},{4,5,6},{7,8,9}}; \n" "assert( g[0,0] == 1 ); \n" "assert( g[2,2] == 9 ); \n" "assert( g[0,2] == 7 ); \n"); if( r != asEXECUTION_FINISHED ) TEST_FAILED; r = ExecuteString(engine, "grid<string> g = {{'1','2'},{'4','5'}}; \n" "assert( g[0,0] == '1' ); \n" "assert( g[1,1] == '5' ); \n" "assert( g[0,1] == '4' ); \n"); if( r != asEXECUTION_FINISHED ) TEST_FAILED; r = ExecuteString(engine, "grid<grid<int>@> g = {{grid<int> = {{1}}, grid<int> = {{2}}}, {grid<int> = {{3}}, grid<int> = {{4}}}}; \n" "assert( g[0,0][0,0] == 1 ); \n" "assert( g[1,1][0,0] == 4 ); \n"); if( r != asEXECUTION_FINISHED ) TEST_FAILED; engine->Release(); } // Success return fail; }
bool Test() { bool fail = false; int r; COutStream out; CBufferedOutStream bout; asIScriptContext *ctx; asIScriptEngine *engine; { engine = asCreateScriptEngine(ANGELSCRIPT_VERSION); engine->SetMessageCallback(asMETHOD(COutStream,Callback), &out, asCALL_THISCALL); RegisterScriptHandle(engine); RegisterScriptArray(engine, false); engine->RegisterGlobalFunction("void assert(bool)", asFUNCTION(Assert), asCALL_GENERIC); engine->RegisterGlobalFunction("void ReceiveRefByVal(ref@)", asFUNCTION(ReceiveRefByValue), asCALL_CDECL); engine->RegisterGlobalFunction("void ReceiveRefByRef(ref&in)", asFUNCTION(ReceiveRefByRef), asCALL_CDECL); const char *script = "class A {} \n" "class B {} \n" "void main() \n" "{ \n" " ref@ ra, rb; \n" " A a; B b; \n" // Assignment of reference " @ra = @a; \n" " assert( ra is a ); \n" " @rb = @b; \n" // Casting to reference " A@ ha = cast<A>(ra); \n" " assert( ha !is null ); \n" " B@ hb = cast<B>(ra); \n" " assert( hb is null ); \n" // Assigning null, and comparing with null " @ra = null; \n" " assert( ra is null ); \n" " func2(ra); \n" // Handle assignment with explicit handle " @ra = @rb; \n" " assert( ra is b ); \n" " assert( rb is b ); \n" " assert( ra is rb ); \n" // Handle assignment with implicit handle " @rb = rb; \n" " assert( rb is b ); \n" " assert( ra is rb ); \n" // Function call and return value " @rb = func(rb); \n" " assert( rb is b ); \n" " assert( func(rb) is b ); \n" // Arrays of handles " array<ref@> arr(2); \n" " assert( arr[0] is null ); \n" " @arr[0] = a; \n" " @arr[1] = a; \n" " assert( arr[0] is arr[1] ); \n" " assert( arr[0] is a ); \n" // Implicit conv from type to ref " func2(null); \n" " func(a); \n" " assert( func(a) is a ); \n" "} \n" "ref@ func(ref@ r) { return r; } \n" "void func2(ref@r) { assert( r is null ); } \n"; asIScriptModule *mod = engine->GetModule(0, asGM_ALWAYS_CREATE); mod->AddScriptSection(TESTNAME, script); r = mod->Build(); if( r < 0 ) { TEST_FAILED; printf("%s: Failed to compile the script\n", TESTNAME); } ctx = engine->CreateContext(); r = ExecuteString(engine, "main()", mod, ctx); if( r != asEXECUTION_FINISHED ) { if( r == asEXECUTION_EXCEPTION ) PrintException(ctx); printf("%s: Failed to execute script\n", TESTNAME); TEST_FAILED; } if( ctx ) ctx->Release(); r = ExecuteString(engine, "ref @r; ReceiveRefByVal(r);", mod); if( r != asEXECUTION_FINISHED ) TEST_FAILED; // This will cause an implicit cast to 'ref'. The object must be release properly afterwards r = ExecuteString(engine, "ReceiveRefByRef(A());", mod); if( r != asEXECUTION_FINISHED ) TEST_FAILED; engine->Release(); } // Success return fail; }