Format for an instruction
template<class	X>
class	ai_instruction
{
	public:
	ai_instruction()
	{
		pObject		=	NULL;
		pFunc		=	NULL;
		unknowns	=	NULL;
	}

	
	ai_instruction(X*_pObject,void(X::*_pFunc)(ai_instruction<X>&))
	{
		pObject	=	_pObject;
		pFunc	=	_pFunc;
	}

	void	clear_cache()
	{
		float_params.clear();
		int_params.clear();

		if(unknowns)
		{
			delete[] unknowns;
			unknowns	=	NULL;
		}

		if(vectors)
		{
			delete[]	vectors;
			vectors	=	NULL;
		}
	}

	void	operator()(ai_instruction<X>&)
	{
		if(pFunc && pObject)
		{	
			(*pObject.*pFunc)(*this);
		}
	}
	X	*pObject;
	void	(X::*pFunc)(ai_instruction<X>&);	//instruction pointer
	Vector3	*vectors;
	std::vector<int>		int_params;
	std::vector<float>		float_params;

	void	*unknowns;	
};

...

The definition of some basic instructions
#ifndef	HOVERTANK_INSTRUCTION_SET_H
#define	HOVERTANK_INSTRUCTION_SET_H

enum	Instruction_Categories	{Navigation = 0,Weaponry};

enum	Navigation_Instructions	{TurnToGoal = 0, KillRotation,KillMovement, CG_Shift,NUM_NAV_INSTRUCTIONS};	

enum	Weaponry_Instructions	{Fire = NUM_NAV_INSTRUCTIONS, Turret_Aim, Missile_Aim,NUM_WEAPONRY_INSTRUCTIONS};	

#define	NUM_HOVERTANK_INSTRUCTIONS	(NUM_NAV_INSTRUCTIONS + NUM_WEAPONRY_INSTRUCTIONS)

#endif

...

The implementation of the instructions, in this case it just prints to the screen which instruction 
the craft is currently executing, the actual functionality was removed on purpose

void	Hovertank::linear_stop(ai_instruction<Hovertank>&a)
{
	gpTextManager->PushLineOfText("Hovertank::linear_stop",-1024,1.0f,0.0f,0.0f);
	current_instruction			 = angular_stop_inst;
}

void	Hovertank::angular_stop(ai_instruction<Hovertank>&a)
{
	gpTextManager->PushLineOfText("Hovertank::angular_stop",-1024,1.0f,0.0f,0.0f);
	current_instruction			 = move_to_goal_inst;
}

void	Hovertank::move_to_goal(ai_instruction<Hovertank>&a)
{
	gpTextManager->PushLineOfText("Hovertank::move_to_goal",-1024,1.0f,0.0f,0.0f);
	current_instruction			 = rotate_to_goal_inst;
}

void	Hovertank::rotate_to_goal(ai_instruction<Hovertank>&a)
{
	gpTextManager->PushLineOfText("Hovertank::rotate_to_goal",-1024,1.0f,0.0f,0.0f);
	current_instruction			 = fire_projectile_inst;
}

void	Hovertank::fire_projectile(ai_instruction<Hovertank>&a)
{
	gpTextManager->PushLineOfText("Hovertank::fire_projectile",-1024,1.0f,0.0f,0.0f);
	current_instruction			 = linear_stop_inst;
}

..

The initialization of the instructions inside the constructor

	hovertank_instruction_set[linear_stop_inst]		=	ai_instruction<Hovertank>(this,&Hovertank::linear_stop);
	hovertank_instruction_set[angular_stop_inst]	=	ai_instruction<Hovertank>(this,&Hovertank::angular_stop);
	hovertank_instruction_set[move_to_goal_inst]	=	ai_instruction<Hovertank>(this,&Hovertank::move_to_goal);
	hovertank_instruction_set[rotate_to_goal_inst]	=	ai_instruction<Hovertank>(this,&Hovertank::rotate_to_goal);
	hovertank_instruction_set[fire_projectile_inst]	=	ai_instruction<Hovertank>(this,&Hovertank::fire_projectile);