The Battle for Wesnoth  1.17.0-dev
manager.cpp
Go to the documentation of this file.
1 /*
2  Copyright (C) 2009 - 2021
3  by Yurii Chernyi <terraninfo@terraninfo.net>
4  Part of the Battle for Wesnoth Project https://www.wesnoth.org/
5 
6  This program is free software; you can redistribute it and/or modify
7  it under the terms of the GNU General Public License as published by
8  the Free Software Foundation; either version 2 of the License, or
9  (at your option) any later version.
10  This program is distributed in the hope that it will be useful,
11  but WITHOUT ANY WARRANTY.
12 
13  See the COPYING file for more details.
14 */
15 
16 /**
17  * Managing the AI lifecycle and interface for the rest of Wesnoth
18  * @file
19  */
20 
21 #include "ai/manager.hpp"
22 
23 #include "config.hpp" // for config, etc
24 #include "game_events/pump.hpp"
25 #include "log.hpp"
26 #include "map/location.hpp" // for map_location
27 #include "resources.hpp"
29 #include "tod_manager.hpp"
30 
31 #include "ai/composite/ai.hpp" // for ai_composite
32 #include "ai/composite/component.hpp" // for component_manager
33 #include "ai/composite/engine.hpp" // for engine
35 #include "ai/configuration.hpp" // for configuration
36 #include "ai/contexts.hpp" // for readonly_context, etc
37 #include "ai/default/contexts.hpp" // for default_ai_context, etc
38 #include "game_end_exceptions.hpp" // for ai_end_turn_exception
39 #include "ai/game_info.hpp" // for side_number, engine_ptr, etc
40 #include "game_config.hpp" // for debug
42 #include "ai/registry.hpp" // for init
43 #include "ai/lua/engine_lua.hpp"
44 
45 #include <algorithm> // for min
46 #include <cassert> // for assert
47 #include <iterator> // for reverse_iterator, etc
48 #include <map> // for _Rb_tree_iterator, etc
49 #include <ostream> // for operator<<, basic_ostream, etc
50 #include <set> // for set
51 #include <stack> // for stack
52 #include <utility> // for pair, make_pair
53 #include <vector> // for vector, allocator, etc
54 
55 #include <SDL2/SDL_timer.h>
56 
57 namespace ai {
58 
59 const std::string manager::AI_TYPE_COMPOSITE_AI = "composite_ai";
60 const std::string manager::AI_TYPE_SAMPLE_AI = "sample_ai";
61 const std::string manager::AI_TYPE_IDLE_AI = "idle_ai";
62 const std::string manager::AI_TYPE_FORMULA_AI = "formula_ai";
63 const std::string manager::AI_TYPE_DEFAULT = "default";
64 
65 static lg::log_domain log_ai_manager("ai/manager");
66 #define DBG_AI_MANAGER LOG_STREAM(debug, log_ai_manager)
67 #define LOG_AI_MANAGER LOG_STREAM(info, log_ai_manager)
68 #define ERR_AI_MANAGER LOG_STREAM(err, log_ai_manager)
69 
70 static lg::log_domain log_ai_mod("ai/mod");
71 #define DBG_AI_MOD LOG_STREAM(debug, log_ai_mod)
72 #define LOG_AI_MOD LOG_STREAM(info, log_ai_mod)
73 #define WRN_AI_MOD LOG_STREAM(warn, log_ai_mod)
74 #define ERR_AI_MOD LOG_STREAM(err, log_ai_mod)
75 
76 holder::holder( side_number side, const config &cfg )
77  : ai_(), side_context_(nullptr), readonly_context_(nullptr), readwrite_context_(nullptr), default_ai_context_(nullptr), side_(side), cfg_(cfg)
78 {
79  DBG_AI_MANAGER << describe_ai() << "Preparing new AI holder" << std::endl;
80 }
81 
83 {
84  if (side_context_ == nullptr) {
85  side_context_.reset(new side_context_impl(side,cfg_));
86  } else {
87  side_context_->set_side(side);
88  }
89  if (readonly_context_ == nullptr){
91  readonly_context_->on_readonly_context_create();
92  }
93  if (readwrite_context_ == nullptr){
95  }
96  if (default_ai_context_ == nullptr){
98  }
99  if (!this->ai_){
101  }
102 
103  if (this->ai_) {
104  ai_->on_create();
105  for (config &mod_ai : cfg_.child_range("modify_ai")) {
106  if (!mod_ai.has_attribute("side")) {
107  mod_ai["side"] = side;
108  }
109  modify_ai(mod_ai);
110  }
111  for(config& micro : cfg_.child_range("micro_ai")) {
112  micro["side"] = side;
113  micro["action"] = "add";
114  micro_ai(micro);
115  }
116  cfg_.clear_children("modify_ai", "micro_ai");
117 
118  std::vector<engine_ptr> engines = ai_->get_engines();
119  for (std::vector<engine_ptr>::iterator it = engines.begin(); it != engines.end(); ++it)
120  {
121  (*it)->set_ai_context(&(ai_->get_ai_context()));
122  }
123 
124  } else {
125  ERR_AI_MANAGER << describe_ai()<<"AI lazy initialization error!" << std::endl;
126  }
127 
128 }
129 
131 {
132  try {
133  if (this->ai_) {
134  LOG_AI_MANAGER << describe_ai() << "Managed AI will be deleted" << std::endl;
135  }
136  } catch (...) {}
137 }
138 
140 {
141  if (!this->ai_) {
142  this->init(this->side_);
143  }
144  assert(this->ai_);
145 
146  return *this->ai_;
147 }
148 
149 void holder::micro_ai(const config& cfg)
150 {
151  if (!this->ai_) {
152  this->init(this->side_);
153  }
154  assert(this->ai_);
155 
156  auto engine = this->ai_->get_engine_by_cfg(config{"engine", "lua"});
157  if(auto lua = std::dynamic_pointer_cast<engine_lua>(engine)) {
158  lua->apply_micro_ai(cfg);
159  }
160 }
161 
162 void holder::modify_ai(const config &cfg)
163 {
164  if (!this->ai_) {
165  // if not initialized, initialize now.
166  get_ai_ref();
167  }
168  const std::string &act = cfg["action"];
169  LOG_AI_MOD << "side "<< side_ << " "<<act<<"_ai_component \""<<cfg["path"]<<"\""<<std::endl;
170  DBG_AI_MOD << std::endl << cfg << std::endl;
171  DBG_AI_MOD << "side "<< side_ << " before "<<act<<"_ai_component"<<std::endl << to_config() << std::endl;
172  bool res = false;
173  if (act == "add") {
174  res = component_manager::add_component(&*this->ai_,cfg["path"],cfg);
175  } else if (act == "change") {
176  res = component_manager::change_component(&*this->ai_,cfg["path"],cfg);
177  } else if (act == "delete") {
178  res = component_manager::delete_component(&*this->ai_,cfg["path"]);
179  } else {
180  ERR_AI_MOD << "modify_ai tag has invalid 'action' attribute " << act << std::endl;
181  }
182  DBG_AI_MOD << "side "<< side_ << " after [modify_ai]"<<act<<std::endl << to_config() << std::endl;
183  if (!res) {
184  LOG_AI_MOD << act << "_ai_component failed"<< std::endl;
185  } else {
186  LOG_AI_MOD << act << "_ai_component success"<< std::endl;
187  }
188 
189 }
190 
191 void holder::append_ai(const config& cfg)
192 {
193  if(!this->ai_) {
194  get_ai_ref();
195  }
196  for(const config& aspect : cfg.child_range("aspect")) {
197  const std::string& id = aspect["id"];
198  for(const config& facet : aspect.child_range("facet")) {
199  ai_->add_facet(id, facet);
200  }
201  }
202  for(const config& goal : cfg.child_range("goal")) {
203  ai_->add_goal(goal);
204  }
205  for(const config& stage : cfg.child_range("stage")) {
206  if(stage["name"] != "empty") {
207  ai_->add_stage(stage);
208  }
209  }
210  for(config mod : cfg.child_range("modify_ai")) {
211  if (!mod.has_attribute("side")) {
212  mod["side"] = side_context_->get_side();
213  }
214  modify_ai(mod);
215  }
216  for(config micro : cfg.child_range("micro_ai")) {
217  micro["side"] = side_context_->get_side();
218  micro["action"] = "add";
219  micro_ai(micro);
220  }
221 }
222 
224 {
225  if (!this->ai_) {
226  return cfg_;
227  } else {
228  config cfg = ai_->to_config();
229  if (this->side_context_!=nullptr) {
230  cfg.merge_with(this->side_context_->to_side_context_config());
231  }
232  if (this->readonly_context_!=nullptr) {
233  cfg.merge_with(this->readonly_context_->to_readonly_context_config());
234  }
235  if (this->readwrite_context_!=nullptr) {
236  cfg.merge_with(this->readwrite_context_->to_readwrite_context_config());
237  }
238  if (this->default_ai_context_!=nullptr) {
239  cfg.merge_with(this->default_ai_context_->to_default_ai_context_config());
240  }
241 
242  return cfg;
243  }
244 }
245 
246 const std::string holder::describe_ai()
247 {
248  std::string sidestr = std::to_string(this->side_);
249 
250  if (this->ai_!=nullptr) {
251  return this->ai_->describe_self()+std::string(" for side ")+sidestr+std::string(" : ");
252  } else {
253  return std::string("not initialized ai with id=[")+cfg_["id"]+std::string("] for side ")+sidestr+std::string(" : ");
254  }
255 }
256 
257 const std::string holder::get_ai_overview()
258 {
259  if (!this->ai_) {
260  get_ai_ref();
261  }
262  // These assignments are necessary because the code will otherwise not compile on some platforms with an lvalue/rvalue mismatch error
263  auto lik = this->ai_->get_leader_ignores_keep();
264  auto pl = this->ai_->get_passive_leader();
265  auto plsk = this->ai_->get_passive_leader_shares_keep();
266  // In order to display booleans as yes/no rather than 1/0 or true/false
267  config cfg;
268  cfg["simple_targeting"] = this->ai_->get_simple_targeting();
269  cfg["support_villages"] = this->ai_->get_support_villages();
270  std::stringstream s;
271  s << "advancements: " << this->ai_->get_advancements().get_value() << std::endl;
272  s << "aggression: " << this->ai_->get_aggression() << std::endl;
273  s << "caution: " << this->ai_->get_caution() << std::endl;
274  s << "grouping: " << this->ai_->get_grouping() << std::endl;
275  s << "leader_aggression: " << this->ai_->get_leader_aggression() << std::endl;
276  s << "leader_ignores_keep: " << utils::visit(leader_aspects_visitor(), lik) << std::endl;
277  s << "leader_value: " << this->ai_->get_leader_value() << std::endl;
278  s << "passive_leader: " << utils::visit(leader_aspects_visitor(), pl) << std::endl;
279  s << "passive_leader_shares_keep: " << utils::visit(leader_aspects_visitor(), plsk) << std::endl;
280  s << "recruitment_diversity: " << this->ai_->get_recruitment_diversity() << std::endl;
281  s << "recruitment_instructions: " << std::endl << "----config begin----" << std::endl;
282  s << this->ai_->get_recruitment_instructions() << "-----config end-----" << std::endl;
283  s << "recruitment_more: " << utils::join(this->ai_->get_recruitment_more()) << std::endl;
284  s << "recruitment_pattern: " << utils::join(this->ai_->get_recruitment_pattern()) << std::endl;
285  s << "recruitment_randomness: " << this->ai_->get_recruitment_randomness() << std::endl;
286  s << "recruitment_save_gold: " << std::endl << "----config begin----" << std::endl;
287  s << this->ai_->get_recruitment_save_gold() << "-----config end-----" << std::endl;
288  s << "retreat_enemy_weight: " << this->ai_->get_retreat_enemy_weight() << std::endl;
289  s << "retreat_factor: " << this->ai_->get_retreat_factor() << std::endl;
290  s << "scout_village_targeting: " << this->ai_->get_scout_village_targeting() << std::endl;
291  s << "simple_targeting: " << cfg["simple_targeting"] << std::endl;
292  s << "support_villages: " << cfg["support_villages"] << std::endl;
293  s << "village_value: " << this->ai_->get_village_value() << std::endl;
294  s << "villages_per_scout: " << this->ai_->get_villages_per_scout() << std::endl;
295 
296  return s.str();
297 }
298 
299 const std::string holder::get_ai_structure()
300 {
301  if (!this->ai_) {
302  get_ai_ref();
303  }
304  return component_manager::print_component_tree(&*this->ai_,"");
305 }
306 
307 const std::string holder::get_ai_identifier() const
308 {
309  return cfg_["id"];
310 }
311 
312 component* holder::get_component(component *root, const std::string &path) {
313  if (!game_config::debug) // Debug guard
314  {
315  return nullptr;
316  }
317 
318  if (root == nullptr) // Return root component(ai_)
319  {
320  if (!this->ai_) {
321  this->init(this->side_);
322  }
323  assert(this->ai_);
324 
325  return &*this->ai_;
326  }
327 
328  return component_manager::get_component(root, path);
329 }
330 
331 // =======================================================================
332 // LIFECYCLE
333 // =======================================================================
334 
336  : history_()
337  , history_item_counter_(0)
338  , ai_info_()
339  , map_changed_("ai_map_changed")
340  , recruit_list_changed_("ai_recruit_list_changed")
341  , user_interact_("ai_user_interact")
342  , sync_network_("ai_sync_network")
343  , tod_changed_("ai_tod_changed")
344  , gamestate_changed_("ai_gamestate_changed")
345  , turn_started_("ai_turn_started")
346  , last_interact_(0)
347  , num_interact_(0)
348 {
349  registry::init();
350  singleton_ = this;
351 }
352 
353 manager* manager::singleton_ = nullptr;
354 
356  user_interact_.attach_handler(event_observer);
357  sync_network_.attach_handler(event_observer);
358  turn_started_.attach_handler(event_observer);
359  gamestate_changed_.attach_handler(event_observer);
360 }
361 
363  user_interact_.detach_handler(event_observer);
364  sync_network_.detach_handler(event_observer);
365  turn_started_.detach_handler(event_observer);
366  gamestate_changed_.detach_handler(event_observer);
367 }
368 
370  gamestate_changed_.attach_handler(event_observer);
371  turn_started_.attach_handler(event_observer);
372  map_changed_.attach_handler(event_observer);
373 }
374 
376  gamestate_changed_.detach_handler(event_observer);
377  turn_started_.detach_handler(event_observer);
378  map_changed_.detach_handler(event_observer);
379 }
380 
382  tod_changed_.attach_handler(event_observer);
383 }
384 
386  tod_changed_.detach_handler(event_observer);
387 }
388 
390 {
391  map_changed_.attach_handler(event_observer);
392 }
393 
395 {
396  recruit_list_changed_.attach_handler(event_observer);
397 }
398 
400 {
401  turn_started_.attach_handler(event_observer);
402 }
403 
405 {
406  recruit_list_changed_.detach_handler(event_observer);
407 }
408 
410 {
411  map_changed_.detach_handler(event_observer);
412 }
413 
415 {
416  turn_started_.detach_handler(event_observer);
417 }
418 
421  return;
422  }
423 
424  const int interact_time = 30;
425  const int time_since_interact = SDL_GetTicks() - last_interact_;
426  if(time_since_interact < interact_time) {
427  return;
428  }
429 
430  ++num_interact_;
432 
433  last_interact_ = SDL_GetTicks();
434 
435 }
436 
439 }
440 
443 }
444 
447 }
448 
451 }
452 
455 }
456 
459 }
460 
461 // =======================================================================
462 // EVALUATION
463 // =======================================================================
464 
465 const std::string manager::evaluate_command( side_number side, const std::string& str )
466 {
467  //insert new command into history
468  history_.emplace_back(history_item_counter_++,str);
469 
470  //prune history - erase 1/2 of it if it grows too large
471  if (history_.size()>MAX_HISTORY_SIZE){
472  history_.erase(history_.begin(),history_.begin()+MAX_HISTORY_SIZE/2);
473  LOG_AI_MANAGER << "AI MANAGER: pruned history" << std::endl;
474  }
475 
476  if (!should_intercept(str)){
479  return ai.evaluate(str);
480  }
481 
482  return internal_evaluate_command(side,str);
483 }
484 
485 bool manager::should_intercept( const std::string& str ) const
486 {
487  if (str.length()<1) {
488  return false;
489  }
490  if (str.at(0)=='!'){
491  return true;
492  }
493  if (str.at(0)=='?'){
494  return true;
495  }
496  return false;
497 
498 }
499 
500 // this is stub code to allow testing of basic 'history', 'repeat-last-command', 'add/remove/replace ai' capabilities.
501 // yes, it doesn't look nice. but it is usable.
502 // to be refactored at earliest opportunity
503 // TODO: extract to separate class which will use fai or lua parser
504 const std::string manager::internal_evaluate_command( side_number side, const std::string& str ){
505  const int MAX_HISTORY_VISIBLE = 30;
506 
507  //repeat last command
508  if (str=="!") {
509  //this command should not be recorded in history
510  if (!history_.empty()){
511  history_.pop_back();
513  }
514 
515  if (history_.empty()){
516  return "AI MANAGER: empty history";
517  }
518  return evaluate_command(side, history_.back().get_command());//no infinite loop since '!' commands are not present in history
519  };
520  //show last command
521  if (str=="?") {
522  //this command should not be recorded in history
523  if (!history_.empty()){
524  history_.pop_back();
526  }
527 
528  if (history_.empty()){
529  return "AI MANAGER: History is empty";
530  }
531 
532  int n = std::min<int>( MAX_HISTORY_VISIBLE, history_.size() );
533  std::stringstream strstream;
534  strstream << "AI MANAGER: History - last "<< n <<" commands:\n";
535  std::deque< command_history_item >::reverse_iterator j = history_.rbegin();
536 
537  for (int cmd_id=n; cmd_id>0; --cmd_id){
538  strstream << j->get_number() << " :" << j->get_command() << '\n';
539  ++j;//this is *reverse* iterator
540  }
541 
542  return strstream.str();
543  };
544 
545  std::vector< std::string > cmd = utils::parenthetical_split(str, ' ',"'","'");
546 
547  if (cmd.size()==3){
548  // add_ai side file
549  if (cmd.at(0)=="!add_ai"){
550  side = std::stoi(cmd.at(1));
551  std::string file = cmd.at(2);
552  if (add_ai_for_side_from_file(side,file,false)){
553  return std::string("AI MANAGER: added [")+manager::get_active_ai_identifier_for_side(side)+std::string("] AI for side ")+std::to_string(side)+std::string(" from file ")+file;
554  } else {
555  return std::string("AI MANAGER: failed attempt to add AI for side ")+std::to_string(side)+std::string(" from file ")+file;
556  }
557  }
558  // replace_ai side file
559  if (cmd.at(0)=="!replace_ai"){
560  side = std::stoi(cmd.at(1));
561  std::string file = cmd.at(2);
562  if (add_ai_for_side_from_file(side,file,true)){
563  return std::string("AI MANAGER: added [")+manager::get_active_ai_identifier_for_side(side)+std::string("] AI for side ")+std::to_string(side)+std::string(" from file ")+file;
564  } else {
565  return std::string("AI MANAGER: failed attempt to add AI for side ")+std::to_string(side)+std::string(" from file ")+file;
566  }
567  }
568 
569  } else if (cmd.size()==2){
570  // remove_ai side
571  if (cmd.at(0)=="!remove_ai"){
572  side = std::stoi(cmd.at(1));
573  remove_ai_for_side(side);
574  return std::string("AI MANAGER: made an attempt to remove AI for side ")+std::to_string(side);
575  }
576  if (cmd.at(0)=="!"){
577  //this command should not be recorded in history
578  if (!history_.empty()){
579  history_.pop_back();
581  }
582 
583  int command = std::stoi(cmd.at(1));
584  std::deque< command_history_item >::reverse_iterator j = history_.rbegin();
585  //yes, the iterator could be precisely positioned (since command numbers go 1,2,3,4,..). will do it later.
586  while ( (j!=history_.rend()) && (j->get_number()!=command) ){
587  ++j;// this is *reverse* iterator
588  }
589  if (j!=history_.rend()){
590  return evaluate_command(side,j->get_command());//no infinite loop since '!' commands are not present in history
591  }
592  return "AI MANAGER: no command with requested number found";
593  }
594  } else if (cmd.size()==1){
595  if (cmd.at(0)=="!help") {
596  return
597  "known commands:\n"
598  "! - repeat last command (? and ! do not count)\n"
599  "! NUMBER - repeat numbered command\n"
600  "? - show a history list\n"
601  "!add_ai TEAM FILE - add a AI to side (0 - command AI, N - AI for side #N) from file\n"
602  "!remove_ai TEAM - remove AI from side (0 - command AI, N - AI for side #N)\n"
603  "!replace_ai TEAM FILE - replace AI of side (0 - command AI, N - AI for side #N) from file\n"
604  "!help - show this help message";
605  }
606  }
607 
608  return "AI MANAGER: nothing to do";
609 }
610 
611 // =======================================================================
612 // ADD, CREATE AIs, OR LIST AI TYPES
613 // =======================================================================
614 
615 bool manager::add_ai_for_side_from_file( side_number side, const std::string& file, bool replace )
616 {
617  config cfg;
619  ERR_AI_MANAGER << " unable to read [SIDE] config for side "<< side << "from file [" << file <<"]"<< std::endl;
620  return false;
621  }
622  return add_ai_for_side_from_config(side,cfg,replace);
623 }
624 
625 bool manager::add_ai_for_side_from_config( side_number side, const config& cfg, bool replace ){
626  config parsed_cfg;
627  configuration::parse_side_config(side, cfg, parsed_cfg);
628 
629  if (replace) {
630  remove_ai_for_side(side);
631  }
632 
633  std::stack<holder>& ai_stack_for_specific_side = get_or_create_ai_stack_for_side(side);
634  ai_stack_for_specific_side.emplace(side, parsed_cfg);
635  return true;
636 }
637 
638 // =======================================================================
639 // REMOVE
640 // =======================================================================
641 
643 {
644  std::stack<holder>& ai_stack_for_specific_side = get_or_create_ai_stack_for_side(side);
645  if (!ai_stack_for_specific_side.empty()){
646  ai_stack_for_specific_side.pop();
647  }
648 }
649 
651 {
652  std::stack<holder>& ai_stack_for_specific_side = get_or_create_ai_stack_for_side(side);
653 
654  //clear the stack. std::stack doesn't have a '.clear()' method to do it
655  while (!ai_stack_for_specific_side.empty()){
656  ai_stack_for_specific_side.pop();
657  }
658 }
659 
661 {
662  ai_map_.clear();
663 }
664 
666 {
668 }
669 
671 {
673 }
674 
676 {
678 }
679 
681 {
683 }
684 
686 {
688 }
689 
691 {
692  if (!game_config::debug)
693  {
694  static ai::holder empty_holder(side, config());
695  return empty_holder;
696  }
697  return get_active_ai_holder_for_side(side);
698 }
699 
701 {
703 }
704 
706 {
707  return ai_info_;
708 }
709 
711 {
712  return ai_info_;
713 }
714 
716 {
718 }
719 
720 // =======================================================================
721 // PROXY
722 // =======================================================================
723 
725  last_interact_ = 0;
726  num_interact_ = 0;
727  const int turn_start_time = SDL_GetTicks();
728  get_ai_info().recent_attacks.clear();
729  ai_composite& ai_obj = get_active_ai_for_side(side);
730  resources::game_events->pump().fire("ai_turn");
732  if (resources::tod_manager->has_tod_bonus_changed()) {
734  }
735  ai_obj.new_turn();
736  ai_obj.play_turn();
737  const int turn_end_time= SDL_GetTicks();
738  DBG_AI_MANAGER << "side " << side << ": number of user interactions: "<<num_interact_<<std::endl;
739  DBG_AI_MANAGER << "side " << side << ": total turn time: "<<turn_end_time - turn_start_time << " ms "<< std::endl;
740 }
741 
742 // =======================================================================
743 // PRIVATE
744 // =======================================================================
745 // =======================================================================
746 // AI STACKS
747 // =======================================================================
749 {
750  AI_map_of_stacks::iterator iter = ai_map_.find(side);
751  if (iter!=ai_map_.end()){
752  return iter->second;
753  }
754  return ai_map_.emplace(side, std::stack<holder>()).first->second;
755 }
756 
757 // =======================================================================
758 // AI HOLDERS
759 // =======================================================================
761 {
762  std::stack<holder>& ai_stack_for_specific_side = get_or_create_ai_stack_for_side(side);
763 
764  if (!ai_stack_for_specific_side.empty()){
765  return ai_stack_for_specific_side.top();
766  } else {
768  ai_stack_for_specific_side.emplace(side, cfg);
769  return ai_stack_for_specific_side.top();
770  }
771 }
772 
773 // =======================================================================
774 // AI POINTERS
775 // =======================================================================
776 
778 {
780 }
781 
782 // =======================================================================
783 // MISC
784 // =======================================================================
785 
786 } //end of namespace ai
virtual std::string evaluate(const std::string &str)
Evaluate command (using fai)
Definition: ai.cpp:163
void add_observer(events::observer *event_observer)
Adds observer of game events.
Definition: manager.cpp:355
#define ERR_AI_MANAGER
Definition: manager.cpp:68
::tod_manager * tod_manager
Definition: resources.cpp:30
void clear_children(T... keys)
Definition: config.hpp:557
virtual void notify_observers()
std::string join(const T &v, const std::string &s=",")
Generates a new string joining container items in a list.
void raise_gamestate_changed()
Notifies all observers of &#39;ai_gamestate_changed&#39; event.
Definition: manager.cpp:441
static bool change_component(component *root, const std::string &path, const config &cfg)
Definition: component.cpp:196
#define LOG_AI_MANAGER
Definition: manager.cpp:67
void raise_map_changed()
Notifies all observers of &#39;ai_map_changed&#39; event.
Definition: manager.cpp:457
bool should_intercept(const std::string &str) const
Determines if the command should be intercepted and evaluated as internal command.
Definition: manager.cpp:485
game_info & get_active_ai_info_for_side(side_number side)
Gets AI info for active AI of the given side.
Definition: manager.cpp:705
child_itors child_range(config_key_type key)
Definition: config.cpp:344
config cfg_
Definition: manager.hpp:87
void add_turn_started_observer(events::observer *event_observer)
Adds an observer of &#39;ai_turn_started&#39; event.
Definition: manager.cpp:399
holder(side_number side, const config &cfg)
Definition: manager.cpp:76
events::generic_event gamestate_changed_
Definition: manager.hpp:435
Class that manages AIs for all sides and manages AI redeployment.
Definition: manager.hpp:113
AI Support engine - creating specific ai components from config.
std::unique_ptr< readonly_context > readonly_context_
Definition: manager.hpp:83
#define DBG_AI_MOD
Definition: manager.cpp:71
Contains the exception interfaces used to signal completion of a scenario, campaign or turn...
const std::string internal_evaluate_command(side_number side, const std::string &str)
Evaluates an internal manager command.
Definition: manager.cpp:504
Definitions for the interface to Wesnoth Markup Language (WML).
void add_tod_changed_observer(events::observer *event_observer)
Adds an observer of &#39;ai_tod_changed&#39; event.
Definition: manager.cpp:381
config to_config() const
Definition: manager.cpp:223
composite_ai_ptr ai_
Definition: manager.hpp:81
const std::string get_ai_overview()
Definition: manager.cpp:257
void init(side_number side)
Definition: manager.cpp:82
void append_active_ai_for_side(ai::side_number side, const config &cfg)
Appends AI parameters to active AI of the given side.
Definition: manager.cpp:670
#define LOG_AI_MOD
Definition: manager.cpp:72
formula_ai & ai_
std::unique_ptr< side_context > side_context_
Definition: manager.hpp:82
void micro_ai(const config &cfg)
Definition: manager.cpp:149
std::stack< holder > & get_or_create_ai_stack_for_side(side_number side)
Gets the AI stack for the specified side, create it if it doesn&#39;t exist.
Definition: manager.cpp:748
virtual const unit_advancements_aspect & get_advancements() const override
Definition: contexts.hpp:546
void merge_with(const config &c)
Merge config &#39;c&#39; into this config, overwriting this config&#39;s values.
Definition: config.cpp:1224
bool add_ai_for_side_from_file(side_number side, const std::string &file, bool replace=true)
Adds active AI for specified side from file.
Definition: manager.cpp:615
void clear_ais()
Clears all the AIs.
Definition: manager.cpp:660
void raise_recruit_list_changed()
Notifies all observers of &#39;ai_recruit_list_changed&#39; event.
Definition: manager.cpp:453
const std::string get_ai_structure()
Definition: manager.cpp:299
A small explanation about what&#39;s going on here: Each action has access to two game_info objects First...
Definition: actions.cpp:61
void remove_gamestate_observer(events::observer *event_observer)
Removes an observer of game events except ai_user_interact event and ai_sync_network event...
Definition: manager.cpp:375
static bool parse_side_config(side_number side, const config &original_cfg, config &cfg)
static component * get_component(component *root, const std::string &path)
Definition: component.cpp:258
std::deque< command_history_item > history_
Definition: manager.hpp:426
virtual void new_turn()
On new turn.
Definition: ai.cpp:175
component * get_component(component *root, const std::string &path)
Definition: manager.cpp:312
void remove_turn_started_observer(events::observer *event_observer)
Deletes an observer of &#39;ai_turn_started&#39; event.
Definition: manager.cpp:414
std::string get_active_ai_overview_for_side(side_number side)
Gets AI Overview for active AI of the given side.
Definition: manager.cpp:675
events::generic_event user_interact_
Definition: manager.hpp:432
A component of the AI framework.
Composite AI with turn sequence which is a vector of stages.
config to_config(side_number side)
Gets AI config for active AI of the given side.
Definition: manager.cpp:700
std::unique_ptr< default_ai_context > default_ai_context_
Definition: manager.hpp:85
#define ERR_AI_MOD
Definition: manager.cpp:74
std::string path
Definition: game_config.cpp:39
static lg::log_domain log_ai_manager("ai/manager")
Managing the AIs lifecycle - headers TODO: Refactor history handling and internal commands...
void play_turn(side_number side)
Plays a turn for the specified side using its active AI.
Definition: manager.cpp:724
void modify_active_ai_for_side(ai::side_number side, const config &cfg)
Modifies AI parameters for active AI of the given side.
Definition: manager.cpp:665
void init()
Initializes the GUI subsystems.
Definition: registry.cpp:493
game_events::manager * game_events
Definition: resources.cpp:25
void modify_ai(const config &cfg)
Definition: manager.cpp:162
void remove_all_ais_for_side(side_number side)
Removes all AIs from side.
Definition: manager.cpp:650
static const std::string AI_TYPE_DEFAULT
Definition: manager.hpp:129
virtual ~holder()
Definition: manager.cpp:130
static const std::string AI_TYPE_IDLE_AI
Definition: manager.hpp:125
static bool delete_component(component *root, const std::string &path)
Definition: component.cpp:210
void remove_ai_for_side(side_number side)
Removes top-level AI from side.
Definition: manager.cpp:642
virtual bool attach_handler(observer *obs)
const std::string evaluate_command(side_number side, const std::string &str)
Evaluates a string command using command AI.
Definition: manager.cpp:465
events::generic_event sync_network_
Definition: manager.hpp:433
static bool add_component(component *root, const std::string &path, const config &cfg)
Definition: component.cpp:181
void raise_user_interact()
Notifies all observers of &#39;ai_user_interact&#39; event.
Definition: manager.cpp:419
static const std::string AI_TYPE_COMPOSITE_AI
Definition: manager.hpp:123
static std::string print_component_tree(component *root, const std::string &path)
Definition: component.cpp:240
#define DBG_AI_MANAGER
Definition: manager.cpp:66
Game information for the AI.
std::string get_active_ai_identifier_for_side(side_number side)
Gets AI algorithm identifier for active AI of the given side.
Definition: manager.cpp:685
static map_location::DIRECTION s
void append_ai(const config &cfg)
Definition: manager.cpp:191
std::set< map_location > recent_attacks
Definition: game_info.hpp:115
Default AI contexts.
events::generic_event map_changed_
Definition: manager.hpp:430
Define the game&#39;s event mechanism.
const std::string get_ai_identifier() const
Definition: manager.cpp:307
void add_recruit_list_changed_observer(events::observer *event_observer)
Adds an observer of &#39;ai_recruit_list_changed&#39; event.
Definition: manager.cpp:394
void remove_tod_changed_observer(events::observer *event_observer)
Deletes an observer of &#39;ai_tod_changed&#39; event.
Definition: manager.cpp:385
events::generic_event turn_started_
Definition: manager.hpp:436
long history_item_counter_
Definition: manager.hpp:427
bool simulation_
Definition: resources.cpp:36
const bool & debug
bool add_ai_for_side_from_config(side_number side, const config &cfg, bool replace=true)
Adds active AI for specified side from cfg.
Definition: manager.cpp:625
Helper functions for the object which operates in the context of AI for specific side this is part of...
std::string get_active_ai_structure_for_side(side_number side)
Gets AI Structure for active AI of the given side.
Definition: manager.cpp:680
events::generic_event tod_changed_
Definition: manager.hpp:434
pump_result_t fire(const std::string &event, const entity_location &loc1=entity_location::null_entity, const entity_location &loc2=entity_location::null_entity, const config &data=config())
Function to fire an event.
Definition: pump.cpp:481
game_info ai_info_
Definition: manager.hpp:428
const ai::unit_advancements_aspect & get_advancement_aspect_for_side(side_number side)
Definition: manager.cpp:715
static manager * singleton_
Definition: manager.hpp:442
const std::string describe_ai()
Definition: manager.cpp:246
static lg::log_domain log_ai_mod("ai/mod")
void remove_observer(events::observer *event_observer)
Removes an observer of game events.
Definition: manager.cpp:362
static const std::string AI_TYPE_FORMULA_AI
Definition: manager.hpp:126
void play_turn()
Play the turn.
Definition: ai.cpp:141
static const config & get_default_ai_parameters()
get default AI parameters
ai_composite & get_ai_ref()
Definition: manager.cpp:139
static const std::string AI_TYPE_SAMPLE_AI
Definition: manager.hpp:124
game_info & get_ai_info()
Gets global AI-game info.
Definition: manager.cpp:710
side_number side_
Definition: manager.hpp:86
Managing the AIs configuration - headers.
void add_gamestate_observer(events::observer *event_observer)
Adds observer of game events except ai_user_interact event and ai_sync_network event.
Definition: manager.cpp:369
std::unique_ptr< readwrite_context > readwrite_context_
Definition: manager.hpp:84
int num_interact_
Definition: manager.hpp:438
Standard logging facilities (interface).
virtual bool detach_handler(observer *obs)
static bool get_side_config_from_file(const std::string &file, config &cfg)
get side config from file
void raise_sync_network()
Notifies all observers of &#39;ai_sync_network&#39; event.
Definition: manager.cpp:437
AI_map_of_stacks ai_map_
Definition: manager.hpp:440
ai_composite & get_active_ai_for_side(side_number side)
Gets active AI for specified side.
Definition: manager.cpp:777
int side_number
Definition: game_info.hpp:40
game_events::wml_event_pump & pump()
Definition: manager.cpp:230
void raise_tod_changed()
Notifies all observers of &#39;ai_tod_changed&#39; event.
Definition: manager.cpp:445
A config object defines a single node in a WML file, with access to child nodes.
Definition: config.hpp:61
ai::holder & get_active_ai_holder_for_side_dbg(side_number side)
Gets the active AI holder for debug purposes.
Definition: manager.cpp:690
LUA AI Support engine - creating specific ai components from config.
static map_location::DIRECTION n
static const std::size_t MAX_HISTORY_SIZE
Definition: manager.hpp:121
int last_interact_
Definition: manager.hpp:437
void remove_recruit_list_changed_observer(events::observer *event_observer)
Deletes an observer of &#39;ai_recruit_list_changed&#39; event.
Definition: manager.cpp:404
std::string::const_iterator iterator
Definition: tokenizer.hpp:25
events::generic_event recruit_list_changed_
Definition: manager.hpp:431
void raise_turn_started()
Notifies all observers of &#39;ai_turn_started&#39; event.
Definition: manager.cpp:449
All known AI parts.
Base class that holds the AI and current AI parameters.
Definition: manager.hpp:53
holder & get_active_ai_holder_for_side(side_number side)
Gets active holder for specified side.
Definition: manager.cpp:760
void add_map_changed_observer(events::observer *event_observer)
Adds an observer of &#39;ai_map_changed&#39; event.
Definition: manager.cpp:389
std::vector< std::string > parenthetical_split(const std::string &val, const char separator, const std::string &left, const std::string &right, const int flags)
Splits a string based either on a separator, except then the text appears within specified parenthesi...
void remove_map_changed_observer(events::observer *event_observer)
Deletes an observer of &#39;ai_map_changed&#39; event.
Definition: manager.cpp:409