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;
}
