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