void ai_player::on_Attacked_By(drawable_object* attacked, drawable_object* attacking){
	// ...
}

void ai_player::on_Ally_Attacked(drawable_object* attacking){
	// ...
}

void ai_player::on_Seen_Ennemy(drawable_object* ennemy){
	// ...
}

void ai_player::on_No_More_Money(){
	// ...
}

... 

class mesh_manager{
public:
	mesh_manager(graphics_engine*);
	~mesh_manager();
	irr::scene::IAnimatedMesh *get_mesh(std::string&);
private:
	graphics_engine *parent;
	std::map<std::string, irr::scene::IAnimatedMesh*> l_meshes;
};

irr::scene::IAnimatedMesh *mesh_manager::get_mesh(std::string& s){
	if (l_meshes.find(s) == l_meshes.end()){
		std::string filename = shared::get()->get_data()->get_objects_path()+s;
		irr::scene::IAnimatedMesh *m = parent->get_scene_graph()->smgr->getMesh( filename.c_str());
		if (m == NULL){
			shared::get()->get_logger()(logger::LL_ERROR) << "Cannot load mesh "<< filename << std::endl;
			return NULL;
		}
		
		l_meshes[s] = m;
		return m;
	}else
		return l_meshes[s];
}

void network_machine::TCP_async_receive(const asio::error_code& e, size_t bytes_received){
	if (e){
		// il y a eu une erreur réseau. 
		
		// traiter l'erreur, par exemple en supprimant la machine d'où vient le message
		return;
	}

	// on désérialise le flux reçu
	std::string str_data(&network_buffer[0], network_buffer.size());
	std::istringstream archive_stream(str_data);
	boost::archive::text_iarchive archive(archive_stream);

	engine_event ne;
	archive >> ne;

	// on ajoute une traçabilité du message
	ne.i_data["FROM"] = id;

	parent->process_event(ne);
}

void network_context::UDP_async_read(const asio::error_code& e, std::size_t){
	if (e){
		// il y a eu une erreur réseau. 
		
		// traiter l'erreur, par exemple en supprimant la machine d'où vient le message
		return;
	}
	
	// on vérifie l'origine du message	
	int machine_id = is_address_registered(udp_remote_endpoint.address().to_string());
	if (machine_id == -1)
		return;
	
	// on désérialise le message
	std::string str_data(&network_buffer[0], network_buffer.size());
	std::istringstream archive_stream(str_data);
	boost::archive::text_iarchive archive(archive_stream);

	engine_event ne;
	archive >> ne;

	// on ajoute une traçabilité
	ne.i_data["FROM"] = machine_id;

	// on traite le message reçu
	process_event(ne);
}

void server_context::process_event(engine_event &e){
	switch(e.type){
		case engine_event::PLAYER_HAS_CHANGED_OPTIONS:	
			process_client_has_changed_options(e); break;
		case engine_event::CHAT:				process_chat_message(e);break;
		case engine_event::ADD_NODE:			process_add(e);			break;
		case engine_event::REM_NODE:			process_rm(e);			break;
		case engine_event::MOVE_NODE:			process_move(e);		break;
		case engine_event::CHOSEN_MAP:			break;	// erreur de protocole, 
										// les clients n'ont pas le droit d'envoyer ces messages
		default:
			// appel d'un traitement plus général
			network_context::process_event(e);
	}
}

	irr::core::position2di r;
	widget_container *k = get_gui_container();	
	
	// tout d'abord les arrières plans
	std::pair<int, int> res = parent->get_resolution();
	r = irr::core::position2di(res.first - 180, res.second - 100);
	image_widget *bg_bottom_right = new image_widget(
		k, 			// élément parent
		r, 			// position du coin supérieur gauche, en pixels
		std::string("bg-bottom-right.png")// nom de la texture à afficher
	);	

	r = irr::core::position2di(0, res.second - 70);
	image_widget *bg_bottom_left = new image_widget(
		k, 			// élément parent
		r, 			// position du coin supérieur gauche, en pixels
		std::string("bg-bottom-left.png")// nom de la texture à afficher
	);	
	
	// ensuite les autres widgets
	r = irr::core::position2di(250, 100);
	new image_button(
		k, 			// élément parent
		r, 			// position du coin supérieur gauche, en pixels
		std::string("defend.png"), 		// nom de la texture 'normale'
		std::string("defend-bright.png"), // nom de la texture 'on mouse over'
		std::string("defend.png")		// nom de la texture 'on clic'
	);

	r = irr::core::position2di(250, 300);
	new timed_button(
		k, 			// élément parent
		r, 			// position du coin supérieur gauche, en pixels
		std::string("defend.png"), 		// nom de la texture 'normale'
		std::string("defend-bright.png"), // nom de la texture 'on mouse over'
		std::string("defend.png"), 		// nom de la texture 'on clic'
		irr::core::position2di(8, 20), 	// décalage avec le coin sup gauche du texte
		34				// temps du timer, en secondes
	);

bool game_event_handler::OnEvent(irr::SEvent e){
	if (!parent->get_device())
		return false;

	if (!parent->get_device()->isWindowActive())
		return true;

	// on crée une simple déviation des messages pour les amener dans la GUI
	widget *w = parent->get_gui()->get_kakou_gui_system()->is_event_for_me(e);
	if (w != NULL){
		w->process_event(e);
	}
		
	// reprise du cheminement normal
	switch (e.EventType){			
		[...]
		
}

void cegui_gui_system::render(){
	if (current_screen == gui_system::MAIN_GAME_SCREEN){
		k->draw();	
	}
	
	boost::mutex::scoped_lock lock(mutex_gui);
	CEGUI::System::getSingleton().renderGUI();
}

struct obj_dist{
	float distance;
	drawable_object* o;
};

class data_container{
public:
	data_container();
	~data_container();
	
	// 2 fonctions pour repérer des objets autour d'un point (x,y) ou d'un objet précis
	virtual std::list<obj_dist> get_objects(float x, float y, float dist, obj_functor&)=0;
	virtual std::list<obj_dist> get_objects(drawable_object*, float dist, obj_functor&)=0;

	// 2 fonctions pour repérer l'objet le plus proche d'un point (x,y) ou d'un objet précis
	virtual drawable_object* get_first(float x, float y, obj_functor&)=0;
	virtual drawable_object* get_first(drawable_object*, obj_functor&)=0;
};

class data_item{
public:
	data_item(){is_empty = true;}
	float x,z;

	// liste de tous les objets présents dans la case, classés par joueur		
	std::vector<std::list<drawable_object*>> obj;	

	bool is_empty;

	drawable_object* get_first_ennemy(drawable_object*, float);
	drawable_object* get_first_unit(float, float, float);
	drawable_object* get_first_unit(drawable_object*, float, obj_functor&);
	drawable_object* get_first_unit(drawable_object*, obj_functor&);
};

void calculator_mgr::run(){
	bool b;
	boost::mutex::scoped_lock l(still_running_mutex);
		b = still_running;
	l.unlock();
	while (b){
		// on vérifie s'il y a des actions dans la liste
		if (!q.empty()){
			boost::posix_time::ptime now(boost::posix_time::microsec_clock::local_time());
			
			boost::mutex::scoped_lock l2(queue_mutex);
				calculator_todo *c = *(q.begin());
				q.erase(q.begin());
			l2.unlock();

			// on calcule le temps jusqu'à la prochaine action à réaliser
			boost::posix_time::ptime::time_duration_type time_to_wait( c->n - now);
			
			// on attend la prochaine action
			asio::deadline_timer timer(io, time_to_wait);
			timer.wait();

			// on exécute l'action
			c->run();
			delete c;

		}else{
			// la liste est vide, on patiente un peu
			// .04 s <-> 25 FPS
			asio::deadline_timer timer(io, boost::posix_time::microsec(40000));  
			timer.wait();
		}

		l.lock();
		b = still_running;
		l.unlock();
	}
}

	boost::mutex::scoped_lock l(still_running_mutex);
		still_running = false;
	l.unlock();

	// on attend la fin du thread
	t->join();