void spawnMonster(){
bool type = true;
bool dir = true;
if(rand()%3 == 0)type = false;
if(rand()%2 == 0)dir = false;
int startFrame = 32;
if(type)startFrame = 16;
int i = 0;
if(enemies.size() < MAX_ENEMIES){
enemies.push_back(Monster(116,0,type));
i = enemies.size()-1;
}else{
for(int k = 0; k < MAX_ENEMIES; k++){
if(enemies.at(k).isDead()){
enemies[k] = Monster(116,0,type);
i = k;
break;
}
}
}
SetObject(i+3,
ATTR0_SHAPE(0) | ATTR0_8BPP | ATTR0_REG | ATTR0_Y(enemies.at(i).getY()),
ATTR1_SIZE(!type) | ATTR1_X(enemies.at(i).getX()),
ATTR2_ID8(startFrame));
enemies.at(i).setDir(dir);
}
//============================================================================
// NCGImage::NCGImage : Constructor.
//----------------------------------------------------------------------------
NCGImage::NCGImage(CGImageRef cfObject, bool takeOwnership)
{
// Initialize ourselves
SetObject(cfObject, takeOwnership);
}
//============================================================================
// NCFArray::NCFArray : Constructor.
//----------------------------------------------------------------------------
NCFArray::NCFArray(CFArrayRef cfObject, bool takeOwnership)
{
// Initialize ourselves
SetObject(cfObject, takeOwnership);
}
//============================================================================
// NCFDictionary::NCFDictionary : Constructor.
//----------------------------------------------------------------------------
NCFDictionary::NCFDictionary(CFDictionaryRef cfObject, bool takeOwnership)
{
// Initialize ourselves
SetObject(cfObject, takeOwnership);
}
TBValue::TBValue(TYPE type)
: m_packed_init(0)
{
switch (type)
{
case TYPE_NULL:
SetNull();
break;
case TYPE_STRING:
SetString("", SET_AS_STATIC);
break;
case TYPE_FLOAT:
SetFloat(0);
break;
case TYPE_INT:
SetInt(0);
break;
case TYPE_OBJECT:
SetObject(nullptr);
break;
case TYPE_ARRAY:
if (TBValueArray *arr = new TBValueArray())
SetArray(arr, SET_TAKE_OWNERSHIP);
break;
default:
assert(!"Not implemented!");
};
}
static int prPlatform_ideName(struct VMGlobals *g, int numArgsPushed)
{
PyrSlot *a = g->sp;
PyrString* string = newPyrString(g->gc, gIdeName, 0, true);
SetObject(a, string);
return errNone;
}
SC_DLLEXPORT_C void runLibrary(PyrSymbol* selector)
{
VMGlobals *g = gMainVMGlobals;
g->canCallOS = true;
try {
if (compiledOK) {
++g->sp; SetObject(g->sp, g->process);
runInterpreter(g, selector, 1);
} else {
postfl("Library has not been compiled successfully.\n");
}
} catch (std::exception &ex) {
PyrMethod *meth = g->method;
if (meth) {
int ip = slotRawInt8Array(&meth->code) ? g->ip - slotRawInt8Array(&meth->code)->b : -1;
post("caught exception in runLibrary %s:%s %3d\n",
slotRawSymbol(&slotRawClass(&meth->ownerclass)->name)->name, slotRawSymbol(&meth->name)->name, ip
);
dumpByteCodes(meth);
} else {
post("caught exception in runLibrary\n");
}
error(ex.what());
} catch (...) {
postfl("DANGER: OUT of MEMORY. Operation failed.\n");
}
g->canCallOS = false;
}
//============================================================================
// NCFNumber::NCFNumber : Constructor.
//----------------------------------------------------------------------------
NCFNumber::NCFNumber(CFNumberRef cfObject, bool takeOwnership)
{
// Initialize ourselves
SetObject(cfObject, takeOwnership);
}
void FObjectReplicator::CleanUp()
{
if ( OwningChannel != NULL )
{
StopReplicating( OwningChannel ); // We shouldn't get here, but just in case
}
SetObject( NULL );
ObjectClass = NULL;
Connection = NULL;
RemoteFunctions = NULL;
bHasReplicatedProperties = false;
bOpenAckCalled = false;
// Cleanup custom delta state
RecentCustomDeltaState.Empty();
LifetimeCustomDeltaProperties.Empty();
LifetimeCustomDeltaPropertyConditions.Empty();
if ( RepState != NULL )
{
delete RepState;
RepState = NULL;
}
}
int prArray_OSCBytes(VMGlobals *g, int numArgsPushed)
{
PyrSlot* a = g->sp;
PyrObject *array = slotRawObject(a);
PyrSlot* args = array->slots;
int numargs = array->size;
if (numargs < 1) return errFailed;
big_scpacket packet;
if (IsFloat(args) || IsNil(args) || IsInt(args)) {
makeSynthBundle(&packet, args, numargs, false);
} else if (IsSym(args) || isKindOfSlot(args, class_string)) {
int error = makeSynthMsgWithTags(&packet, args, numargs);
if (error != errNone)
return error;
} else {
return errWrongType;
}
int size = packet.size();
PyrInt8Array* obj = newPyrInt8Array(g->gc, size, 0, true);
obj->size = size;
memcpy(obj->b, packet.data(), size);
SetObject(a, (PyrObject*)obj);
//for (int i=0; i<packet.size()/4; i++) post("%d %p\n", i, packet.buf[i]);
return errNone;
}
void SC_HID_APIManager::handleElement( int joy_idx, struct hid_device_element * ele, std::atomic<bool> const & shouldBeRunning ){
int status = lockLanguageOrQuit(shouldBeRunning);
if (status == EINTR)
return;
if (status) {
postfl("error when locking language (%d)\n", status);
return;
}
if (compiledOK) {
VMGlobals* g = gMainVMGlobals;
g->canCallOS = false;
++g->sp; SetObject(g->sp, s_hidapi->u.classobj ); // set the class HID_API
++g->sp; SetInt(g->sp, joy_idx );
++g->sp; SetInt(g->sp, ele->index );
++g->sp; SetInt(g->sp, ele->usage_page );
++g->sp; SetInt(g->sp, ele->usage );
++g->sp; SetInt(g->sp, ele->value );
++g->sp; SetFloat(g->sp, hid_element_map_logical( ele ) );
++g->sp; SetFloat(g->sp, hid_element_map_physical( ele ) );
++g->sp; SetInt(g->sp, ele->array_value );
runInterpreter(g, s_hidElementData, 9 );
g->canCallOS = false;
}
gLangMutex.unlock();
}
static int prPlatform_ideName(struct VMGlobals *g, int numArgsPushed)
{
PyrSlot *a = g->sp;
PyrString* string = newPyrString(g->gc, SC_Filesystem::instance().getIdeName().c_str(), 0, true);
SetObject(a, string);
return errNone;
}
PyrObject *PyrGC::NewFinalizer(ObjFuncPtr finalizeFunc, PyrObject *inObject, bool inCollect)
{
PyrObject *obj = NULL;
#ifdef GC_SANITYCHECK
SanityCheck();
#endif
// obtain size info
int32 sizeclass = 1;
int32 credit = 1L << sizeclass;
mNumToScan += credit;
mAllocTotal += credit;
mNumAllocs++;
if (inCollect && mNumToScan >= kScanThreshold) {
Collect();
}
GCSet *gcs = mSets + kFinalizerSet;
obj = (PyrObject*)gcs->mFree;
if (!IsMarker(obj)) {
// from free list
gcs->mFree = obj->next;
} else {
if (sizeclass > kMaxPoolSet) {
SweepBigObjects();
int32 allocSize = sizeof(PyrObjectHdr) + (sizeof(PyrSlot) << sizeclass);
obj = (PyrObject*)mPool->Alloc(allocSize);
} else {
int32 allocSize = sizeof(PyrObjectHdr) + (sizeof(PyrSlot) << sizeclass);
obj = (PyrObject*)mNewPool.Alloc(allocSize);
}
if (!obj) {
post("Finalizer alloc failed.\n");
MEMFAILED;
}
DLInsertAfter(&gcs->mWhite, obj);
}
obj->obj_sizeclass = sizeclass;
obj->obj_format = obj_slot;
obj->obj_flags = 0;
obj->size = 2;
obj->classptr = class_finalizer;
obj->gc_color = mWhiteColor;
SetPtr(obj->slots+0, (void*)finalizeFunc);
SetObject(obj->slots+1, inObject);
#ifdef GC_SANITYCHECK
SanityCheck();
#endif
return obj;
}
void UI::Init()
{
SetObject( POSX , POSY , WIDTH , HEIGTH );
m_BoxWidth = m_Width / ( SHIP_NUM + 1 );
m_BoxHeight = m_Height / ( SHIP_NUM + 1 );
m_ScaleX = m_BoxWidth;
m_ScaleY = m_BoxHeight;
}
static inline int prPlatform_getDirectory(const struct VMGlobals *g, const DirName dirname)
{
PyrSlot *a = g->sp;
const bfs::path& p = SC_Filesystem::instance().getDirectory(dirname);
PyrString* string = newPyrString(g->gc, SC_Codecvt::path_to_utf8_str(p).c_str(), 0, true);
SetObject(a, string);
return errNone;
}
int prFile_PutFile(struct VMGlobals *g, int numArgsPushed)
{
PyrSlot *a = g->sp - 2;
PyrSlot *b = g->sp - 1;
PyrSlot *c = g->sp;
NavDialogOptions options;
int err = NavGetDefaultDialogOptions(&options);
if (err) return errFailed;
options.dialogOptionFlags |= kNavNoTypePopup;
options.dialogOptionFlags |= kNavDontAutoTranslate;
options.dialogOptionFlags |= kNavDontAddTranslateItems;
options.dialogOptionFlags |= kNavSelectDefaultLocation;
options.dialogOptionFlags &= ~kNavAllowPreviews;
options.dialogOptionFlags &= ~kNavAllowMultipleFiles;
if (isKindOfSlot(b, class_string)) {
pstringFromPyrString((PyrString*)slotRawObject(b), options.message, 256);
}
if (isKindOfSlot(c, class_string)) {
pstringFromPyrString((PyrString*)slotRawObject(c), options.savedFileName, 256);
} else {
//pstrncpy(options.savedFileName, "\pUntitled", 255);
}
NavReplyRecord reply;
err = NavPutFile(0, &reply, &options, 0, 'TEXT', 'SCjm', 0);
if (err == noErr && reply.validRecord) {
AEKeyword keyword;
DescType actualType;
Size actualSize;
FSSpec fsspec;
err = AEGetNthPtr(&reply.selection, 1, typeFSS, &keyword, &actualType,
&fsspec, sizeof(FSSpec), &actualSize);
if (err == noErr) {
Str255 pathname;
GetFullPathname(&fsspec, pathname);
p2cstr(pathname);
PyrString *string = newPyrString(g->gc, (char*)pathname, 0, true);
SetObject(a, string);
err = NavCompleteSave(&reply, kNavTranslateInPlace);
} else {
SetNil(a);
}
err = NavDisposeReply(&reply);
} else {
SetNil(a);
}
return errNone;
}
int prSFOpenRead(struct VMGlobals *g, int numArgsPushed)
{
PyrSlot *a, *b;
char filename[PATH_MAX];
SNDFILE *file;
SF_INFO info;
const char *headerstr;
const char *sampleformatstr;
a = g->sp - 1;
b = g->sp;
PyrObject *obj1 = slotRawObject(a);
if (!isKindOfSlot(b, class_string)) return errWrongType;
if (slotRawObject(b)->size > PATH_MAX - 1) return errFailed;
memcpy(filename, slotRawString(b)->s, slotRawObject(b)->size);
filename[slotRawString(b)->size] = 0;
info.format = 0;
file = sf_open(filename, SFM_READ, &info);
if (file) {
SetPtr(obj1->slots + 0, file);
sndfileFormatInfoToStrings(&info, &headerstr, &sampleformatstr);
//headerFormatToString(&info, &headerstr);
PyrString *hpstr = newPyrString(g->gc, headerstr, 0, true);
SetObject(obj1->slots+1, hpstr);
g->gc->GCWriteNew(obj1, (PyrObjectHdr*)hpstr); // we know hpstr is white so we can use GCWriteNew
PyrString *smpstr = newPyrString(g->gc, sampleformatstr, 0, true);
SetObject(obj1->slots+2, smpstr);
g->gc->GCWriteNew(obj1, (PyrObjectHdr*)smpstr); // we know smpstr is white so we can use GCWriteNew
SetInt(obj1->slots + 3, info.frames);
SetInt(obj1->slots + 4, info.channels);
SetInt(obj1->slots + 5, info.samplerate);
SetTrue(a);
} else {
SetNil(a);
SetFalse(a);
}
return errNone;
}
static int prWinPlatform_myDocumentsDir(struct VMGlobals *g, int numArgsPushed)
{
PyrSlot *a = g->sp;
char path[PATH_MAX];
win32_GetKnownFolderPath(CSIDL_PERSONAL, path, PATH_MAX); \
PyrString* string = newPyrString(g->gc, path, 0, true); \
SetObject(a, string);
return errNone;
}
void PushQueueEvents_CalibratedValue (){
IOHIDEventStruct event;
pRecDevice pCurrentHIDDevice = HIDGetFirstDevice ();
int numdevs = gNumberOfHIDDevices;
unsigned char result;
for(int i=0; i< numdevs; i++){
result = HIDGetEvent(pCurrentHIDDevice, (void*) &event);
if(result && compiledOK) {
SInt32 value = event.value;
int vendorID = pCurrentHIDDevice->vendorID;
int productID = pCurrentHIDDevice->productID;
int locID = pCurrentHIDDevice->locID;
IOHIDElementCookie cookie = (IOHIDElementCookie) event.elementCookie;
pRecElement pCurrentHIDElement = HIDGetFirstDeviceElement (pCurrentHIDDevice, kHIDElementTypeAll);
// use gElementCookie to find current element
while (pCurrentHIDElement && ( (pCurrentHIDElement->cookie) != cookie))
pCurrentHIDElement = HIDGetNextDeviceElement (pCurrentHIDElement, kHIDElementTypeAll);
if (pCurrentHIDElement)
{
value = HIDCalibrateValue(value, pCurrentHIDElement);
//find element to calibrate
VMGlobals *g = gMainVMGlobals;
pthread_mutex_lock (&gLangMutex);
g->canCallOS = false; // cannot call the OS
++g->sp; SetObject(g->sp, s_hid->u.classobj); // Set the class HIDService
//set arguments:
++g->sp;SetInt(g->sp, vendorID);
++g->sp;SetInt(g->sp, productID);
++g->sp;SetInt(g->sp, locID);
++g->sp;SetInt(g->sp, (int) cookie);
++g->sp;SetInt(g->sp, value);
runInterpreter(g, s_hidAction, 6);
g->canCallOS = false; // cannot call the OS
pthread_mutex_unlock (&gLangMutex);
}
}
/* FIXME: this does not seem to be working!
if ( !HIDIsValidDevice(pCurrentHIDDevice) )
{ // readError
post("HID: read Error\n");
int locID = pCurrentHIDDevice->locID;
VMGlobals *g = gMainVMGlobals;
pthread_mutex_lock (&gLangMutex);
g->canCallOS = false; // cannot call the OS
++g->sp; SetObject(g->sp, s_hid->u.classobj); // Set the class HIDService
++g->sp;SetInt(g->sp, locID);
runInterpreter(g, s_readError, 2);
g->canCallOS = false; // cannot call the OS
pthread_mutex_unlock (&gLangMutex);
}*/
pCurrentHIDDevice = HIDGetNextDevice(pCurrentHIDDevice);
}
}
HitSur::HitSur(const HDC hdc, const float zoom, const float offx, const float offy, const int width, const int height, const int hitx, const int hity, ISelect * const pbackground) : Sur(hdc, zoom, offx, offy, width, height)
{
m_pselected = pbackground;
m_hitx = hitx;
m_hity = hity;
SetObject(NULL);
}
PyrObject* ConvertOSCMessage(int inSize, char *inData)
{
char *cmdName = inData;
int cmdNameLen = OSCstrlen(cmdName);
sc_msg_iter msg(inSize - cmdNameLen, inData + cmdNameLen);
int numElems;
if (inSize == cmdNameLen) {
numElems = 0;
} else {
if (!msg.tags) {
numElems = 0;
error("OSC messages must have type tags. %s\n", cmdName);
} else {
numElems = strlen(msg.tags);
}
}
//post("tags %s %d\n", msg.tags, numElems);
VMGlobals *g = gMainVMGlobals;
PyrObject *obj = newPyrArray(g->gc, numElems + 1, 0, false);
PyrSlot *slots = obj->slots;
SetSymbol(slots+0, getsym(cmdName));
for (int i=0; i<numElems; ++i) {
char tag = msg.nextTag();
//post("%d %c\n", i, tag);
switch (tag) {
case 'i' :
SetInt(slots+i+1, msg.geti());
break;
case 'f' :
SetFloat(slots+i+1, msg.getf());
break;
case 'd' :
SetFloat(slots+i+1, msg.getd());
break;
case 's' :
SetSymbol(slots+i+1, getsym(msg.gets()));
//post("sym '%s'\n", slots[i+1].us->name);
break;
case 'b' :
SetObject(slots+i+1, (PyrObject*)MsgToInt8Array(msg));
break;
case 'c':
SetChar(slots+i+1, (char)msg.geti());
break;
// else add the type tag as a char (jrhb 2009)
default:
SetChar(slots+i+1, tag);
msg.gets();
}
}
obj->size = numElems + 1;
return obj;
}
virtual ~TypeItem()
{
if (fOwnData) {
free(fData);
fData = NULL;
fSize = 0;
}
SetObject(NULL);
}
int SC_TerminalClient::prArgv(struct VMGlobals* g, int)
{
int argc = ((SC_TerminalClient*)SC_TerminalClient::instance())->options().mArgc;
char** argv = ((SC_TerminalClient*)SC_TerminalClient::instance())->options().mArgv;
PyrSlot* argvSlot = g->sp;
PyrObject* argvObj = newPyrArray(g->gc, argc * sizeof(PyrObject), 0, true);
SetObject(argvSlot, argvObj);
for (int i=0; i < argc; i++) {
PyrString* str = newPyrString(g->gc, argv[i], 0, true);
SetObject(argvObj->slots+i, str);
argvObj->size++;
g->gc->GCWriteNew(argvObj, (PyrObject*)str); // we know str is white so we can use GCWriteNew
}
return errNone;
}
//============================================================================
// NCFObject::= : Assignment operator.
//----------------------------------------------------------------------------
const NCFObject& NCFObject::operator = (const NCFObject &theObject)
{
// Assign the object
if (this != &theObject)
SetObject(theObject.mObject, false);
return(*this);
}
void drawText(int x, int y, std::string string){
int startPos = activeLetters;
for(int i = 0; i < string.length(); i++){
activeLetters++;
SetObject(startPos+i+45,
ATTR0_SHAPE(0) | ATTR0_8BPP | ATTR0_REG | ATTR0_Y(y),
ATTR1_SIZE(0) | ATTR1_X(x+(i*8)),
ATTR2_ID8(string.at(i) + 64));
}
}
void Component::Detach()
{
if (!_attached)
{
return;
}
SetObject(nullptr);
_attached = false;
events.CallEvent("OnDetach", NULL, (void*) this);
}
//Alterar
object * Scale(object * ob, float sx, float sy) {
object * oob;
int i;
oob = CreateObject(ob->numbers_of_points);
for(i=0;i<ob->numbers_of_points;i++) {
SetObject(SetPoint(sx*(ob->points[i].x),sy*(ob->points[i].y),ob->points[i].color),oob);
}
return oob;
}
//OK
object * ChangeColor(object * ob, int color) {
object * oob;
int i;
oob = CreateObject(ob->numbers_of_points);
for(i=0;i<ob->numbers_of_points;i++) {
SetObject(SetPoint(ob->points[i].x,ob->points[i].y,color),oob);
}
return oob;
}
void UIShipObject::Create( Bitmap* normalBitmap , Bitmap* destroyedBitmap , float maxHP, float posY )
{
SetObject( 0 , posY , maxHP , 1 );
m_ScaleX = 1;
m_ScaleY = m_Height;
m_ShipSprite->SetNormalBitmap( normalBitmap );
m_ShipSprite->SetDestroyedBitmap( destroyedBitmap );
m_ShipSprite->SetObject( 0 , 0 , maxHP , 0.5 );
AddChild( m_ShipSprite );
}
void ClearObjects()
{
for (int i = 0; i < NUM_OBJECTS; ++i)
{
// This can't just set all the attributes to 0, because an object
// with attr0 == 0 is actually visible.
SetObject(i, ATTR0_HIDE, 0, 0);
}
UpdateObjects();
}
