flag event

my_special_ent->skill1 += 1;
skill_was_changed(my_special_ent);

void set_skill1(ENTITY* ent,fixed value)
{
  if (!ent)
    return;

  ent->skill1 = value;

  skill_was_changed(ent);
}

1. The Detonator

void trigger_explo(ENTITY* explosive) // Will set the Flag of the saved entity to 1
{
   [...]
   set(explosive,FLAG1);
   [...]
}

action detonator()    // Has stored all explosives-pointer in its entity-skills
{
   [...]
   my.skill1 = spawn_explosive(); // create explosive and save its pointer
   while(1)
   {
      [...]
      if(i_want_to detonate)      // check if eg. button for detonation is pressed
      {
         trigger_explo((ENTIY*) my.skill1);
         [...]
      }
      wait(1);
   }
}

2. The Explosive

void detonate_ent()   // aoe damage and shrapnelspawning
{
   [...]
   ent_create("shrapnel.mdl",my.x,shrapnel_func);
   //you.parent = me;
}

void explosive_ent()
{
   [...]
   set_stats_from_other_source(source); // With this function i save the stats of the explosive and the generated shrapnels in skills of this entity 
   
   while(1)
   {
      if(is(my,FLAG1)){detonate_ent();} // i just would like to avoid many entities with short loops that check only for one changing flag
      wait(1);
   }
}

3. The Shrapnel

void set_stats_from(ENTITY* from) // all properties of the shrapnel are save in skills in the explosive_entiy
{
   my.skill10 = from.skill10;
}

void shrapnel_func()
{
   set_stats_from(you); // get stats from your creator
   [...]
   while(1)
   {
      do_stuff();
      wait(1);
   }
}

I know i can avoid the whileloop if i run detonate_ent() inside the detonator action. But then you would point to the detonator and not the explosive.
It would work if i save the stats in detonator.skills instead of explosive.skills, but i want to avoid that if possible, cause i dont have enough free skills if i want to support the number of explosives i need.

void trigger_explo(ENTITY* explosive) // Will set the Flag of the saved entity to 1
{
   wait(1); // This is important as it returns to the caller, and gives us the chance to alter the you pointer opaque to the caller but visible to our callees

   you = explosive;
   detonate_ent();
}

ENTITY* created = ent_create(...);
created.skill1 = explosive;

But it crashed because i checked the skill before it had the right value.

#include <acknex.h>
#include <atypes.h>
#include <default.c>

void bomb()
{
	my.skill3 = 100;
}

void shard()
{
        wait(1); // <-- added
	//my.skill1 = you.skill3;
        my.skill1 = my.parent.skill3; // <-- added
	while(1)
	{
		my.pan -= my.skill1*time_step;
		wait(1);
	}	
}

void detonate_ent(ENTITY* e)
{
	//ent_create(CUBE_MDL,vector(my.x,my.y,my.z+200),shard);
        ENTIY* created = ent_create(CUBE_MDL,vector(my.x,my.y,my.z+200),shard); //<-- added
        created.parent = e; // <-- added

}

void trigger_ent(ENTITY* e)
{	
	//wait(1);
	//you=e;
        // detoante_ent(you);
	detonate_ent(e); //<-- added
}

void detonator()
{
	ENTITY* test= ent_create(CUBE_MDL,vector(0,100,0),bomb);
	my.skill3 = 1;
	while(1)
	{
		if(key_d){trigger_ent(test);return;}
		wait(1);
	}
}

function main()
{
	video_switch(8,0,2);
	level_load(NULL);
	vec_set(screen_color,vector(255,0,0)); // blau 
	wait(3);
	fps_max = 60;
	ent_create(CUBE_MDL,nullvector,detonator);
	camera.x -= 1000;
}