how to synchronize my actions with each other?

[10100010010001001010]

My update() method doesn't work well. I time it at 6.5 seconds (the duration of my action), each time after this time the update() function sets the action to all objects in the pool. Thus, new actions begin at the same time as old ones begin and everything works synchronously. But with each subsequent update() i can see that new objects are slightly behind the animation of the previous ones

code:

void SpriteManager::update(float dt)
{
	this->_dt -= dt; //_dt is 6.5 for default

	if (_dt <= 0)
        {
		this->_dt = 6.5f;

		if (this->_queueToStartAction.empty() == false)
		{
			for (int i = 0; i < this->_queueToStartAction.size(); i++)
			{
				this->_queueToStartAction[i]->runAction(RepeatForever::create(Sequence::create(
                                FadeIn::create(3), 
                                DelayTime::create(0.5f), 
                                FadeOut::create(3), nullptr)));
			}
			this->_queueToStartAction.clear();
		}
	 }
}

[rh101]

When you refer to "actions", do you mean you referring to ActionInterval objects, or is it just a term you're using for your code, because it's a little hard to understand the context of the code snippet you've provided.

[10100010010001001010]

it was too late and I copied the wrong thing, i edited the text

[rh101]

Oh! No wonder!

Also, remember to add the 3 back-tick characters before and after the code section to format it in the post.

[10100010010001001010]

done, boss

[rh101]

There is no clean way to synchronize the actions that I know of. I actually faced this exact issue (also with fading in and out), and even made an attempt to add that kind of functionality to the Action sub-classes, but didn't get anywhere with it because of time constraints.

My work-around was to manually synchronize all the actions any time that same action is added to a new node, meaning setting the same opacity and calling startWithTarget on all nodes:

node->setOpacity(someStartingOpacity);
auto* currentAction = node->getActionByTag(YOUR_ACTION_TAG);
currentAction->startWithTarget(currentAction->getOriginalTarget()); // resets internal values

Regarding your specific issue though, it may be to do with the fact that it is never precisely 6.5 seconds each time you enter that section:

_dt -= dt; //_dt is 6.5 for default
if (_dt <= 0)
{
    _dt = 6.5f;

// etc. etc.

If _dt is less than 0, it means you've gone over the 6.5 seconds since the last set of actions, so the timing will be off. It would need to be precisely 6.5 seconds to ensure it is correctly synchronized, but you can't check for _dt == 0.f, since that is unlikely to ever be equal.

You need to re-think your logic.

[10100010010001001010]

well, I was thinking about restarting all actions when adding a new one. It seemed to me that this would slow down the application, especially if it happened frequently. But it seems there's nothing left

[rh101]

That's one option, but there are many other ways to handle it without having to restart all the actions.

For example, you can create a custom action for fading in and out, which doesn't affect the node it is attached to, but instead has a list of nodes that it operates on. You can add that custom action to the scene, and every time you add a new node to the scene which you want to fade in and our, synchronized to all other nodes, then just add it to that node to the custom action.

[10100010010001001010]

If I understood what was written correctly, then I have already done this. But one action only works with one node, and when I tried to run it in other nodes, it was applied to the last one, and stopped working for others. Or is custom action designed differently?

[rh101]

The current actions only work on one node, but you need to write a custom action that does not operate on the node it's attached to. That way, you can just add it to the scene, but it won't affect the scene. It also doesn't even have to be an action, but custom node or some other object, as long as they have an update method. It's basically just managing a list of nodes that it operates on to change their opacity.

You maintain a list (ax::Vector) of nodes within that custom object, and simply have methods like this:

ax::Vector<axNode*> _nodes;

addNode(Node* node); // adds node to _nodes
removeNode(Node* node); // removes node from _nodes

To process the nodes, you would do what the current FadeIn/FadeOut would do, but instead of operating on a single node, you would process the list of nodes:

void CustomAction::update(float time)
{
    for(auto& node : _nodes)
    {
        node->setOpacity((uint8_t)(_fromOpacity + (_toOpacity - _fromOpacity) * time));
    }
}

This way all nodes have exactly the same opacity at all times.

So, say you made MultiFadeIn and MultiFadeOut actions. You would do this:

_multiFadeIn = MultiFadeIn::create(3);
_multiFadeOut = MultiFadeOut::create(3);

currentScene->runAction(RepeatForever::create(Sequence::create(
                                _multiFadeIn, 
                                DelayTime::create(0.5f), 
                                _multiFadeOut, nullptr)));

Then when you want to add new nodes, just do this:

_multiFadeIn->addNode(newNode);
_multiFadeOut->addNode(newNode);

That should do it.

I'm sure there are easier ways to implement similar functionality, so just take this as purely an example of what is possible.