The Battle for Wesnoth  1.19.1+dev
movetype.cpp
Go to the documentation of this file.
1 /*
2  Copyright (C) 2014 - 2024
3  by David White <dave@whitevine.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  * @file
18  * Handle movement types.
19  */
20 
21 #include "movetype.hpp"
22 
23 #include "game_config_manager.hpp"
24 #include "log.hpp"
25 #include "terrain/translation.hpp"
26 
27 static lg::log_domain log_config("config");
28 #define ERR_CF LOG_STREAM(err, log_config)
29 #define WRN_CF LOG_STREAM(warn, log_config)
30 
31 
32 /* *** parameters *** */
33 
34 
35 namespace { // Some functions for use with parameters::eval.
36 
37  /** Converts config defense values to a "max" value. */
38  int config_to_max(int value)
39  {
40  return value < 0 ? -value : value;
41  }
42 
43  /** Converts config defense values to a "min" value. */
44  int config_to_min(int value)
45  {
46  return value < 0 ? -value : 0;
47  }
48 }
49 
50 
51 /** The parameters used when calculating a terrain-based value. */
53 {
54  /** The smallest allowable value. */
55  int min_value;
56  /** The largest allowable value. */
57  int max_value;
58  /** The default value (if no data is available). */
60 
61  /** Converter for values taken from a config. May be nullptr. */
62  int (*eval)(int);
63 
64  /** Whether to look at underlying movement or defense terrains. */
65  bool use_move;
66  /** Whether we are looking for highest or lowest (unless inverted by the underlying terrain). */
68 
69  parameters(int min, int max, int (*eval_fun)(int)=nullptr, bool move=true, bool high=false) :
70  min_value(min), max_value(max), default_value(high ? min : max),
71  eval(eval_fun), use_move(move), high_is_good(high)
72  {}
73 };
74 
75 
76 /** Limits for movement, vision and jamming */
79 
81  movetype::terrain_defense::params_min_(0, 100, config_to_min, false, true);
83  movetype::terrain_defense::params_max_(0, 100, config_to_max, false, false);
84 
85 
86 /* *** data *** */
87 
88 
90 {
91 public:
92  /**
93  * Constructor.
94  * @a params must be long-lived (typically a static variable).
95  */
96  explicit data(const parameters & params) :
97  cfg_(), cache_(), params_(params)
98  {}
99  /**
100  * Constructor.
101  * @a params must be long-lived (typically a static variable).
102  */
103  data(const config & cfg, const parameters & params) :
104  cfg_(cfg), cache_(), params_(params)
105  {}
106 
107  // The copy constructor does not bother copying the cache since
108  // typically the cache will be cleared shortly after the copy.
109  data(const data & that) :
110  cfg_(that.cfg_), cache_(), params_(that.params_)
111  {}
112 
113  /** Clears the cached data (presumably our fallback has changed). */
114  void clear_cache() const;
115  /** Tests if merging @a new_values would result in changes. */
116  bool config_has_changes(const config & new_values, bool overwrite) const;
117  /** Tests for no data in this object. */
118  bool empty() const { return cfg_.empty(); }
119  /** Merges the given config over the existing costs. */
120  void merge(const config & new_values, bool overwrite);
121  /** Read-only access to our parameters. */
122  const parameters & params() const { return params_; }
123  /** Returns the value associated with the given terrain. */
124  int value(const t_translation::terrain_code & terrain,
125  const terrain_info * fallback) const
126  { return value(terrain, fallback, 0); }
127  /** If there is data, writes it to the config. */
128  void write(config & out_cfg, const std::string & child_name) const;
129  /** If there is (merged) data, writes it to the config. */
130  void write(config & out_cfg, const std::string & child_name,
131  const terrain_info * fallback) const;
132 
133 private:
134  /** Calculates the value associated with the given terrain. */
135  int calc_value(const t_translation::terrain_code & terrain,
136  const terrain_info * fallback, unsigned recurse_count) const;
137  /** Returns the value associated with the given terrain (possibly cached). */
138  int value(const t_translation::terrain_code & terrain,
139  const terrain_info * fallback, unsigned recurse_count) const;
140 
141 private:
142  typedef std::map<t_translation::terrain_code, int> cache_t;
143 
144  /** Config describing the terrain values. */
146  /** Cache of values based on the config. */
147  mutable cache_t cache_;
148  /** Various parameters used when calculating values. */
150 };
151 
152 
153 /**
154  * Clears the cached data (presumably our fallback has changed).
155  */
157 {
158  cache_.clear();
159 }
160 
161 
162 /**
163  * Tests if merging @a new_values would result in changes.
164  * This allows the shared data to actually work, as otherwise each unit created
165  * via WML (including unstored units) would "overwrite" its movement data with
166  * a usually identical copy and thus break the sharing.
167  */
169  bool overwrite) const
170 {
171  if ( overwrite ) {
172  for (const config::attribute & a : new_values.attribute_range())
173  if ( a.second != cfg_[a.first] )
174  return true;
175  }
176  else {
177  for (const config::attribute & a : new_values.attribute_range())
178  if ( a.second.to_int() != 0 )
179  return true;
180  }
181 
182  // If we make it here, new_values has no changes for us.
183  return false;
184 }
185 
186 
187 /**
188  * Merges the given config over the existing costs.
189  *
190  * After calling this function, the caller must call clear_cache on any
191  * terrain_info that uses this one as a fallback.
192  *
193  * @param[in] new_values The new values.
194  * @param[in] overwrite If true, the new values overwrite the old.
195  * If false, the new values are added to the old.
196  */
197 void movetype::terrain_info::data::merge(const config & new_values, bool overwrite)
198 {
199  if ( overwrite )
200  // We do not support child tags here, so do not copy any that might
201  // be in the input. (If in the future we need to support child tags,
202  // change "merge_attributes" to "merge_with".)
203  cfg_.merge_attributes(new_values);
204  else {
205  for (const config::attribute & a : new_values.attribute_range()) {
206  config::attribute_value & dest = cfg_[a.first];
207  int old = dest.to_int(params_.max_value);
208 
209  // The new value is the absolute value of the old plus the
210  // provided value, capped between minimum and maximum, then
211  // given the sign of the old value.
212  // (Think defenses for why we might have negative values.)
213  int value = std::abs(old) + a.second.to_int(0);
214  value = std::max(params_.min_value, std::min(value, params_.max_value));
215  if ( old < 0 )
216  value = -value;
217 
218  dest = value;
219  }
220  }
221 
222  // The new data has invalidated the cache.
223  clear_cache();
224 }
225 
226 
227 /**
228  * If there is data, writes it to a config.
229  * @param[out] out_cfg The config that will receive the data.
230  * @param[in] child_name If not empty, create and write to a child config with this tag.
231  * This child will *not* be created if there is no data to write.
232  */
234  config & out_cfg, const std::string & child_name) const
235 {
236  if ( cfg_.empty() )
237  return;
238 
239  if ( child_name.empty() )
240  out_cfg.merge_with(cfg_);
241  else
242  out_cfg.add_child(child_name, cfg_);
243 }
244 
245 
246 /**
247  * Writes merged data to a config.
248  * @param[out] out_cfg The config that will receive the data.
249  * @param[in] child_name If not empty, create and write to a child config with this tag.
250  * This *will* be created even if there is no data to write.
251  * @param[in] fallback If not nullptr, its data will be merged with ours for the write.
252  */
254  config & out_cfg, const std::string & child_name, const terrain_info * fallback) const
255 {
256  // Get a place to write to.
257  config & merged = child_name.empty() ? out_cfg : out_cfg.add_child(child_name);
258 
259  if ( fallback )
260  fallback->write(merged, "", true);
261  merged.merge_with(cfg_);
262 }
263 
264 
265 /**
266  * Calculates the value associated with the given terrain.
267  * This is separate from value() to separate the calculating of the
268  * value from the caching of it.
269  * @param[in] terrain The terrain whose value is requested.
270  * @param[in] fallback Consulted if we are missing data.
271  * @param[in] recurse_count Detects (probable) infinite recursion.
272  */
274  const t_translation::terrain_code & terrain,
275  const terrain_info * fallback,
276  unsigned recurse_count) const
277 {
278  // Infinite recursion detection:
279  if ( recurse_count > 100 ) {
280  ERR_CF << "infinite terrain_info recursion on "
281  << (params_.use_move ? "movement" : "defense") << ": "
283  << " depth " << recurse_count;
284  return params_.default_value;
285  }
286 
287  std::shared_ptr<terrain_type_data> tdata;
289  tdata = game_config_manager::get()->terrain_types(); //This permits to get terrain info in unit help pages from the help in title screen, even if there is no residual gamemap object
290  }
291  assert(tdata);
292 
293  // Get a list of underlying terrains.
294  const t_translation::ter_list & underlying = params_.use_move ?
295  tdata->underlying_mvt_terrain(terrain) :
296  tdata->underlying_def_terrain(terrain);
297 
298  if (terrain_type::is_indivisible(terrain, underlying))
299  {
300  // This is not an alias; get the value directly.
301  int result = params_.default_value;
302 
303  const std::string & id = tdata->get_terrain_info(terrain).id();
304  if (const config::attribute_value *val = cfg_.get(id)) {
305  // Read the value from our config.
306  result = val->to_int(params_.default_value);
307  if ( params_.eval != nullptr )
308  result = params_.eval(result);
309  }
310  else if ( fallback != nullptr ) {
311  // Get the value from our fallback.
312  result = fallback->value(terrain);
313  }
314 
315  // Validate the value.
316  if ( result < params_.min_value ) {
317  WRN_CF << "Terrain '" << terrain << "' has evaluated to " << result
318  << " (" << (params_.use_move ? "cost" : "defense")
319  << "), which is less than " << params_.min_value
320  << "; resetting to " << params_.min_value << ".";
321  result = params_.min_value;
322  }
323  if ( result > params_.max_value ) {
324  WRN_CF << "Terrain '" << terrain << "' has evaluated to " << result
325  << " (" << (params_.use_move ? "cost" : "defense")
326  << "), which is more than " << params_.max_value
327  << "; resetting to " << params_.max_value << ".";
328  result = params_.max_value;
329  }
330 
331  return result;
332  }
333  else
334  {
335  // This is an alias; select the best of all underlying terrains.
336  bool prefer_high = params_.high_is_good;
337  int result = params_.default_value;
338  if ( underlying.front() == t_translation::MINUS )
339  // Use the other value as the initial value.
340  result = result == params_.max_value ? params_.min_value :
341  params_.max_value;
342 
343  // Loop through all underlying terrains.
344  t_translation::ter_list::const_iterator i;
345  for ( i = underlying.begin(); i != underlying.end(); ++i )
346  {
347  if ( *i == t_translation::PLUS ) {
348  // Prefer what is good.
349  prefer_high = params_.high_is_good;
350  }
351  else if ( *i == t_translation::MINUS ) {
352  // Prefer what is bad.
353  prefer_high = !params_.high_is_good;
354  }
355  else {
356  // Test the underlying terrain's value against the best so far.
357  const int num = value(*i, fallback, recurse_count + 1);
358 
359  if ( ( prefer_high && num > result) ||
360  (!prefer_high && num < result) )
361  result = num;
362  }
363  }
364 
365  return result;
366  }
367 }
368 
369 
370 /**
371  * Returns the value associated with the given terrain (possibly cached).
372  * @param[in] terrain The terrain whose value is requested.
373  * @param[in] fallback Consulted if we are missing data.
374  * @param[in] recurse_count Detects (probable) infinite recursion.
375  */
377  const t_translation::terrain_code & terrain,
378  const terrain_info * fallback,
379  unsigned recurse_count) const
380 {
381  // Check the cache.
382  std::pair<cache_t::iterator, bool> cache_it =
383  cache_.emplace(terrain, -127); // Bogus value that should never be seen.
384  if ( cache_it.second )
385  // The cache did not have an entry for this terrain, so calculate the value.
386  cache_it.first->second = calc_value(terrain, fallback, recurse_count);
387 
388  return cache_it.first->second;
389 }
390 
391 
392 /* *** terrain_info *** */
393 
394 
395 /**
396  * Constructor.
397  * @param[in] params The parameters to use when calculating values.
398  * This is stored as a reference, so it must be long-lived (typically a static variable).
399  * @param[in] fallback Used as a backup in case we are asked for data we do not have (think vision costs falling back to movement costs).
400  */
402  const terrain_info * fallback) :
403  unique_data_(new data(params)),
404  fallback_(fallback)
405 {
406 }
407 
408 
409 /**
410  * Constructor.
411  * @param[in] cfg An initial data set.
412  * @param[in] params The parameters to use when calculating values.
413  * This is stored as a reference, so it must be long-lived (typically a static variable).
414  * @param[in] fallback Used as a backup in case we are asked for data we do not have (think vision costs falling back to movement costs).
415  */
417  const terrain_info * fallback) :
418  unique_data_(new data(cfg, params)),
419  fallback_(fallback)
420 {
421 }
422 
423 /**
424  * Reverse of terrain_costs::write. Never returns nullptr.
425  * @param[in] cfg An initial data set
426  */
427 std::unique_ptr<movetype::terrain_costs> movetype::read_terrain_costs(const config & cfg)
428 {
429  return std::make_unique<terrain_info> (cfg, movetype::mvj_params_, nullptr);
430 }
431 
432 /**
433  * Copy constructor for callers that handle the fallback and cascade. This is
434  * intended for terrain_defense or movetype's copy constructors, where a
435  * similar set of terrain_infos will be created, complete with the same
436  * relationships between parts of the set.
437  *
438  * @param[in] that The terrain_info to copy.
439  * @param[in] fallback Used as a backup in case we are asked for data we do not have (think vision costs falling back to movement costs).
440  */
442  const terrain_info * fallback) :
443  fallback_(fallback)
444 {
445  assert(fallback ? !! that.fallback_ : ! that.fallback_);
446  copy_data(that);
447 }
448 
450  const terrain_info * fallback) :
451  fallback_(fallback)
452 {
453  assert(fallback ? !! that.fallback_ : ! that.fallback_);
454  swap_data(that);
455 }
456 
457 /**
458  * Destructor
459  *
460  * While this is simply the default destructor, it needs
461  * to be defined in this file so that it knows about ~data(), which
462  * is called from the smart pointers' destructor.
463  */
465 
466 /**
467  * This is only expected to be called either when
468  * 1) both this and @a that have no siblings, as happens when terrain_defense is copied, or
469  * 2) all of the siblings are being copied, as happens when movetype is copied.
470  */
472 {
473  that.make_data_shareable();
474  this->unique_data_.reset();
475  this->shared_data_ = that.shared_data_;
476 }
477 
478 /**
479  * Swap function for the terrain_info class
480  *
481  * This is only expected to be called either when
482  * 1) both this and @a that have no siblings, as happens when swapping two terrain_defenses, or
483  * 2) all of the siblings are being swapped, as happens when two movetypes are swapped.
484  */
486 {
487  // It doesn't matter whether they're both unique, both shared, or
488  // one unique with the other shared.
489  std::swap(this->unique_data_, that.unique_data_);
490  std::swap(this->shared_data_, that.shared_data_);
491 }
492 /**
493  * Swap function for the terrain_defense class
494  *
495  * This relies on all of the terrain_infos having no fallback and no cascade,
496  * an assumption which is provided by terrain_defense's constructors.
497  */
499 {
500  a.min_.swap_data(b.min_);
501  a.max_.swap_data(b.max_);
502 }
503 
504 /**
505  * Swap function for the movetype class, including its terrain_info members
506  *
507  * This relies on the two sets of the terrain_infos having their movement,
508  * vision and jamming cascaded in the same way. This assumption is provided by
509  * movetype's constructors.
510  */
512 {
513  a.movement_.swap_data(b.movement_);
514  a.vision_.swap_data(b.vision_);
515  a.jamming_.swap_data(b.jamming_);
516  swap(a.defense_, b.defense_);
517  std::swap(a.resist_, b.resist_);
518  std::swap(a.flying_, b.flying_);
519  std::swap(a.special_notes_, b.special_notes_);
520 }
521 
523 {
524  movetype m(that);
525  swap(*this, m);
526  return *this;
527 }
528 
530 {
531  swap(*this, that);
532  return *this;
533 }
534 
535 /**
536  * Returns whether or not our data is empty.
537  */
539 {
540  return get_data().empty();
541 }
542 
543 
544 /**
545  * Merges the given config over the existing values.
546  * @param[in] new_values The new values.
547  * @param[in] overwrite If true, the new values overwrite the old.
548  * If false, the new values are added to the old.
549  * @param[in] dependants Other instances that use this as a fallback.
550  */
551 void movetype::terrain_info::merge(const config & new_values, bool overwrite,
552  const std::vector<movetype::terrain_info * > & dependants)
553 {
554  if ( !get_data().config_has_changes(new_values, overwrite) )
555  // Nothing will change, so skip the copy-on-write.
556  return;
557 
558  // Copy-on-write.
559  //
560  // We also need to make our cascade writeable, because changes to this
561  // instance will change data that they receive when using this as their
562  // fallback. However, it's no problem for a writable instance to have a
563  // shareable instance as its fallback.
564  make_data_writable();
565  for (auto & dependant : dependants) {
566  // This will automatically clear the dependant's cache
567  dependant->make_data_writable();
568  }
569 
570  unique_data_->merge(new_values, overwrite);
571 }
572 
573 
574 /**
575  * Returns the value associated with the given terrain.
576  */
578 {
579  return get_data().value(terrain, fallback_);
580 }
581 
582 /**
583  * Writes our data to a config.
584  * @param[out] cfg The config that will receive the data.
585  * @param[in] child_name If not empty, create and write to a child config with this tag.
586  * @param[in] merged If true, our data will be merged with our fallback's, and it is possible an empty child will be created.
587  * If false, data will not be merged, and an empty child will not be created.
588  */
589 void movetype::terrain_info::write(config & cfg, const std::string & child_name,
590  bool merged) const
591 {
592  if ( !merged )
593  get_data().write(cfg, child_name);
594  else
595  get_data().write(cfg, child_name, fallback_);
596 }
597 
598 
599 /**
600  * Does a sufficiently deep copy so that the returned object's lifespan
601  * is independent of other objects' lifespan. Never returns nullptr.
602  *
603  * This implements terrain_costs's virtual method for getting an instance that
604  * doesn't depend on the lifespan of a terrain_defense or movetype object.
605  * This will do a deep copy of the data (with fallback_ already merged) if
606  * needed.
607  */
608 std::unique_ptr<movetype::terrain_costs> movetype::terrain_info::make_standalone() const
609 {
610  std::unique_ptr<terrain_costs> t;
611  if(!fallback_) {
612  // Call the copy constructor, which will make_data_shareable().
613  t = std::make_unique<terrain_info>(*this, nullptr);
614  }
615  else if(get_data().empty()) {
616  // Pure fallback.
617  t = fallback_->make_standalone();
618  }
619  else {
620  // Need to merge data.
621  config merged;
622  write(merged, "", true);
623  t = std::make_unique<terrain_info>(merged, get_data().params(), nullptr);
624  }
625  return t;
626 }
627 
629 {
630  assert(unique_data_ || shared_data_);
631  assert(! (unique_data_ && shared_data_));
632  if(unique_data_)
633  return *unique_data_;
634  return *shared_data_;
635 }
636 
637 /**
638  * Copy the immutable data back to unique_data_, no-op if the data
639  * is already in unique_data_.
640  *
641  * Ensures our data is not shared, and therefore that changes only
642  * affect this instance of terrain_info (and any instances using it
643  * as a fallback).
644  *
645  * This does not need to affect the fallback - it's no problem if a
646  * writable instance has a fallback to a shareable instance, although
647  * a shareable instance must not fallback to a writable instance.
648  */
650 {
651  if(!unique_data_)
652  {
653  // Const hack because this is not really changing the data.
654  auto t = const_cast<terrain_info *>(this);
655  t->unique_data_.reset(new data(*shared_data_));
656  t->shared_data_.reset();
657  }
658 
659  // As we're about to write data, invalidate the cache
660  unique_data_->clear_cache();
661 }
662 
663 /**
664  * Move data to an immutable copy in shared_data_, no-op if the data
665  * is already in shared_data_.
666  *
667  * This is recursive on the fallback chain, because if the data shouldn't be
668  * writable then the data shouldn't be writable via the fallback either.
669  */
671 {
672  if(!unique_data_)
673  return;
674 
675  if(fallback_)
676  fallback_->make_data_shareable();
677 
678  // Const hack because this is not really changing the data.
679  auto t = const_cast<terrain_info *>(this);
680  t->shared_data_ = std::move(t->unique_data_);
681 }
682 
683 /* *** terrain_defense *** */
684 
686  min_(that.min_, nullptr),
687  max_(that.max_, nullptr)
688 {
689 }
690 
692  min_(std::move(that.min_), nullptr),
693  max_(std::move(that.max_), nullptr)
694 {
695 }
696 
698 {
699  min_.copy_data(that.min_);
700  max_.copy_data(that.max_);
701  return *this;
702 }
703 
705 {
706  min_.swap_data(that.min_);
707  max_.swap_data(that.max_);
708  return *this;
709 }
710 /**
711  * Merges the given config over the existing costs.
712  * (Not overwriting implies adding.)
713  */
714 void movetype::terrain_defense::merge(const config & new_data, bool overwrite)
715 {
716  min_.merge(new_data, overwrite, {});
717  max_.merge(new_data, overwrite, {});
718 }
719 
720 /* *** resistances *** */
721 
722 
723 /**
724  * Returns a map from damage types to resistances.
725  */
727 {
728  utils::string_map_res result;
729 
730  for (const config::attribute & attrb : cfg_.attribute_range()) {
731  result[attrb.first] = attrb.second;
732  }
733 
734  return result;
735 }
736 
737 /**
738  * Returns the resistance against the indicated damage type.
739  */
740 int movetype::resistances::resistance_against(const std::string & damage_type) const
741 {
742  return cfg_[damage_type].to_int(100);
743 }
744 
745 
746 /**
747  * Merges the given config over the existing costs.
748  * If @a overwrite is false, the new values will be added to the old.
749  */
750 void movetype::resistances::merge(const config & new_data, bool overwrite)
751 {
752  if ( overwrite )
753  // We do not support child tags here, so do not copy any that might
754  // be in the input. (If in the future we need to support child tags,
755  // change "merge_attributes" to "merge_with".)
756  cfg_.merge_attributes(new_data);
757  else
758  for (const config::attribute & a : new_data.attribute_range()) {
759  config::attribute_value & dest = cfg_[a.first];
760  dest = std::max(0, dest.to_int(100) + a.second.to_int(0));
761  }
762 }
763 
764 
765 /**
766  * Writes our data to a config, as a child if @a child_name is specified.
767  * (No child is created if there is no data.)
768  */
769 void movetype::resistances::write(config & out_cfg, const std::string & child_name) const
770 {
771  if ( cfg_.empty() )
772  return;
773 
774  if ( child_name.empty() )
775  out_cfg.merge_with(cfg_);
776  else
777  out_cfg.add_child(child_name, cfg_);
778 }
779 
780 
781 /* *** movetype *** */
782 
783 
784 /**
785  * Default constructor
786  */
788  movement_(mvj_params_, nullptr),
791  defense_(),
792  resist_(),
793  flying_(false),
795 {
796 }
797 
798 
799 /**
800  * Constructor from a config
801  */
803  movement_(cfg.child_or_empty("movement_costs"), mvj_params_, nullptr),
804  vision_(cfg.child_or_empty("vision_costs"), mvj_params_, &movement_),
805  jamming_(cfg.child_or_empty("jamming_costs"), mvj_params_, &vision_),
806  defense_(cfg.child_or_empty("defense")),
807  resist_(cfg.child_or_empty("resistance")),
808  flying_(cfg["flies"].to_bool(false))
809 {
810  // 1.15 will support both "flying" and "flies", with "flies" being deprecated
811  flying_ = cfg["flying"].to_bool(flying_);
812 
813  for(const config& sn : cfg.child_range("special_note")) {
814  special_notes_.push_back(sn["note"]);
815  }
816 }
817 
818 
819 /**
820  * Copy constructor
821  */
823  movement_(that.movement_, nullptr),
824  vision_(that.vision_, &movement_),
825  jamming_(that.jamming_, &vision_),
826  defense_(that.defense_),
827  resist_(that.resist_),
828  flying_(that.flying_),
829  special_notes_(that.special_notes_)
830 {
831 }
832 
833 /**
834  * Move constructor.
835  */
837  movement_(std::move(that.movement_), nullptr),
838  vision_(std::move(that.vision_), &movement_),
839  jamming_(std::move(that.jamming_), &vision_),
840  defense_(std::move(that.defense_)),
841  resist_(std::move(that.resist_)),
842  flying_(std::move(that.flying_)),
843  special_notes_(std::move(that.special_notes_))
844 {
845 }
846 
847 /**
848  * Checks if we have a defense cap (nontrivial min value) for any of the given terrain types.
849  */
850 bool movetype::has_terrain_defense_caps(const std::set<t_translation::terrain_code> & ts) const {
851  for (const t_translation::terrain_code & t : ts) {
852  if (defense_.capped(t))
853  return true;
854  }
855  return false;
856 }
857 
858 void movetype::merge(const config & new_cfg, bool overwrite)
859 {
860  for (const auto & applies_to : movetype::effects) {
861  for (const config & child : new_cfg.child_range(applies_to)) {
862  merge(child, applies_to, overwrite);
863  }
864  }
865 
866  // "flies" is used when WML defines a movetype.
867  // "flying" is used when WML defines a unit.
868  // It's easier to support both than to track which case we are in.
869  // Note: in 1.15 "flies" is deprecated, with "flying" preferred in movetype too.
870  flying_ = new_cfg["flies"].to_bool(flying_);
871  flying_ = new_cfg["flying"].to_bool(flying_);
872 }
873 
874 void movetype::merge(const config & new_cfg, const std::string & applies_to, bool overwrite)
875 {
876  if(applies_to == "movement_costs") {
877  movement_.merge(new_cfg, overwrite, {&vision_, &jamming_});
878  }
879  else if(applies_to == "vision_costs") {
880  vision_.merge(new_cfg, overwrite, {&jamming_});
881  }
882  else if(applies_to == "jamming_costs") {
883  jamming_.merge(new_cfg, overwrite, {});
884  }
885  else if(applies_to == "defense") {
886  defense_.merge(new_cfg, overwrite);
887  }
888  else if(applies_to == "resistance") {
889  resist_.merge(new_cfg, overwrite);
890  }
891  else {
892  ERR_CF << "movetype::merge with unknown applies_to: " << applies_to;
893  }
894 }
895 
896 /**
897  * The set of strings defining effects which apply to movetypes.
898  */
899 const std::set<std::string> movetype::effects {"movement_costs",
900  "vision_costs", "jamming_costs", "defense", "resistance"};
901 
902 void movetype::write(config& cfg, bool include_notes) const
903 {
904  movement_.write(cfg, "movement_costs", false);
905  vision_.write(cfg, "vision_costs", false);
906  jamming_.write(cfg, "jamming_costs", false);
907  defense_.write(cfg, "defense");
908  resist_.write(cfg, "resistance");
909 
910  if(flying_)
911  cfg["flying"] = true;
912 
913  if(include_notes) {
914  for(const auto& note : special_notes_) {
915  cfg.add_child("special_note", config{"note", note});
916  }
917  }
918 }
double t
Definition: astarsearch.cpp:63
Variant for storing WML attributes.
A config object defines a single node in a WML file, with access to child nodes.
Definition: config.hpp:159
const_attr_itors attribute_range() const
Definition: config.cpp:763
void merge_with(const config &c)
Merge config 'c' into this config, overwriting this config's values.
Definition: config.cpp:1126
child_itors child_range(config_key_type key)
Definition: config.cpp:273
attribute_map::value_type attribute
Definition: config.hpp:299
bool empty() const
Definition: config.cpp:852
config & add_child(config_key_type key)
Definition: config.cpp:441
static game_config_manager * get()
const std::shared_ptr< terrain_type_data > & terrain_types() const
int resistance_against(const std::string &damage_type) const
Returns the vulnerability to the indicated damage type (higher means more damage).
Definition: movetype.cpp:740
void merge(const config &new_data, bool overwrite)
Merges the given config over the existing costs.
Definition: movetype.cpp:750
utils::string_map_res damage_table() const
Returns a map from damage types to resistances.
Definition: movetype.cpp:726
void write(config &out_cfg, const std::string &child_name="") const
Writes our data to a config, as a child if child_name is specified.
Definition: movetype.cpp:769
Stores a set of defense levels.
Definition: movetype.hpp:178
terrain_defense & operator=(const terrain_defense &that)
Definition: movetype.cpp:697
void write(config &cfg, const std::string &child_name="") const
Writes our data to a config, as a child if child_name is specified.
Definition: movetype.hpp:207
bool capped(const t_translation::terrain_code &terrain) const
Returns whether there is a defense cap associated to this terrain.
Definition: movetype.hpp:196
static const terrain_info::parameters params_max_
Definition: movetype.hpp:180
static const terrain_info::parameters params_min_
Definition: movetype.hpp:179
void merge(const config &new_data, bool overwrite)
Merges the given config over the existing costs.
Definition: movetype.cpp:714
bool config_has_changes(const config &new_values, bool overwrite) const
Tests if merging new_values would result in changes.
Definition: movetype.cpp:168
const parameters & params() const
Read-only access to our parameters.
Definition: movetype.cpp:122
void write(config &out_cfg, const std::string &child_name) const
If there is data, writes it to the config.
Definition: movetype.cpp:233
data(const config &cfg, const parameters &params)
Constructor.
Definition: movetype.cpp:103
config cfg_
Config describing the terrain values.
Definition: movetype.cpp:145
std::map< t_translation::terrain_code, int > cache_t
Definition: movetype.cpp:142
bool empty() const
Tests for no data in this object.
Definition: movetype.cpp:118
void merge(const config &new_values, bool overwrite)
Merges the given config over the existing costs.
Definition: movetype.cpp:197
cache_t cache_
Cache of values based on the config.
Definition: movetype.cpp:147
void clear_cache() const
Clears the cached data (presumably our fallback has changed).
Definition: movetype.cpp:156
int calc_value(const t_translation::terrain_code &terrain, const terrain_info *fallback, unsigned recurse_count) const
Calculates the value associated with the given terrain.
Definition: movetype.cpp:273
int value(const t_translation::terrain_code &terrain, const terrain_info *fallback) const
Returns the value associated with the given terrain.
Definition: movetype.cpp:124
data(const parameters &params)
Constructor.
Definition: movetype.cpp:96
data(const data &that)
Definition: movetype.cpp:109
const parameters & params_
Various parameters used when calculating values.
Definition: movetype.cpp:149
Stores a set of data based on terrain, in some cases with raw pointers to other instances of terrain_...
Definition: movetype.hpp:103
void make_data_writable() const
Copy the immutable data back to unique_data_, no-op if the data is already in unique_data_.
Definition: movetype.cpp:649
const data & get_data() const
Returns either *unique_data_ or *shared_data_, choosing the one that currently holds the data.
Definition: movetype.cpp:628
std::unique_ptr< terrain_costs > make_standalone() const override
Does a sufficiently deep copy so that the returned object's lifespan is independent of other objects'...
Definition: movetype.cpp:608
std::shared_ptr< const data > shared_data_
Definition: movetype.hpp:164
void swap_data(movetype::terrain_info &that)
Swap function for the terrain_info class.
Definition: movetype.cpp:485
void copy_data(const movetype::terrain_info &that)
This is only expected to be called either when 1) both this and that have no siblings,...
Definition: movetype.cpp:471
bool empty() const
Returns whether or not our data is empty.
Definition: movetype.cpp:538
terrain_info(const parameters &params, const terrain_info *fallback)
Constructor.
Definition: movetype.cpp:401
void write(config &cfg, const std::string &child_name="", bool merged=true) const override
Writes our data to a config.
Definition: movetype.cpp:589
int value(const t_translation::terrain_code &terrain) const override
Returns the value associated with the given terrain.
Definition: movetype.cpp:577
~terrain_info() override
Destructor.
void make_data_shareable() const
Move data to an immutable copy in shared_data_, no-op if the data is already in shared_data_.
Definition: movetype.cpp:670
const terrain_info *const fallback_
Definition: movetype.hpp:165
void merge(const config &new_values, bool overwrite, const std::vector< movetype::terrain_info * > &dependants)
Merges the given config over the existing values.
Definition: movetype.cpp:551
std::unique_ptr< data > unique_data_
Definition: movetype.hpp:163
The basic "size" of the unit - flying, small land, large land, etc.
Definition: movetype.hpp:44
static const int UNREACHABLE
Magic value that signifies a hex is unreachable.
Definition: movetype.hpp:174
void write(config &cfg, bool include_notes) const
Writes the movement type data to the provided config.
Definition: movetype.cpp:902
movetype()
Default constructor.
Definition: movetype.cpp:787
static const std::set< std::string > effects
The set of applicable effects for movement types.
Definition: movetype.hpp:340
void merge(const config &new_cfg, bool overwrite=true)
Merges the given config over the existing data, the config should have zero or more children named "m...
Definition: movetype.cpp:858
bool has_terrain_defense_caps(const std::set< t_translation::terrain_code > &ts) const
Returns whether or not there are any terrain caps with respect to a set of terrains.
Definition: movetype.cpp:850
resistances resist_
Definition: movetype.hpp:368
terrain_info movement_
Definition: movetype.hpp:364
movetype & operator=(const movetype &that)
Definition: movetype.cpp:522
bool flying_
Definition: movetype.hpp:370
terrain_defense defense_
Definition: movetype.hpp:367
static const terrain_info::parameters mvj_params_
Limits for movement, vision and jamming.
Definition: movetype.hpp:240
static std::unique_ptr< terrain_costs > read_terrain_costs(const config &cfg)
Reverse of terrain_costs::write.
Definition: movetype.cpp:427
friend void swap(movetype &a, movetype &b)
Swap function for the movetype class, including its terrain_info members.
Definition: movetype.cpp:511
std::vector< t_string > special_notes_
Definition: movetype.hpp:371
terrain_info jamming_
Definition: movetype.hpp:366
terrain_info vision_
Definition: movetype.hpp:365
bool is_indivisible() const
Returns true if this terrain has no underlying types other than itself.
Definition: terrain.hpp:110
const formula_callable * fallback_
Definition: function.cpp:756
std::size_t i
Definition: function.cpp:968
Standard logging facilities (interface).
void swap(movetype::terrain_defense &a, movetype::terrain_defense &b)
Swap function for the terrain_defense class.
Definition: movetype.cpp:498
#define ERR_CF
Definition: movetype.cpp:28
#define WRN_CF
Definition: movetype.cpp:29
static lg::log_domain log_config("config")
const terrain_code MINUS
std::vector< terrain_code > ter_list
Definition: translation.hpp:77
const terrain_code PLUS
std::string write_terrain_code(const terrain_code &tcode)
Writes a single terrain code to a string.
std::map< std::string, t_string, res_compare > string_map_res
std::string_view data
Definition: picture.cpp:194
The parameters used when calculating a terrain-based value.
Definition: movetype.cpp:53
int default_value
The default value (if no data is available).
Definition: movetype.cpp:59
bool use_move
Whether to look at underlying movement or defense terrains.
Definition: movetype.cpp:65
parameters(int min, int max, int(*eval_fun)(int)=nullptr, bool move=true, bool high=false)
Definition: movetype.cpp:69
int max_value
The largest allowable value.
Definition: movetype.cpp:57
bool high_is_good
Whether we are looking for highest or lowest (unless inverted by the underlying terrain).
Definition: movetype.cpp:67
int(* eval)(int)
Converter for values taken from a config.
Definition: movetype.cpp:62
int min_value
The smallest allowable value.
Definition: movetype.cpp:55
A terrain string which is converted to a terrain is a string with 1 or 2 layers the layers are separa...
Definition: translation.hpp:49
#define a
#define b