Add 2 new functions to handle getting and setting action completion.

Move action code to bot_actions_common.gsc and remake how it works.

scripts/sp/bots/actions/combat.gsc

@@ -1,5 +1,3 @@
-
-
 bot_aimatsinglenormalzombie()
 {
 
@@ -15,6 +13,16 @@ bot_should_aimatsinglenormalzombie()
 	return false;
 }
 
+bot_check_complete_aimatsinglenormalzombie()
+{
+
+}
+
+bot_set_complete_aimatsinglenormalzombie()
+{
+
+}
+
 bot_aimatsinglenormalzombie_on_completion()
 {
 	
@@ -60,6 +68,16 @@ bot_should_shootsinglenormalzombie()
 	return false;
 }
 
+bot_check_complete_shootsinglenormalzombie()
+{
+
+}
+
+bot_set_complete_shootsinglenormalzombie()
+{
+
+}
+
 bot_shootsinglenormalzombie_on_completion()
 {
 
@@ -105,6 +123,16 @@ bot_should_aimatmultiplenormalzombies()
 	return false;
 }
 
+bot_check_complete_aimatmultiplenormalzombies()
+{
+
+}
+
+bot_set_complete_aimatmultiplenormalzombies()
+{
+
+}
+
 bot_aimatmultiplenormalzombies_on_completion()
 {
 
@@ -150,6 +178,16 @@ bot_should_shootmultiplenormalzombies()
 	return false;
 }
 
+bot_check_complete_shootmultiplenormalzombies()
+{
+
+}
+
+bot_set_complete_shootmultiplenormalzombies()
+{
+
+}
+
 bot_shootmultiplenormalzombie_on_completion()
 {
 
@@ -195,6 +233,16 @@ bot_should_meleesinglenormalzombie()
 
 }
 
+bot_check_complete_meleesinglenormalzombie()
+{
+
+}
+
+bot_set_complete_meleesinglenormalzombie()
+{
+
+}
+
 bot_meleesinglenormalzombie_on_completion()
 {
 
@@ -240,6 +288,16 @@ bot_should_shootsingledogzombie()
 	return false;
 }
 
+bot_check_complete_shootsingledogzombie()
+{
+
+}
+
+bot_set_complete_shootsingledogzombie()
+{
+
+}
+
 bot_shootsingledogzombie_on_completion()
 {
 
@@ -285,6 +343,16 @@ bot_should_shootmultipledogzombies()
 	return false;
 }
 
+bot_check_complete_shootmultipledogzombies()
+{
+
+}
+
+bot_set_complete_shootmultipledogzombies()
+{
+
+}
+
 bot_shootmultipledogzombies_on_completion()
 {
 
@@ -330,6 +398,16 @@ bot_should_meleesingledogzombie()
 	return false;
 }
 
+bot_check_complete_meleesingledogzombie()
+{
+
+}
+
+bot_set_complete_meleesingledogzombie()
+{
+
+}
+
 bot_meleesingledogzombie_on_completion()
 {
 

scripts/sp/bots/actions/movement.gsc

@@ -13,6 +13,16 @@ bot_should_movetoobjective()
 	return false;
 }
 
+bot_check_complete_movetoobjective()
+{
+
+}
+
+bot_set_complete_movetoobjective()
+{
+
+}
+
 bot_movetoobjective_on_completion()
 {
 	
@@ -58,6 +68,16 @@ bot_should_train()
 	return false;
 }
 
+bot_check_complete_train()
+{
+
+}
+
+bot_set_complete_train()
+{
+
+}
+
 bot_train_on_completion()
 {
 
@@ -103,6 +123,16 @@ bot_should_camp()
 	return false;
 }
 
+bot_check_complete_camp()
+{
+
+}
+
+bot_set_complete_camp()
+{
+
+}
+
 bot_camp_on_completion()
 {
 
@@ -148,6 +178,16 @@ bot_should_flee()
 	return false;
 }
 
+bot_check_complete_flee()
+{
+
+}
+
+bot_set_complete_flee()
+{
+
+}
+
 bot_flee_on_completion()
 {
 

scripts/sp/bots/actions/objective.gsc

@@ -45,6 +45,16 @@ bot_should_purchase_magicbox()
 	return self.available_chests.size > 0;
 }
 
+bot_check_complete_magicbox() 
+{
+
+}
+
+bot_set_complete_magicbox()
+{
+
+}
+
 bot_magicbox_purchase_on_completion()
 {
 
@@ -104,6 +114,16 @@ bot_should_purchase_wallbuy()
 	return false;
 }
 
+bot_check_complete_wallbuy()
+{
+
+}
+
+bot_set_complete_wallbuy()
+{
+
+}
+
 bot_wallbuy_purchase_on_completion()
 {
 
@@ -149,6 +169,16 @@ bot_should_purchase_wallbuy_ammo()
 	return false;
 }
 
+bot_check_complete_wallbuy_ammo()
+{
+
+}
+
+bot_set_complete_wallbuy_ammo()
+{
+
+}
+
 bot_wallbuy_ammo_purchase_on_completion()
 {
 
@@ -194,6 +224,16 @@ bot_should_purchase_perk()
 	return false;
 }
 
+bot_check_complete_perk_purchase()
+{
+
+}
+
+bot_set_complete_perk_purchase()
+{
+
+}
+
 bot_perk_purchase_on_completion()
 {
 
@@ -239,6 +279,16 @@ bot_should_purchase_door()
 	return false;
 }
 
+bot_check_complete_door_purchase()
+{
+
+}
+
+bot_set_complete_door_purchase()
+{
+
+}
+
 bot_door_purchase_on_completion()
 {
 
@@ -284,6 +334,16 @@ bot_should_purchase_debris()
 	return false;
 }
 
+bot_check_complete_debris_purchase()
+{
+
+}
+
+bot_set_complete_debris_purchase()
+{
+
+}
+
 bot_debris_purchase_on_completion()
 {
 
@@ -329,6 +389,16 @@ bot_should_purchase_trap()
 	return false;
 }
 
+bot_check_complete_trap_purchase()
+{
+
+}
+
+bot_set_complete_trap_purchase()
+{
+
+}
+
 bot_trap_purchase_on_completion()
 {
 
@@ -374,6 +444,16 @@ bot_should_purchase_packapunch()
 	return false;
 }
 
+bot_check_complete_packapunch_purchase()
+{
+
+}
+
+bot_set_complete_packapunch_purchase()
+{
+
+}
+
 bot_packapunch_purchase_on_completion()
 {
 
@@ -419,6 +499,16 @@ bot_should_revive_player()
 	return false;
 }
 
+bot_check_complete_revive_player()
+{
+
+}
+
+bot_set_complete_revive_player()
+{
+
+}
+
 bot_revive_player_on_completion()
 {
 
@@ -454,7 +544,7 @@ bot_grab_buildable()
 
 }
 
-bot_grabbuildable_process_order()
+bot_grab_buildable_process_order()
 {
 	return 0;
 }
@@ -464,6 +554,16 @@ bot_should_grab_buildable()
 	return false;
 }
 
+bot_check_complete_grab_buildable()
+{
+
+}
+
+bot_set_complete_grab_buildable()
+{
+
+}
+
 bot_grab_buildable_on_completion()
 {
 
@@ -499,7 +599,7 @@ bot_build_buildable()
 
 }
 
-bot_buildbuildable_process_order()
+bot_build_buildable_process_order()
 {
 	return 0;
 }
@@ -509,6 +609,16 @@ bot_should_build_buildable()
 	return false;
 }
 
+bot_check_complete_build_buildable()
+{
+	
+}
+
+bot_set_complete_build_buildable()
+{
+
+}
+
 bot_build_buildable_on_completion()
 {
 
@@ -564,6 +674,16 @@ bot_part_should_cancel()
 	return false;
 }
 
+bot_check_complete_grab_part()
+{
+
+}
+
+bot_set_complete_grab_part()
+{
+
+}
+
 bot_part_on_cancel()
 {
 
@@ -651,6 +771,16 @@ bot_should_grab_powerup()
 	return self.available_powerups.size > 0;
 }
 
+bot_check_complete_grab_powerup()
+{
+
+}
+
+bot_set_complete_grab_powerup()
+{
+
+}
+
 bot_powerup_on_completion()
 {
 	level endon( "end_game" );

scripts/sp/bots/bot_actions_common.gsc

@@ -5,7 +5,7 @@
 #include maps\_utility;
 #include maps\_zombiemode_utility;
 
-register_bot_action( group, action_name, action_func, should_do_func, action_process_order_func, action_completion_func, should_cancel_func, on_cancel_func, should_postpone_func, on_postpone_func, priority_func )
+register_bot_action( group, action_name, action_func, action_process_order_func, should_do_func, check_if_complete_func, set_complete_func, on_completion_func, should_cancel_func, on_cancel_func, should_postpone_func, on_postpone_func, priority_func )
 {
 	if ( !isDefined( level.zbots_actions ) )
 	{
@@ -20,7 +20,9 @@ register_bot_action( group, action_name, action_func, should_do_func, action_pro
 	level.zbots_actions[ action_name ].action = action_func;
 	level.zbots_actions[ action_name ].should_do_func = should_do_func;
 	level.zbots_actions[ action_name ].action_process_order_func = action_process_order_func;
-	level.zbots_actions[ action_name ].on_completion_func = action_completion_func;
+	level.zbots_actions[ action_name ].check_if_complete_func = check_if_complete_func;
+	level.zbots_actions[ action_name ].set_complete_func = set_complete_func;
+	level.zbots_actions[ action_name ].on_completion_func = on_completion_func;
 	level.zbots_actions[ action_name ].should_cancel_func = should_cancel_func;
 	level.zbots_actions[ action_name ].on_cancel_func = on_cancel_func;
 	level.zbots_actions[ action_name ].should_postpone_func = should_postpone_func;
@@ -28,15 +30,125 @@ register_bot_action( group, action_name, action_func, should_do_func, action_pro
 	level.zbots_actions[ action_name ].priority_func = priority_func;
 }
 
-register_bot_action_queue_action( action_name )
+initialize_bot_actions_queue()
 {
-	if ( !isDefined( self.actions_in_queue ) )
+	keys = getArrayKeys( level.zbots_actions );
+	for ( i = 0; i < keys.size; i++ )
 	{
-		self.actions_in_queue = [];
+		self register_bot_objective_action_for_queue( keys[ i ], level.zbots_actions[ keys[ i ] ].group );
+	}
+}
+
+register_bot_objective_action_for_queue( action_name )
+{
+	if ( !isDefined( self.zbot_actions_in_queue ) )
+	{
+		self.zbot_actions_in_queue = [];
+	}
+	if ( !isDefined( self.zbot_actions_in_queue[ group_name ] ) )
+	{
+		self.zbot_actions_in_queue[ group_name ] = [];
+	}
+	self.zbot_actions_in_queue[ group_name ][ action_name ] = spawnStruct();
+	self.zbot_actions_in_queue[ group_name ][ action_name ].postponed = false;
+	self.zbot_actions_in_queue[ group_name ][ action_name ].canceled = false;
+	self.zbot_actions_in_queue[ group_name ][ action_name ].queued = false;
+	self.zbot_actions_in_queue[ group_name ][ action_name ].completed = false;
+	self.zbot_actions_in_queue[ group_name ][ action_name ].is_current = false;
+}
+
+process_next_queued_action( group_name )
+{
+	if ( self.action_queue.size <= 0 )
+	{
+		return;
+	}
+	self [[ self.action_queue[ group_name ][ 0 ].action ]]();
+
+	self wait_for_action_completion( self.action_queue[ group_name ][ 0 ].action_name );
+}
+
+wait_for_action_completion( group_name, action_name )
+{
+	result = self waittill_any_return( action_name + "_completion", action_name + "_cancel", action_name + "_postpone", "disconnect" );
+	if ( !isDefined( result ) )
+	{
+		return;
+	}
+	if ( result == "disconnect" )
+	{
+		return;
+	}
+	if ( ( result == action_name + "_completion" ) )
+	{
+		self.zbot_actions_in_queue[ group_name ][ self.action_queue[ group_name ][ 0 ].action_name ].postponed = false;
+		self.zbot_actions_in_queue[ group_name ][ self.action_queue[ group_name ][ 0 ].action_name ].queued = false;
+		arrayRemoveIndex( self.action_queue[ group_name ], 0 );
+		self thread [[ self.action_queue[ group_name ][ 0 ].on_completion_func ]]();
+	}
+	else if ( result == action_name + "_cancel" )
+	{
+		self.zbot_actions_in_queue[ group_name ][ self.action_queue[ group_name ][ 0 ].action_name ].postponed = false;
+		self.zbot_actions_in_queue[ group_name ][ self.action_queue[ group_name ][ 0 ].action_name ].queued = false;
+		arrayRemoveIndex( self.action_queue[ group_name ], 0 );
+		self thread [[ self.action_queue[ group_name ][ 0 ].on_cancel_func ]]();
+	}
+	else if ( result == action_name + "_postpone" )
+	{
+		self.zbot_actions_in_queue[ group_name ][ self.action_queue[ group_name ][ 0 ].action_name ].postponed = true;
+		postponed_action = self.action_queue[ group_name ][ 0 ];
+		arrayRemoveIndex( self.action_queue[ group_name ], 0 );
+		postponed_action.priority = 0;
+		self.action_queue[ group_name ][ self.action_queue[ group_name ].size ] = postponed_action;
+		self thread [[ self.action_queue[ group_name ][ 0 ].on_postpone_func ]]();
+	}
+}
+
+copy_default_action_settings_to_queue( group_name, action_name )
+{
+	//self.group = level.zbots_actions[ group_name ][ action_name ].group;
+	self.action = level.zbots_actions[ group_name ][ action_name ].action;
+	//self.should_do_func = level.zbots_actions[ group_name ][ action_name ].should_do_func;
+	self.on_completion_func = level.zbots_actions[ group_name ][ action_name ].on_completion_func;
+	self.should_cancel_func = level.zbots_actions[ group_name ][ action_name ].should_cancel_func;
+	self.on_cancel_func = level.zbots_actions[ group_name ][ action_name ].on_cancel_func;
+	self.should_postpone_func = level.zbots_actions[ group_name ][ action_name ].should_postpone_func;
+	self.on_postpone_func = level.zbots_actions[ group_name ][ action_name ].on_postpone_func;
+	self.priority_func = level.zbots_actions[ group_name ][ action_name ].priority_func;
+}
+
+pick_actions_to_add_to_queue( group_name, action_keys )
+{
+	for ( i = 0; i < action_keys.size; i++ )
+	{
+		if ( !self.zbot_actions_in_queue[ group_name ][ action_keys[ i ] ].queued && [[ level.zbots_actions[ group_name ][ action_keys[ i ] ].should_do_func ]]() )
+		{
+			self.action_queue[ group_name ][ self.action_queue[ group_name ].size ] = spawnStruct();
+			self.action_queue[ group_name ][ self.action_queue[ group_name ].size - 1 ].action_name = action_keys[ i ];
+			self.action_queue[ group_name ][ self.action_queue[ group_name ].size - 1 ].priority = self [[ level.zbots_actions[ group_name ][ action_keys[ i ] ].priority_func ]]();
+			self.zbot_actions_in_queue[ group_name ][ action_keys[ i ] ].queued = true;
+		}
+	}
+}
+
+check_if_actions_should_be_canceled_in_group( group_name, action_keys )
+{
+	for ( i = 0; i < action_keys.size; i++ )
+	{
+		if ( self.zbot_actions_in_queue[ group_name ][ action_keys[ i ] ].queued && [[ level.zbots_actions[ group_name ][ action_keys[ i ] ].should_cancel_func ]]() )
+		{
+			self notify( action_keys[ i ] + "_cancel" );
+		}
+	}
+}
+
+check_if_actions_should_be_postponed_in_group( group_name, action_keys )
+{
+	for ( i = 0; i < action_keys.size; i++ )
+	{
+		if ( self.zbot_actions_in_queue[ group_name ][ action_keys[ i ] ].queued && [[ level.zbots_actions[ group_name ][ action_keys[ i ] ].should_postpone_func ]]() )
+		{
+			self notify( action_keys[ i ] + "_postpone" );
+		}
 	}
-	self.actions_in_queue[ action_name ] = spawnStruct();
-	self.actions_in_queue[ action_name ].postponed = false;
-	self.actions_in_queue[ action_name ].canceled = false;
-	self.actions_in_queue[ action_name ].queued = false;
-	self.actions_in_queue[ action_name ].completed = false;
 }