void ActionManager::addAction(Action *action, Node *target, bool paused) { CCASSERT(action != nullptr, "action can't be nullptr!"); CCASSERT(target != nullptr, "target can't be nullptr!"); if(action == nullptr || target == nullptr) return; tHashElement *element = nullptr; // we should convert it to Ref*, because we save it as Ref* Ref *tmp = target; HASH_FIND_PTR(_targets, &tmp, element); if (! element) { element = (tHashElement*)calloc(sizeof(*element), 1); element->paused = paused; target->retain(); element->target = target; HASH_ADD_PTR(_targets, target, element); } actionAllocWithHashElement(element); CCASSERT(! ccArrayContainsObject(element->actions, action), "action already be added!"); ccArrayAppendObject(element->actions, action); action->startWithTarget(target); }
void CCActionManager::addAction(CCAction *pAction, CAView *pTarget, bool paused) { CCAssert(pAction != NULL, ""); CCAssert(pTarget != NULL, ""); tHashElement *pElement = NULL; // we should convert it to CAObject*, because we save it as CAObject* CAObject *tmp = pTarget; HASH_FIND_INT(m_pTargets, &tmp, pElement); if (! pElement) { pElement = (tHashElement*)calloc(sizeof(*pElement), 1); pElement->paused = paused; pTarget->retain(); pElement->target = pTarget; HASH_ADD_INT(m_pTargets, target, pElement); } actionAllocWithHashElement(pElement); CCAssert(! ccArrayContainsObject(pElement->actions, pAction), ""); ccArrayAppendObject(pElement->actions, pAction); pAction->startWithTarget(pTarget); }
/** Appends objects from plusArr to arr. Behavior undefined if arr doesn't have enough capacity. */ void ccArrayAppendArray(ccArray *arr, ccArray *plusArr) { for(unsigned int i = 0; i < plusArr->num; i++) { ccArrayAppendObject(arr, plusArr->arr[i]); } }
/** Appends objects from plusArr to arr. Behavior undefined if arr doesn't have enough capacity. */ void ccArrayAppendArray(ccArray *arr, ccArray *plusArr) { for (ssize_t i = 0; i < plusArr->num; i++) { ccArrayAppendObject(arr, plusArr->arr[i]); } }
void ActionManager::addAction(Action *pAction, Node *target, bool paused) { CCASSERT(pAction != NULL, ""); CCASSERT(target != NULL, ""); tHashElement *pElement = NULL; // we should convert it to Object*, because we save it as Object* Object *tmp = target; HASH_FIND_INT(_targets, &tmp, pElement); if (! pElement) { pElement = (tHashElement*)calloc(sizeof(*pElement), 1); pElement->paused = paused; target->retain(); pElement->target = target; HASH_ADD_INT(_targets, target, pElement); } actionAllocWithHashElement(pElement); CCASSERT(! ccArrayContainsObject(pElement->actions, pAction), ""); ccArrayAppendObject(pElement->actions, pAction); pAction->startWithTarget(target); }
void CCScheduler::scheduleSelector(SEL_SCHEDULE pfnSelector, SelectorProtocol *pTarget, float fInterval, bool bPaused) { assert(pfnSelector); assert(pTarget); tHashSelectorEntry *pElement = NULL; HASH_FIND_INT(m_pHashForSelectors, &pTarget, pElement); if (! pElement) { pElement = (tHashSelectorEntry *)calloc(sizeof(*pElement), 1);; pElement->target = pTarget; if (pTarget) { pTarget->selectorProtocolRetain(); } HASH_ADD_INT(m_pHashForSelectors, target, pElement); // Is this the 1st element ? Then set the pause level to all the selectors of this target pElement->paused = bPaused; } else { assert(pElement->paused == bPaused); } if (pElement->timers == NULL) { pElement->timers = ccArrayNew(10); } else { for (unsigned int i = 0; i < pElement->timers->num; ++i) { CCTimer *timer = (CCTimer*)pElement->timers->arr[i]; if (pfnSelector == timer->m_pfnSelector) { CCLOG("CCSheduler#scheduleSelector. Selector already scheduled."); timer->m_fInterval = fInterval; return; } } ccArrayEnsureExtraCapacity(pElement->timers, 1); } CCTimer *pTimer = new CCTimer(); pTimer->initWithTarget(pTarget, pfnSelector, fInterval); ccArrayAppendObject(pElement->timers, pTimer); pTimer->release(); }
/** Appends an object. Capacity of arr is increased if needed. */ void ccArrayAppendObjectWithResize(ccArray *arr, CCObject* object) { ccArrayEnsureExtraCapacity(arr, 1); ccArrayAppendObject(arr, object); }