void ToolShoot::activate()
{
// debemos crear una instancia del arma y de la munición que dispara
ToolAnimData data;
std::string name;
Direction dir = player->getDir();
// Ejecutamos la animación correspondiente en función de la dirección a la que mira el player
switch(dir){
case UP:
name = "up";
break;
case DOWN:
name = "down";
break;
case LEFT:
name = "left";
break;
case UPLEFT:
name = "left";
break;
case DOWNLEFT:
name = "left";
break;
case RIGHT:
name = "right";
break;
case UPRIGHT:
name = "right";
break;
case DOWNRIGHT:
name = "right";
break;
}
data = animList.at(name); // cogemos los datos de la animación
playAnim(name); // ejecutamos la animación
player->playAnim(playeranim, data.animSpeed); // Hacemos que el player ejecute la animación
placeTool(); // Colocamos el arma en función de la animación actual
// creamos la munición (en pruebas)
ammo = new ToolAmmo(this->x, this->y, this->game, this->world);
ammo->init(false, this->player, this->idTool, damage, damageType, ammoGfxpath, dir);
game->getGameState()->add(ammo);
}
LLPreviewAnim::LLPreviewAnim(const std::string& name, const LLRect& rect, const std::string& title, const LLUUID& item_uuid, const S32& activate, const LLUUID& object_uuid ) :
LLPreview( name, rect, title, item_uuid, object_uuid)
{
LLUICtrlFactory::getInstance()->buildFloater(this,"floater_preview_animation.xml");
childSetAction("Anim play btn",playAnim,this);
childSetAction("Anim audition btn",auditionAnim,this);
const LLInventoryItem* item = getItem();
childSetCommitCallback("desc", LLPreview::onText, this);
childSetText("desc", item->getDescription());
childSetPrevalidate("desc", &LLLineEditor::prevalidatePrintableNotPipe);
setTitle(title);
if (!getHost())
{
LLRect curRect = getRect();
translate(rect.mLeft - curRect.mLeft, rect.mTop - curRect.mTop);
}
// preload the animation
if(item)
{
gAgent.getAvatarObject()->createMotion(item->getAssetUUID());
}
switch ( activate )
{
case 1:
{
playAnim( (void *) this );
break;
}
case 2:
{
auditionAnim( (void *) this );
break;
}
default:
{
//do nothing
}
}
}
void Level8::restart(){
BaseLevel::restart();
ring = Ring::create();
ring->setPosition(E::originX, E::originY + 96);
ring->setScale(0.2);
ring->initBody();
this->addChild(ring);
auto t = Target::create();
t->setPosition(E::originX + DESIGNED_WIDTH / 2 - 128, E::originY + 400);
t->initBody();
this->addChild(t);
t->playAnim(0);
#define MOVE_BY_X 64
auto b1 = Brick::create(256, 24);
b1->setPosition(E::originX, E::originY + 320);
b1->initBody();
this->addChild(b1);
auto b12 = Brick::create(256, 16, E::P.C800);
b12->setPosition(E::originX, E::originY + 320 - 16);
b12->initBody();
b12->runAction(RepeatForever::create(Sequence::create(MoveBy::create(1.0f, Vec2(MOVE_BY_X, 0)), MoveBy::create(1.0f, Vec2(-MOVE_BY_X, 0)), nullptr)));
b12->runAction(RepeatForever::create(Sequence::create(TintTo::create(1.0f, C3B(E::P.C400)), TintTo::create(1.0f, C3B(E::P.C800)), nullptr)));
this->addChild(b12);
auto diamond1 = Diamond::create();
diamond1->setScale(0.8f);
diamond1->setRotation(-30);
diamond1->setPosition(E::originX - 128, E::originY + 256 + 64);
diamond1->initBody();
this->addChild(diamond1);
auto diamond2 = Diamond::create();
diamond2->setScale(0.8f);
diamond2->setRotation(30);
diamond2->setPosition(E::originX + DESIGNED_WIDTH + 128, E::originY + 256 + 64);
diamond2->initBody();
this->addChild(diamond2);
}
void LLPreviewAnim::activate(e_activation_type type)
{
switch ( type )
{
case PLAY:
{
playAnim( (void *) this );
break;
}
case AUDITION:
{
auditionAnim( (void *) this );
break;
}
default:
{
//do nothing
}
}
}
void Character::updateIdle() {
debugC(5, kDebugCharacter, "updateIdle()");
// only flux and drew
if (_id > 1)
return;
if (_vm->state()->_mouseHidden)
_nextIdleTime = _vm->getOldMilli() + (300 + _vm->randRange(0, 600)) * _vm->getTickLength();
if (_vm->getOldMilli() > _nextIdleTime) {
if (((_flags & 1) == 0) || ((_flags & 2) != 0)) {
if (!_vm->state()->_inCloseUp && !_vm->state()->_inCutaway && _animSpecialId == -1) {
if (!_vm->state()->_mouseHidden) {
_nextIdleTime = _vm->getOldMilli() + (300 + _vm->randRange(0, 600)) * _vm->getTickLength();
playAnim(getRandomIdleAnim(), 0, 0x40);
_flags |= 0x4;
}
}
}
}
}
void EnemyTool::activate()
{
// Si no estamos ya activados
if(!active){
collidable = true;
EnemyToolAnimData data;
std::string name;
distTravelled = 0;
// nos activamos y preparamos el timer para desactivarnos
active = true;
setTimer(1, atkCoolDown);
// seteamos la direccion
dir = enemy->dir;
// Ejecutamos la animación correspondiente en función de la dirección a la que mira el player
switch(dir){
case UP:
name = "up";
break;
case DOWN:
name = "down";
break;
case LEFT:
name = "left";
break;
case RIGHT:
name = "right";
break;
}
enabled = true;
setVisible(true);
playAnim(name); // ejecutamos la animación
placeTool(); // Colocamos el arma en función de la animación actual
}
}
void map::draw(void)
{ internalSaveBlitLimit();
if(out) setBlitLimit(out->start,out->end,out->x,out->x+out->width);
else fullBlitLimit();
clDeep *screen = out->start;
clDeep *scr ;
u32 cptx,cpty,blitPosx,blitPosy ;
u32 tile;
// left clipped colon (from up to down)
blitPosx = (out->x) - currentDecx;
blitPosy = (out->y) - currentDecy;
for(cpty=0; cpty<tiledrawy; cpty++) // show first colon in clipped
{ tile = array[firstTileBlitx+sizeInTilex*(firstTileBlity+cpty)];
if(tile)
{ if(!Animate[tile]) drawGfm(tileset[tile],blitPosx,blitPosy);
else playAnim(&Animate[tile],blitPosx,blitPosy);
}
blitPosy += tileSizey;
};
// right clipped colon
blitPosx = out->x + out->width - pixelessx;
blitPosy = out->y - currentDecy;
for(cpty=0; cpty<tiledrawy; cpty++)
{ tile = array[firstTileBlitx+tiledrawx-1+sizeInTilex*(firstTileBlity+cpty)];
if(tile)
{ if(!Animate[tile]) drawGfm(tileset[tile],blitPosx,blitPosy);
else playAnim(&Animate[tile],blitPosx,blitPosy);
}
blitPosy += tileSizey;
};
// up clipped line
blitPosx = (out->x) - currentDecx + tileSizex;
blitPosy = (out->y) - currentDecy;
for(cptx=1; cptx<uncutDrawx+morex; cptx++) // show first colon in clipped
{
tile = array[firstTileBlitx+cptx+sizeInTilex*firstTileBlity];
if(tile)
{ if(!Animate[tile]) drawGfm(tileset[tile],blitPosx,blitPosy);
else playAnim(&Animate[tile],blitPosx,blitPosy);
}
blitPosx += tileSizex;
};
// down clipped line
blitPosx = (out->x) - currentDecx + tileSizex;
blitPosy = (out->y) + out->height - pixelessy;
for(cptx=1; cptx<uncutDrawx+morex; cptx++)
{
tile = array[firstTileBlitx+cptx+sizeInTilex*(firstTileBlity+tiledrawy - 1)];
if(tile)
{ if(!Animate[tile]) drawGfm(tileset[tile],blitPosx,blitPosy);
else playAnim(&Animate[tile],blitPosx,blitPosy);
}
blitPosx += tileSizex;
};
// show map center, unclipped
screen -= currentDecy*WIDTH;
screen -= currentDecx;
for(cpty=1; cpty<uncutDrawy+morey; cpty++)
{ screen += WIDTH<<yTileDec;
scr = screen;
u32 tileOff = firstTileBlitx+1;
for(cptx=1; cptx<uncutDrawx+morex; cptx++)
{ scr += tileSizex;
tile = array[firstTileBlitx+cptx+sizeInTilex*(firstTileBlity+cpty)];
if(tile)
{ if(!Animate[tile]) udrawGfm(tileset[tile],scr);
else playAnim(&Animate[tile],scr);
}
tileOff++;
};
};
internalLoadBlitLimit();
}
void Level13::restart(){
BaseLevel::restart();
#define MOVE_BY_X 192
auto r1 = Ring::create();
r1->setPosition(E::originX, E::originY + 128);
r1->setScale(0.2);
r1->initBody();
this->addChild(r1);
r1->runAction(RepeatForever::create(Sequence::create(MoveBy::create(0.5f, Vec2(MOVE_BY_X, 0)), DelayTime::create(1.0f), MoveBy::create(0.5f, Vec2(-MOVE_BY_X, 0)), nullptr)));
auto r2 = Ring::create();
r2->setPosition(E::originX + DESIGNED_WIDTH, E::originY + 128);
r2->setScale(0.2);
r2->initBody();
this->addChild(r2);
r2->runAction(RepeatForever::create(Sequence::create(MoveBy::create(0.5f, Vec2(-MOVE_BY_X, 0)), DelayTime::create(1.0f),MoveBy::create(0.5f, Vec2(MOVE_BY_X, 0)), nullptr)));
auto t1 = Target::create();
t1->setPosition(E::originX + DESIGNED_WIDTH / 2, E::originY + 400);
t1->initBody();
t1->playAnim(1);
this->addChild(t1);
t1->initProtector();
/*
auto b_l = Brick::create(E::originX + 96, 32);
b_l->setPosition(0, E::originY + 32);
b_l->setRotation(30);
b_l->initBody();
this->addChild(b_l);
auto b_r = Brick::create(E::originX + 96, 32);
b_r->setPosition(E::originX + DESIGNED_WIDTH - 96, E::originY + 32);
b_r->setRotation(-30);
b_r->initBody();
this->addChild(b_r);
*/
ring1 = Ring::create();
ring1->setPosition(E::originX + DESIGNED_WIDTH / 2 - 80, E::originY + 400);
ring1->setScale(0.1);
ring1->initBody();
this->addChild(ring1);
ring2 = Ring::create();
ring2->setPosition(E::originX + DESIGNED_WIDTH / 2 + 80, E::originY + 400);
ring2->setScale(0.1);
ring2->initBody();
this->addChild(ring2);
auto diamond1 = Diamond::create();
diamond1->setScale(0.9f);
diamond1->setRotation(30);
diamond1->setPosition(E::originX - 128, E::originY + 256 + 64);
diamond1->initBody();
this->addChild(diamond1);
auto diamond2 = Diamond::create();
diamond2->setScale(0.9f);
diamond2->setRotation(-30);
diamond2->setPosition(E::originX + DESIGNED_WIDTH + 128, E::originY + 256 + 64);
diamond2->initBody();
this->addChild(diamond2);
angle = 0;
}
//////////////////////////////////////////////////////////////////////////
// high level scripting interface
//////////////////////////////////////////////////////////////////////////
bool AdObject::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack, const char *name) {
//////////////////////////////////////////////////////////////////////////
// PlayAnim / PlayAnimAsync
//////////////////////////////////////////////////////////////////////////
if (strcmp(name, "PlayAnim") == 0 || strcmp(name, "PlayAnimAsync") == 0) {
stack->correctParams(1);
if (DID_FAIL(playAnim(stack->pop()->getString()))) {
stack->pushBool(false);
} else {
if (strcmp(name, "PlayAnimAsync") != 0) {
script->waitFor(this);
}
stack->pushBool(true);
}
return STATUS_OK;
}
//////////////////////////////////////////////////////////////////////////
// Reset
//////////////////////////////////////////////////////////////////////////
else if (strcmp(name, "Reset") == 0) {
stack->correctParams(0);
reset();
stack->pushNULL();
return STATUS_OK;
}
//////////////////////////////////////////////////////////////////////////
// IsTalking
//////////////////////////////////////////////////////////////////////////
else if (strcmp(name, "IsTalking") == 0) {
stack->correctParams(0);
stack->pushBool(_state == STATE_TALKING);
return STATUS_OK;
}
//////////////////////////////////////////////////////////////////////////
// StopTalk / StopTalking
//////////////////////////////////////////////////////////////////////////
else if (strcmp(name, "StopTalk") == 0 || strcmp(name, "StopTalking") == 0) {
stack->correctParams(0);
if (_sentence) {
_sentence->finish();
}
if (_state == STATE_TALKING) {
_state = _nextState;
_nextState = STATE_READY;
stack->pushBool(true);
} else {
stack->pushBool(false);
}
return STATUS_OK;
}
//////////////////////////////////////////////////////////////////////////
// ForceTalkAnim
//////////////////////////////////////////////////////////////////////////
else if (strcmp(name, "ForceTalkAnim") == 0) {
stack->correctParams(1);
const char *animName = stack->pop()->getString();
delete[] _forcedTalkAnimName;
_forcedTalkAnimName = new char[strlen(animName) + 1];
strcpy(_forcedTalkAnimName, animName);
_forcedTalkAnimUsed = false;
stack->pushBool(true);
return STATUS_OK;
}
//////////////////////////////////////////////////////////////////////////
// Talk / TalkAsync
//////////////////////////////////////////////////////////////////////////
else if (strcmp(name, "Talk") == 0 || strcmp(name, "TalkAsync") == 0) {
stack->correctParams(5);
const char *text = stack->pop()->getString();
ScValue *soundVal = stack->pop();
int duration = stack->pop()->getInt();
ScValue *valStances = stack->pop();
const char *stances = valStances->isNULL() ? nullptr : valStances->getString();
int align = 0;
ScValue *val = stack->pop();
if (val->isNULL()) {
align = TAL_CENTER;
} else {
align = val->getInt();
}
align = MIN(MAX(0, align), NUM_TEXT_ALIGN - 1);
const char *sound = soundVal->isNULL() ? nullptr : soundVal->getString();
talk(text, sound, duration, stances, (TTextAlign)align);
if (strcmp(name, "TalkAsync") != 0) {
script->waitForExclusive(this);
}
stack->pushNULL();
return STATUS_OK;
}
//////////////////////////////////////////////////////////////////////////
// StickToRegion
//////////////////////////////////////////////////////////////////////////
else if (strcmp(name, "StickToRegion") == 0) {
stack->correctParams(1);
AdLayer *main = ((AdGame *)_gameRef)->_scene->_mainLayer;
bool regFound = false;
uint32 i;
ScValue *val = stack->pop();
if (val->isNULL() || !main) {
_stickRegion = nullptr;
regFound = true;
} else if (val->isString()) {
const char *regionName = val->getString();
for (i = 0; i < main->_nodes.size(); i++) {
if (main->_nodes[i]->_type == OBJECT_REGION && main->_nodes[i]->_region->getName() && scumm_stricmp(main->_nodes[i]->_region->getName(), regionName) == 0) {
_stickRegion = main->_nodes[i]->_region;
regFound = true;
break;
}
}
} else if (val->isNative()) {
BaseScriptable *obj = val->getNative();
for (i = 0; i < main->_nodes.size(); i++) {
if (main->_nodes[i]->_type == OBJECT_REGION && main->_nodes[i]->_region == obj) {
_stickRegion = main->_nodes[i]->_region;
regFound = true;
break;
}
}
}
if (!regFound) {
_stickRegion = nullptr;
}
stack->pushBool(regFound);
return STATUS_OK;
}
//////////////////////////////////////////////////////////////////////////
// SetFont
//////////////////////////////////////////////////////////////////////////
else if (strcmp(name, "SetFont") == 0) {
stack->correctParams(1);
ScValue *val = stack->pop();
if (val->isNULL()) {
setFont(nullptr);
} else {
setFont(val->getString());
}
stack->pushNULL();
return STATUS_OK;
}
//////////////////////////////////////////////////////////////////////////
// GetFont
//////////////////////////////////////////////////////////////////////////
else if (strcmp(name, "GetFont") == 0) {
stack->correctParams(0);
if (_font && _font->getFilename()) {
stack->pushString(_font->getFilename());
} else {
stack->pushNULL();
}
return STATUS_OK;
}
//////////////////////////////////////////////////////////////////////////
// TakeItem
//////////////////////////////////////////////////////////////////////////
else if (strcmp(name, "TakeItem") == 0) {
stack->correctParams(2);
if (!_inventory) {
_inventory = new AdInventory(_gameRef);
((AdGame *)_gameRef)->registerInventory(_inventory);
}
ScValue *val = stack->pop();
if (!val->isNULL()) {
const char *itemName = val->getString();
val = stack->pop();
const char *insertAfter = val->isNULL() ? nullptr : val->getString();
if (DID_FAIL(_inventory->insertItem(itemName, insertAfter))) {
script->runtimeError("Cannot add item '%s' to inventory", itemName);
} else {
// hide associated entities
((AdGame *)_gameRef)->_scene->handleItemAssociations(itemName, false);
}
} else {
script->runtimeError("TakeItem: item name expected");
}
stack->pushNULL();
return STATUS_OK;
}
//////////////////////////////////////////////////////////////////////////
// DropItem
//////////////////////////////////////////////////////////////////////////
else if (strcmp(name, "DropItem") == 0) {
stack->correctParams(1);
if (!_inventory) {
_inventory = new AdInventory(_gameRef);
((AdGame *)_gameRef)->registerInventory(_inventory);
}
ScValue *val = stack->pop();
if (!val->isNULL()) {
if (DID_FAIL(_inventory->removeItem(val->getString()))) {
script->runtimeError("Cannot remove item '%s' from inventory", val->getString());
} else {
// show associated entities
((AdGame *)_gameRef)->_scene->handleItemAssociations(val->getString(), true);
}
} else {
script->runtimeError("DropItem: item name expected");
}
stack->pushNULL();
return STATUS_OK;
}
//////////////////////////////////////////////////////////////////////////
// GetItem
//////////////////////////////////////////////////////////////////////////
else if (strcmp(name, "GetItem") == 0) {
stack->correctParams(1);
if (!_inventory) {
_inventory = new AdInventory(_gameRef);
((AdGame *)_gameRef)->registerInventory(_inventory);
}
ScValue *val = stack->pop();
if (val->_type == VAL_STRING) {
AdItem *item = ((AdGame *)_gameRef)->getItemByName(val->getString());
if (item) {
stack->pushNative(item, true);
} else {
stack->pushNULL();
}
} else if (val->isNULL() || val->getInt() < 0 || val->getInt() >= (int32)_inventory->_takenItems.size()) {
stack->pushNULL();
} else {
stack->pushNative(_inventory->_takenItems[val->getInt()], true);
}
return STATUS_OK;
}
//////////////////////////////////////////////////////////////////////////
// HasItem
//////////////////////////////////////////////////////////////////////////
else if (strcmp(name, "HasItem") == 0) {
stack->correctParams(1);
if (!_inventory) {
_inventory = new AdInventory(_gameRef);
((AdGame *)_gameRef)->registerInventory(_inventory);
}
ScValue *val = stack->pop();
if (!val->isNULL()) {
for (uint32 i = 0; i < _inventory->_takenItems.size(); i++) {
if (val->getNative() == _inventory->_takenItems[i]) {
stack->pushBool(true);
return STATUS_OK;
} else if (scumm_stricmp(val->getString(), _inventory->_takenItems[i]->getName()) == 0) {
stack->pushBool(true);
return STATUS_OK;
}
}
} else {
script->runtimeError("HasItem: item name expected");
}
stack->pushBool(false);
return STATUS_OK;
}
//////////////////////////////////////////////////////////////////////////
// CreateParticleEmitter
//////////////////////////////////////////////////////////////////////////
else if (strcmp(name, "CreateParticleEmitter") == 0) {
stack->correctParams(3);
bool followParent = stack->pop()->getBool();
int offsetX = stack->pop()->getInt();
int offsetY = stack->pop()->getInt();
PartEmitter *emitter = createParticleEmitter(followParent, offsetX, offsetY);
if (emitter) {
stack->pushNative(_partEmitter, true);
} else {
stack->pushNULL();
}
return STATUS_OK;
}
//////////////////////////////////////////////////////////////////////////
// DeleteParticleEmitter
//////////////////////////////////////////////////////////////////////////
else if (strcmp(name, "DeleteParticleEmitter") == 0) {
stack->correctParams(0);
if (_partEmitter) {
_gameRef->unregisterObject(_partEmitter);
_partEmitter = nullptr;
}
stack->pushNULL();
return STATUS_OK;
}
//////////////////////////////////////////////////////////////////////////
// AddAttachment
//////////////////////////////////////////////////////////////////////////
else if (strcmp(name, "AddAttachment") == 0) {
stack->correctParams(4);
const char *filename = stack->pop()->getString();
bool preDisplay = stack->pop()->getBool(true);
int offsetX = stack->pop()->getInt();
int offsetY = stack->pop()->getInt();
bool res;
AdEntity *ent = new AdEntity(_gameRef);
if (DID_FAIL(res = ent->loadFile(filename))) {
delete ent;
ent = nullptr;
script->runtimeError("AddAttachment() failed loading entity '%s'", filename);
stack->pushBool(false);
} else {
_gameRef->registerObject(ent);
ent->_posX = offsetX;
ent->_posY = offsetY;
ent->_active = true;
if (preDisplay) {
_attachmentsPre.add(ent);
} else {
_attachmentsPost.add(ent);
}
stack->pushBool(true);
}
return STATUS_OK;
}
//////////////////////////////////////////////////////////////////////////
// RemoveAttachment
//////////////////////////////////////////////////////////////////////////
else if (strcmp(name, "RemoveAttachment") == 0) {
stack->correctParams(1);
ScValue *val = stack->pop();
bool found = false;
if (val->isNative()) {
BaseScriptable *obj = val->getNative();
for (uint32 i = 0; i < _attachmentsPre.size(); i++) {
if (_attachmentsPre[i] == obj) {
found = true;
_gameRef->unregisterObject(_attachmentsPre[i]);
_attachmentsPre.remove_at(i);
i--;
}
}
for (uint32 i = 0; i < _attachmentsPost.size(); i++) {
if (_attachmentsPost[i] == obj) {
found = true;
_gameRef->unregisterObject(_attachmentsPost[i]);
_attachmentsPost.remove_at(i);
i--;
}
}
} else {
const char *attachmentName = val->getString();
for (uint32 i = 0; i < _attachmentsPre.size(); i++) {
if (_attachmentsPre[i]->getName() && scumm_stricmp(_attachmentsPre[i]->getName(), attachmentName) == 0) {
found = true;
_gameRef->unregisterObject(_attachmentsPre[i]);
_attachmentsPre.remove_at(i);
i--;
}
}
for (uint32 i = 0; i < _attachmentsPost.size(); i++) {
if (_attachmentsPost[i]->getName() && scumm_stricmp(_attachmentsPost[i]->getName(), attachmentName) == 0) {
found = true;
_gameRef->unregisterObject(_attachmentsPost[i]);
_attachmentsPost.remove_at(i);
i--;
}
}
}
stack->pushBool(found);
return STATUS_OK;
}
//////////////////////////////////////////////////////////////////////////
// GetAttachment
//////////////////////////////////////////////////////////////////////////
else if (strcmp(name, "GetAttachment") == 0) {
stack->correctParams(1);
ScValue *val = stack->pop();
AdObject *ret = nullptr;
if (val->isInt()) {
int index = val->getInt();
int currIndex = 0;
for (uint32 i = 0; i < _attachmentsPre.size(); i++) {
if (currIndex == index) {
ret = _attachmentsPre[i];
}
currIndex++;
}
for (uint32 i = 0; i < _attachmentsPost.size(); i++) {
if (currIndex == index) {
ret = _attachmentsPost[i];
}
currIndex++;
}
} else {
const char *attachmentName = val->getString();
for (uint32 i = 0; i < _attachmentsPre.size(); i++) {
if (_attachmentsPre[i]->getName() && scumm_stricmp(_attachmentsPre[i]->getName(), attachmentName) == 0) {
ret = _attachmentsPre[i];
break;
}
}
if (!ret) {
for (uint32 i = 0; i < _attachmentsPost.size(); i++) {
if (_attachmentsPost[i]->getName() && scumm_stricmp(_attachmentsPost[i]->getName(), attachmentName) == 0) {
ret = _attachmentsPre[i];
break;
}
}
}
}
if (ret != nullptr) {
stack->pushNative(ret, true);
} else {
stack->pushNULL();
}
return STATUS_OK;
} else {
return BaseObject::scCallMethod(script, stack, thisStack, name);
}
}
