The Battle for Wesnoth  1.17.8+dev
udisplay.cpp
Go to the documentation of this file.
1 /*
2  Copyright (C) 2003 - 2022
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 #include "units/udisplay.hpp"
17 
18 #include "fake_unit_manager.hpp"
19 #include "fake_unit_ptr.hpp"
20 #include "game_board.hpp"
21 #include "game_display.hpp"
22 #include "preferences/game.hpp"
23 #include "log.hpp"
24 #include "mouse_events.hpp"
25 #include "resources.hpp"
26 #include "color.hpp"
27 #include "sound.hpp"
28 #include "terrain/filter.hpp"
29 #include "units/unit.hpp"
31 #include "units/filter.hpp"
32 #include "units/map.hpp"
33 #include "utils/scope_exit.hpp"
34 #include "video.hpp"
35 
36 #define LOG_DP LOG_STREAM(info, display)
37 
38 
39 namespace unit_display
40 {
41 namespace
42 {
43 /**
44  * Returns a string whose first line is @a number, centered over a second line,
45  * which consists of @a text.
46  * If the number is 0, the first line is suppressed.
47  */
48 std::string number_and_text(int number, const std::string& text)
49 {
50  // Simple case.
51  if ( number == 0 )
52  return text;
53 
54  std::ostringstream result;
55 
56  if ( text.empty() )
57  result << number;
58  else
59  result << std::string((text.size()+1)/2, ' ') << number << '\n' << text;
60 
61  return result.str();
62 }
63 
64 
65 /**
66  * Animates a teleportation between hexes.
67  *
68  * @param a The starting hex.
69  * @param b The ending hex.
70  * @param temp_unit The unit to animate (historically, a temporary unit).
71  * @param disp The game display. Assumed neither locked nor faked.
72  */
73 void teleport_unit_between(const map_location& a, const map_location& b, unit& temp_unit, display& disp)
74 {
75  if ( disp.fogged(a) && disp.fogged(b) ) {
76  return;
77  }
78  const display_context& dc = disp.get_disp_context();
79  const team& viewing_team = dc.get_team(disp.viewing_side());
80 
81  const bool a_visible = temp_unit.is_visible_to_team(a, viewing_team, false);
82  const bool b_visible = temp_unit.is_visible_to_team(b, viewing_team, false);
83 
84  temp_unit.set_location(a);
85  if ( a_visible ) { // teleport
86  disp.invalidate(a);
87  temp_unit.set_facing(a.get_relative_dir(b));
88  if ( b_visible )
89  disp.scroll_to_tiles(a, b, game_display::ONSCREEN, true, 0.0, false);
90  else
91  disp.scroll_to_tile(a, game_display::ONSCREEN, true, false);
92  unit_animator animator;
93  animator.add_animation(temp_unit.shared_from_this(),"pre_teleport",a);
94  animator.start_animations();
95  animator.wait_for_end();
96  }
97 
98  temp_unit.set_location(b);
99  if ( b_visible ) { // teleport
100  disp.invalidate(b);
101  temp_unit.set_facing(a.get_relative_dir(b));
102  if ( a_visible )
103  disp.scroll_to_tiles(b, a, game_display::ONSCREEN, true, 0.0, false);
104  else
105  disp.scroll_to_tile(b, game_display::ONSCREEN, true, false);
106  unit_animator animator;
107  animator.add_animation(temp_unit.shared_from_this(),"post_teleport",b);
108  animator.start_animations();
109  animator.wait_for_end();
110  }
111 
112  temp_unit.anim_comp().set_standing();
113  events::pump();
114 }
115 
116 /**
117  * Animates a single step between hexes.
118  * This will return before the animation actually finishes, allowing other
119  * processing to occur during the animation.
120  *
121  * @param a The starting hex.
122  * @param b The ending hex.
123  * @param temp_unit The unit to animate (historically, a temporary unit).
124  * @param step_num The number of steps taken so far (used to pick an animation).
125  * @param step_left The number of steps remaining (used to pick an animation).
126  * @param animator The unit_animator to use. This is assumed clear when we start,
127  * but will likely not be clear when we return.
128  * @param disp The game display. Assumed neither locked nor faked.
129  * @returns The animation potential until this animation will finish.
130  * INT_MIN indicates that no animation is pending.
131  */
132 int move_unit_between(const map_location& a,
133  const map_location& b,
134  unit_ptr temp_unit,
135  unsigned int step_num,
136  unsigned int step_left,
137  unit_animator& animator,
138  display& disp)
139 {
140  if ( disp.fogged(a) && disp.fogged(b) ) {
141  return INT_MIN;
142  }
143 
144  temp_unit->set_location(a);
145  disp.invalidate(a);
146  temp_unit->set_facing(a.get_relative_dir(b));
147  animator.replace_anim_if_invalid(temp_unit,"movement",a,b,step_num,
148  false,"",{0,0,0},strike_result::type::invalid,nullptr,nullptr,step_left);
149  animator.start_animations();
150  animator.pause_animation();
151  disp.scroll_to_tiles(a, b, game_display::ONSCREEN, true, 0.0, false);
152  animator.restart_animation();
153 
154  // useless now, previous short draw() just did one
155  // new_animation_frame();
156 
157  int target_time = animator.get_animation_time_potential();
158  // target_time must be short to avoid jumpy move
159  // std::cout << "target time: " << target_time << "\n";
160  // we round it to the next multiple of 200 so that movement aligns to hex changes properly
161  target_time += 200;
162  target_time -= target_time%200;
163 
164  return target_time;
165 }
166 
167 bool do_not_show_anims(display* disp)
168 {
169 
170  return !disp || video::headless();
171 }
172 
173 } // end anon namespace
174 
175 /**
176  * The path must remain unchanged for the life of this object.
177  */
178 unit_mover::unit_mover(const std::vector<map_location>& path, bool animate, bool force_scroll) :
179  disp_(game_display::get_singleton()),
180  can_draw_(disp_ && !video::headless() && path.size() > 1),
181  animate_(animate),
182  force_scroll_(force_scroll),
183  animator_(),
184  wait_until_(INT_MIN),
185  shown_unit_(),
186  path_(path),
187  current_(0),
188  temp_unit_ptr_(),
189  // Somewhat arbitrary default values.
190  was_hidden_(false),
191  is_enemy_(true)
192 {
193  // Some error conditions that indicate something has gone very wrong.
194  // (This class can handle these conditions, but someone wanted them
195  // to be assertions.)
196  assert(!path_.empty());
197  assert(disp_);
198 }
199 
200 
202 {
203  // Make sure a unit hidden for movement is unhidden.
205  // For safety, clear the animator before deleting the temp unit.
206  animator_.clear();
207 }
208 
209 
210 /**
211  * Makes the temporary unit used by this match the supplied unit.
212  * This is called when setting the initial unit, as well as replacing it with
213  * something new.
214  * When this finishes, the supplied unit is hidden, while the temporary unit
215  * is not hidden.
216  */
217 /* Note: Hide the unit in its current location; do not actually remove it.
218  * Otherwise the status displays will be wrong during the movement.
219  */
221 {
222  if ( disp_ == nullptr )
223  // No point in creating a temp unit with no way to display it.
224  return;
225 
226  // Save the hidden state of the unit.
227  was_hidden_ = u->get_hidden();
228 
229  // Make our temporary unit mostly match u...
231 
232  // ... but keep the temporary unhidden and hide the original.
233  temp_unit_ptr_->set_hidden(false);
234  u->set_hidden(true);
235 
236  // Update cached data.
237  is_enemy_ = resources::gameboard->get_team(u->side()).is_enemy(disp_->viewing_side());
238 }
239 
240 
241 /**
242  * Switches the display back to *shown_unit_ after animating.
243  * This uses temp_unit_ptr_, so (in the destructor) call this before deleting
244  * temp_unit_ptr_.
245  */
247 {
248  if ( shown_unit_ ) {
249  // Switch the display back to the real unit.
250  shown_unit_->set_hidden(was_hidden_);
251  temp_unit_ptr_->set_hidden(true);
252  shown_unit_.reset();
253  }
254 }
255 
256 
257 /**
258  * Initiates the display of movement for the supplied unit.
259  * This should be called before attempting to display moving to a new hex.
260  */
262 {
263  // Nothing to do here if there is nothing to animate.
264  if ( !can_draw_ )
265  return;
266  // If no animation then hide unit until end of movement
267  if ( !animate_ ) {
268  was_hidden_ = u->get_hidden();
269  u->set_hidden(true);
270  return;
271  }
272 
273  // This normally does nothing, but just in case...
274  wait_for_anims();
275 
276  // Visually replace the original unit with the temporary.
277  // (Original unit is left on the map, so the unit count is correct.)
279 
280  // Initialize our temporary unit for the move.
281  temp_unit_ptr_->set_location(path_[0]);
282  temp_unit_ptr_->set_facing(path_[0].get_relative_dir(path_[1]));
283  temp_unit_ptr_->anim_comp().set_standing(false);
284  disp_->invalidate(path_[0]);
285 
286  // If the unit can be seen here by the viewing side:
287  if(!is_enemy_ || !temp_unit_ptr_->invisible(path_[0])) {
288  // Scroll to the path, but only if it fully fits on screen.
289  // If it does not fit we might be able to do a better scroll later.
290  disp_->scroll_to_tiles(path_, game_display::ONSCREEN, true, true, 0.0, false);
291  }
292 
293  // extra immobile movement animation for take-off
294  animator_.add_animation(temp_unit_ptr_.get_unit_ptr(), "pre_movement", path_[0], path_[1]);
297  animator_.clear();
298 
299  // Switch the display back to the real unit.
300  u->set_facing(temp_unit_ptr_->facing());
301  u->anim_comp().set_standing(false); // Need to reset u's animation so the new facing takes effect.
302  u->set_hidden(was_hidden_);
303  temp_unit_ptr_->set_hidden(true);
304 }
305 
306 
307 /**
308  * Visually moves a unit from the last hex we drew to the one specified by
309  * @a path_index. If @a path_index points to an earlier hex, we do nothing.
310  * The moving unit will only be updated if update is set to true; otherwise,
311  * the provided unit is merely hidden during the movement and re-shown after.
312  * (Not updating the unit can produce smoother animations in some cases.)
313  * If @a wait is set to false, this returns without waiting for the final
314  * animation to finish. Call wait_for_anims() to explicitly get this final
315  * wait (another call to proceed_to() or finish() will implicitly wait). The
316  * unit must remain valid until the wait is finished.
317  */
318 void unit_mover::proceed_to(unit_ptr u, std::size_t path_index, bool update, bool wait)
319 {
320  // Nothing to do here if animations cannot be shown.
321  if ( !can_draw_ || !animate_ )
322  return;
323 
324  // Handle pending visibility issues before introducing new ones.
325  wait_for_anims();
326 
327  if ( update || !temp_unit_ptr_ )
328  // Replace the temp unit (which also hides u and shows our temporary).
330  else
331  {
332  // Just switch the display from the real unit to our fake one.
333  temp_unit_ptr_->set_hidden(false);
334  u->set_hidden(true);
335  }
336 
337  // Safety check.
338  path_index = std::min(path_index, path_.size()-1);
339 
340  for ( ; current_ < path_index; ++current_ ) {
341  // It is possible for path_[current_] and path_[current_+1] not to be adjacent.
342  // When that is the case, and the unit is invisible at path_[current_], we shouldn't
343  // scroll to that hex.
344  std::vector<map_location> locs;
345  if (!temp_unit_ptr_->invisible(path_[current_]))
346  locs.push_back(path_[current_]);
347  if (!temp_unit_ptr_->invisible(path_[current_+1]))
348  locs.push_back(path_[current_+1]);
349  // If the unit can be seen by the viewing side while making this step:
350  if ( !is_enemy_ || !locs.empty() )
351  {
352  // Wait for the previous step to complete before drawing the next one.
353  wait_for_anims();
354 
355  if ( !disp_->tile_fully_on_screen(path_[current_]) ||
356  !disp_->tile_fully_on_screen(path_[current_+1]))
357  {
358  // prevent the unit from disappearing if we scroll here with i == 0
359  temp_unit_ptr_->set_location(path_[current_]);
360  disp_->invalidate(path_[current_]);
361  // scroll in as much of the remaining path as possible
362  if ( temp_unit_ptr_->anim_comp().get_animation() )
363  temp_unit_ptr_->anim_comp().get_animation()->pause_animation();
365  true, false, 0.0, force_scroll_);
366  if ( temp_unit_ptr_->anim_comp().get_animation() )
367  temp_unit_ptr_->anim_comp().get_animation()->restart_animation();
368  }
369 
370  if ( tiles_adjacent(path_[current_], path_[current_+1]) )
371  wait_until_ =
372  move_unit_between(path_[current_], path_[current_+1],
374  path_.size() - (current_+2), animator_,
375  *disp_);
376  else if ( path_[current_] != path_[current_+1] )
377  teleport_unit_between(path_[current_], path_[current_+1],
378  *temp_unit_ptr_, *disp_);
379  }
380  }
381 
382  // Update the unit's facing.
383  u->set_facing(temp_unit_ptr_->facing());
384  u->anim_comp().set_standing(false); // Need to reset u's animation so the new facing takes effect.
385  // Remember the unit to unhide when the animation finishes.
386  shown_unit_ = u;
387  if ( wait )
388  wait_for_anims();
389 }
390 
391 
392 /**
393  * Waits for the final animation of the most recent proceed_to() to finish.
394  * It is not necessary to call this unless you want to wait before the next
395  * call to proceed_to() or finish().
396  */
398 {
399  if ( wait_until_ == INT_MAX )
400  // Wait for end (not currently used, but still supported).
402  else if ( wait_until_ != INT_MIN ) {
403  // Wait until the specified time (used for normal movement).
405  // debug code, see unit_frame::redraw()
406  // std::cout << " end\n";
407  // TODO: For wesnoth 1.14+: check if efficient for redrawing?
408  // Check with large animated units too make sure artifacts are
409  // not left on screen after unit movement in particular.
410  if ( disp_ ) { // Should always be true if we get here.
411  // Invalidate the hexes around the move that prompted this wait.
412  for(const map_location& adj : get_adjacent_tiles(path_[current_ - 1])) {
413  disp_->invalidate(adj);
414  }
415 
416  for(const map_location& adj : get_adjacent_tiles(path_[current_])) {
417  disp_->invalidate(adj);
418  }
419  }
420  }
421 
422  // Reset data.
423  wait_until_ = INT_MIN;
424  animator_.clear();
425 
427 }
428 
429 
430 /**
431  * Finishes the display of movement for the supplied unit.
432  * If called before showing the unit reach the end of the path, it will be
433  * assumed that the movement ended early.
434  * If @a dir is not supplied, the final direction will be determined by (the
435  * last two traversed hexes of) the path.
436  */
438 {
439  // Nothing to do here if the display is not valid.
440  if ( !can_draw_ ) {
441  // Make sure to reset the unit's animation to deal with a quirk in the
442  // action engine where it leaves it to us to reenable bars even if the
443  // display is initially locked.
444  u->anim_comp().set_standing(true);
445  return;
446  }
447 
448  const map_location & end_loc = path_[current_];
449  const map_location::DIRECTION final_dir = current_ == 0 ?
450  path_[0].get_relative_dir(path_[1]) :
451  path_[current_-1].get_relative_dir(end_loc);
452 
453  if ( animate_ )
454  {
455  wait_for_anims(); // In case proceed_to() did not wait for the last animation.
456 
457  // Make sure the displayed unit is correct.
459  temp_unit_ptr_->set_location(end_loc);
460  temp_unit_ptr_->set_facing(final_dir);
461 
462  // Animation
463  animator_.add_animation(temp_unit_ptr_.get_unit_ptr(), "post_movement", end_loc);
466  animator_.clear();
467 
468  // Switch the display back to the real unit.
469  u->set_hidden(was_hidden_);
470  temp_unit_ptr_->set_hidden(true);
471 
473  mousehandler->invalidate_reachmap();
474  }
475  }
476  else
477  {
478  // Show the unit at end of skipped animation
479  u->set_hidden(was_hidden_);
480  }
481 
482  // Facing gets set even when not animating.
483  u->set_facing(dir == map_location::NDIRECTIONS ? final_dir : dir);
484  u->anim_comp().set_standing(true); // Need to reset u's animation so the new facing takes effect.
485 
486  // Redraw path ends (even if not animating).
487  disp_->invalidate(path_.front());
488  disp_->invalidate(end_loc);
489 }
490 
491 
492 /**
493  * Display a unit moving along a given path.
494  *
495  * @param path The path to traverse.
496  * @param u The unit to show being moved. Its facing will be updated,
497  * but not its position.
498  * @param animate If set to false, only side-effects of move are applied
499  * (correct unit facing, path hexes redrawing).
500  * @param dir Unit will be set facing this direction after move.
501  * If nothing passed, direction will be set based on path.
502  * @param force_scroll
503  */
504 /* Note: Hide the unit in its current location,
505  * but don't actually remove it until the move is done,
506  * so that while the unit is moving status etc.
507  * will still display the correct number of units.
508  */
509 void move_unit(const std::vector<map_location>& path, unit_ptr u,
510  bool animate, map_location::DIRECTION dir,
511  bool force_scroll)
512 {
513  unit_mover mover(path, animate, force_scroll);
514 
515  mover.start(u);
516  mover.proceed_to(u, path.size());
517  mover.finish(u, dir);
518 }
519 
520 
521 void reset_helpers(const unit *attacker,const unit *defender);
522 
523 void unit_draw_weapon(const map_location& loc, unit& attacker,
524  const_attack_ptr attack,const_attack_ptr secondary_attack, const map_location& defender_loc, unit_ptr defender)
525 {
527  if(do_not_show_anims(disp) || disp->fogged(loc) || !preferences::show_combat()) {
528  return;
529  }
530  unit_animator animator;
531  attacker.set_facing(loc.get_relative_dir(defender_loc));
532  defender->set_facing(defender_loc.get_relative_dir(loc));
533  animator.add_animation(attacker.shared_from_this(),"draw_weapon",loc,defender_loc,0,true,"",{0,0,0},strike_result::type::hit,attack,secondary_attack,0);
534  if(defender) {
535  animator.add_animation(defender,"draw_weapon",defender_loc,loc,0,true,"",{0,0,0},strike_result::type::miss,secondary_attack,attack,0);
536  }
537  animator.start_animations();
538  animator.wait_for_end();
539 
540 }
541 
542 
543 void unit_sheath_weapon(const map_location& primary_loc, unit_ptr primary_unit,
544  const_attack_ptr primary_attack,const_attack_ptr secondary_attack, const map_location& secondary_loc,unit_ptr secondary_unit)
545 {
547  if(do_not_show_anims(disp) || disp->fogged(primary_loc) || !preferences::show_combat()) {
548  return;
549  }
550  unit_animator animator;
551  if(primary_unit) {
552  animator.add_animation(primary_unit,"sheath_weapon",primary_loc,secondary_loc,0,true,"",{0,0,0},strike_result::type::invalid,primary_attack,secondary_attack,0);
553  }
554  if(secondary_unit) {
555  animator.add_animation(secondary_unit,"sheath_weapon",secondary_loc,primary_loc,0,true,"",{0,0,0},strike_result::type::invalid,secondary_attack,primary_attack,0);
556  }
557 
558  if(primary_unit || secondary_unit) {
559  animator.start_animations();
560  animator.wait_for_end();
561  }
562  if(primary_unit) {
563  primary_unit->anim_comp().set_standing();
564  }
565  if(secondary_unit) {
566  secondary_unit->anim_comp().set_standing();
567  }
568  reset_helpers(primary_unit.get(),secondary_unit.get());
569 
570 }
571 
572 
573 void unit_die(const map_location& loc, unit& loser,
574  const_attack_ptr attack,const_attack_ptr secondary_attack, const map_location& winner_loc, unit_ptr winner)
575 {
577  if(do_not_show_anims(disp) || disp->fogged(loc) || !preferences::show_combat()) {
578  return;
579  }
580  unit_animator animator;
581  // hide the hp/xp bars of the loser (useless and prevent bars around an erased unit)
582  animator.add_animation(loser.shared_from_this(),"death",loc,winner_loc,0,false,"",{0,0,0},strike_result::type::kill,attack,secondary_attack,0);
583  // but show the bars of the winner (avoid blinking and show its xp gain)
584  if(winner) {
585  animator.add_animation(winner,"victory",winner_loc,loc,0,true,"",{0,0,0},
586  strike_result::type::kill,secondary_attack,attack,0);
587  }
588  animator.start_animations();
589  animator.wait_for_end();
590 
591  reset_helpers(winner.get(), &loser);
592 
594  mousehandler->invalidate_reachmap();
595  }
596 }
597 
598 
599 void unit_attack(display * disp, game_board & board,
600  const map_location& a, const map_location& b, int damage,
601  const attack_type& attack, const_attack_ptr secondary_attack,
602  int swing, const std::string& hit_text, int drain_amount,
603  const std::string& att_text,
604  const std::vector<std::string>* extra_hit_sounds,
605  bool attacking)
606 {
607  if(do_not_show_anims(disp) || (disp->fogged(a) && disp->fogged(b)) || !preferences::show_combat()) {
608  return;
609  }
610  //const unit_map& units = disp->get_units();
612 
613  // scroll such that there is at least half a hex spacing around fighters
614  disp->scroll_to_tiles(a,b,game_display::ONSCREEN,true,0.5,false);
615 
616  log_scope("unit_attack");
617 
618  const unit_map::const_iterator att = board.units().find(a);
619  assert(att.valid());
620  const unit& attacker = *att;
621 
622  const unit_map::iterator def = board.find_unit(b);
623  assert(def.valid());
624  unit &defender = *def;
625  int def_hitpoints = defender.hitpoints();
626  const_attack_ptr weapon = attack.shared_from_this();
627  auto ctx = weapon->specials_context(attacker.shared_from_this(), defender.shared_from_this(), a, b, attacking, secondary_attack);
628  std::optional<decltype(ctx)> opp_ctx;
629 
630  if(secondary_attack) {
631  opp_ctx.emplace(secondary_attack->specials_context(defender.shared_from_this(), attacker.shared_from_this(), b, a, !attacking, weapon));
632  }
633 
634  att->set_facing(a.get_relative_dir(b));
635  def->set_facing(b.get_relative_dir(a));
636  defender.set_facing(b.get_relative_dir(a));
637 
638  std::string text = number_and_text(damage, hit_text);
639  std::string text_2 = number_and_text(std::abs(drain_amount), att_text);
640 
641  strike_result::type hit_type;
642  if(damage >= defender.hitpoints()) {
643  hit_type = strike_result::type::kill;
644  } else if(damage > 0) {
645  hit_type = strike_result::type::hit;
646  }else {
647  hit_type = strike_result::type::miss;
648  }
649 
650  unit_animator animator;
651 
652  animator.add_animation(attacker.shared_from_this(), "attack", att->get_location(), def->get_location(), damage, true, text_2,
653  (drain_amount >= 0) ? color_t(0, 255, 0) : color_t(255, 0, 0), hit_type, weapon,
654  secondary_attack, swing);
655 
656  // note that we take an anim from the real unit, we'll use it later
657  const unit_animation* defender_anim = def->anim_comp().choose_animation(def->get_location(), "defend",
658  att->get_location(), damage, hit_type, weapon, secondary_attack, swing);
659 
660  animator.add_animation(defender.shared_from_this(), defender_anim, def->get_location(), true, text, {255, 0, 0});
661 
662  unit_ability_list leadership_list = attacker.get_abilities_weapons("leadership", weapon, secondary_attack);
663  unit_ability_list resistance_list = defender.get_abilities_weapons("resistance", secondary_attack, weapon);
664  for(const unit_ability& ability : leadership_list) {
665  if(ability.teacher_loc == a) {
666  continue;
667  }
668 
669  if(ability.teacher_loc == b) {
670  continue;
671  }
672 
673  unit_map::const_iterator leader = board.units().find(ability.teacher_loc);
674  assert(leader.valid());
675  leader->set_facing(ability.teacher_loc.get_relative_dir(a));
676  leader->anim_comp().invalidate(*disp);
677  animator.add_animation(leader.get_shared_ptr(), "leading", ability.teacher_loc,
678  att->get_location(), damage, true, "", {0,0,0},
679  hit_type, weapon, secondary_attack, swing);
680  }
681 
682  for(const unit_ability& ability : resistance_list) {
683  if(ability.teacher_loc == a) {
684  continue;
685  }
686 
687  if(ability.teacher_loc == b) {
688  continue;
689  }
690 
691  unit_map::const_iterator helper = board.units().find(ability.teacher_loc);
692  assert(helper.valid());
693  helper->set_facing(ability.teacher_loc.get_relative_dir(b));
694  animator.add_animation(helper.get_shared_ptr(), "resistance", ability.teacher_loc,
695  def->get_location(), damage, true, "", {0,0,0},
696  hit_type, weapon, secondary_attack, swing);
697  }
698 
699  unit_ability_list abilities = att->get_location();
700  for(auto& special : attacker.checking_tags()) {
701  abilities.append(weapon->get_weapon_ability(special));
702  }
703 
704  for(const unit_ability& ability : abilities) {
705  if(ability.teacher_loc == a) {
706  continue;
707  }
708 
709  if(ability.teacher_loc == b) {
710  continue;
711  }
712 
713  bool leading_playable = false;
714  bool helping_playable = false;
715  for(const unit_ability& leader_list : leadership_list) {
716  if(ability.teacher_loc == leader_list.teacher_loc) {
717  leading_playable = true;
718  break;
719  }
720  }
721 
722  for(const unit_ability& helper_list : resistance_list) {
723  if(ability.teacher_loc == helper_list.teacher_loc) {
724  helping_playable = true;
725  break;
726  }
727  }
728 
729  unit_map::const_iterator leader = board.units().find(ability.teacher_loc);
730  assert(leader.valid());
731  leader->set_facing(ability.teacher_loc.get_relative_dir(a));
732  if(animator.has_animation(leader.get_shared_ptr(), "leading", ability.teacher_loc,
733  att->get_location(), damage, hit_type, weapon, secondary_attack, swing) && leading_playable){
734  continue;
735  }
736  if(animator.has_animation(leader.get_shared_ptr(), "resistance", ability.teacher_loc,
737  def->get_location(), damage, hit_type, weapon, secondary_attack, swing) && helping_playable){
738  continue;
739  }
740  animator.add_animation(leader.get_shared_ptr(), "teaching", ability.teacher_loc,
741  att->get_location(), damage, true, "", {0,0,0},
742  hit_type, weapon, secondary_attack, swing);
743  }
744 
745 
746  animator.start_animations();
747  animator.wait_until(0);
748  int damage_left = damage;
749  bool extra_hit_sounds_played = false;
750  while(damage_left > 0 && !animator.would_end()) {
751  if(!extra_hit_sounds_played && extra_hit_sounds != nullptr) {
752  for (std::string hit_sound : *extra_hit_sounds) {
753  sound::play_sound(hit_sound);
754  }
755  extra_hit_sounds_played = true;
756  }
757 
758  int step_left = (animator.get_end_time() - animator.get_animation_time() )/50;
759  if(step_left < 1) step_left = 1;
760  int removed_hp = damage_left/step_left ;
761  if(removed_hp < 1) removed_hp = 1;
762  defender.take_hit(removed_hp);
763  damage_left -= removed_hp;
764  animator.wait_until(animator.get_animation_time_potential() +50);
765  }
766  animator.wait_for_end();
767  // pass the animation back to the real unit
768  def->anim_comp().start_animation(animator.get_end_time(), defender_anim, true);
769  reset_helpers(&*att, &*def);
770  def->set_hitpoints(def_hitpoints);
771 }
772 
773 // private helper function, set all helpers to default position
774 void reset_helpers(const unit *attacker,const unit *defender)
775 {
777  const unit_map& units = disp->get_units();
778  if(attacker) {
779  unit_ability_list attacker_abilities = attacker->get_abilities("leadership");
780  for(auto& special : attacker->checking_tags()) {
781  attacker_abilities.append(attacker->get_abilities(special));
782  }
783  for(const unit_ability& ability : attacker_abilities) {
784  unit_map::const_iterator leader = units.find(ability.teacher_loc);
785  assert(leader != units.end());
786  leader->anim_comp().set_standing();
787  }
788  }
789 
790  if(defender) {
791  unit_ability_list defender_abilities = defender->get_abilities("resistance");
792  for(auto& special : defender->checking_tags()) {
793  defender_abilities.append(defender->get_abilities(special));
794  }
795  for(const unit_ability& ability : defender_abilities) {
796  unit_map::const_iterator helper = units.find(ability.teacher_loc);
797  assert(helper != units.end());
798  helper->anim_comp().set_standing();
799  }
800  }
801 }
802 
803 void unit_recruited(const map_location& loc,const map_location& leader_loc)
804 {
806  if(do_not_show_anims(disp) || (disp->fogged(loc) && disp->fogged(leader_loc))) {
807  return;
808  }
809 
810  const display_context& dc = disp->get_disp_context();
811  const team& viewing_team = dc.get_team(disp->viewing_side());
812 
813  unit_map::const_iterator u = disp->get_units().find(loc);
814  if(u == disp->get_units().end()) return;
815  const bool unit_visible = u->is_visible_to_team(viewing_team, false);
816 
817  unit_map::const_iterator leader = disp->get_units().find(leader_loc); // may be null_location
818  const bool leader_visible = (leader != disp->get_units().end()) && leader->is_visible_to_team(viewing_team, false);
819 
820  unit_animator animator;
821 
822  {
823  ON_SCOPE_EXIT(u) {
824  u->set_hidden(false);
825  };
826  u->set_hidden(true);
827 
828  if (leader_visible && unit_visible) {
829  disp->scroll_to_tiles(loc,leader_loc,game_display::ONSCREEN,true,0.0,false);
830  } else if (leader_visible) {
831  disp->scroll_to_tile(leader_loc,game_display::ONSCREEN,true,false);
832  } else if (unit_visible) {
833  disp->scroll_to_tile(loc,game_display::ONSCREEN,true,false);
834  } else {
835  return;
836  }
837  if (leader != disp->get_units().end()) {
838  leader->set_facing(leader_loc.get_relative_dir(loc));
839  if (leader_visible) {
840  animator.add_animation(leader.get_shared_ptr(), "recruiting", leader_loc, loc, 0, true);
841  }
842  }
843  }
844  animator.add_animation(u.get_shared_ptr(), "recruited", loc, leader_loc);
845  animator.start_animations();
846  animator.wait_for_end();
847  animator.set_all_standing();
848  if (loc==disp->mouseover_hex()) disp->invalidate_unit();
849 }
850 
851 void unit_healing(unit &healed, const std::vector<unit *> &healers, int healing,
852  const std::string & extra_text)
853 {
855  const map_location& healed_loc = healed.get_location();
856  const bool some_healer_is_unfogged =
857  (healers.end() != std::find_if_not(healers.begin(), healers.end(),
858  [&](unit* h) { return disp->fogged(h->get_location()); }));
859 
860  if(do_not_show_anims(disp) || (disp->fogged(healed_loc) && !some_healer_is_unfogged)) {
861  return;
862  }
863 
864  // This is all the pretty stuff.
865  disp->scroll_to_tile(healed_loc, game_display::ONSCREEN,true,false);
866  disp->display_unit_hex(healed_loc);
867  unit_animator animator;
868 
869  for (unit *h : healers) {
870  h->set_facing(h->get_location().get_relative_dir(healed_loc));
871  animator.add_animation(h->shared_from_this(), "healing", h->get_location(),
872  healed_loc, healing);
873  }
874 
875  if (healing < 0) {
876  animator.add_animation(healed.shared_from_this(), "poisoned", healed_loc,
877  map_location::null_location(), -healing, false,
878  number_and_text(-healing, extra_text),
879  {255,0,0});
880  } else if ( healing > 0 ) {
881  animator.add_animation(healed.shared_from_this(), "healed", healed_loc,
882  map_location::null_location(), healing, false,
883  number_and_text(healing, extra_text),
884  {0,255,0});
885  } else {
886  animator.add_animation(healed.shared_from_this(), "healed", healed_loc,
887  map_location::null_location(), 0, false,
888  extra_text, {0,255,0});
889  }
890  animator.start_animations();
891  animator.wait_for_end();
892  animator.set_all_standing();
893 }
894 
895 } // end unit_display namespace
const map_location & mouseover_hex() const
Definition: display.hpp:289
void wait_for_end() const
Definition: animation.cpp:1458
Game board class.
Definition: game_board.hpp:52
virtual void select_hex(map_location hex)
Definition: display.cpp:1627
void unit_draw_weapon(const map_location &loc, unit &attacker, const_attack_ptr attack, const_attack_ptr secondary_attack, const map_location &defender_loc, unit_ptr defender)
Play a pre-fight animation First unit is the attacker, second unit the defender.
Definition: udisplay.cpp:523
unit_iterator end()
Definition: map.hpp:429
static display * get_singleton()
Returns the display object if a display object exists.
Definition: display.hpp:97
const team & get_team(int side) const
void start_animations()
Definition: animation.cpp:1396
void get_adjacent_tiles(const map_location &a, map_location *res)
Function which, given a location, will place all adjacent locations in res.
Definition: location.cpp:475
void unit_sheath_weapon(const map_location &primary_loc, unit_ptr primary_unit, const_attack_ptr primary_attack, const_attack_ptr secondary_attack, const map_location &secondary_loc, unit_ptr secondary_unit)
Play a post-fight animation Both unit can be set to null, only valid units will play their animation...
Definition: udisplay.cpp:543
virtual const unit_map & units() const override
Definition: game_board.hpp:113
DIRECTION get_relative_dir(const map_location &loc, map_location::RELATIVE_DIR_MODE mode) const
Definition: location.cpp:227
bool invalidate(const map_location &loc)
Function to invalidate a specific tile for redrawing.
Definition: display.cpp:3224
game_display *const disp_
Definition: udisplay.hpp:63
This class represents a single unit of a specific type.
Definition: unit.hpp:120
internal_ptr get_unit_ptr()
Get a copy of the internal unit pointer.
bool would_end() const
Definition: animation.cpp:1420
#define a
void invalidate_unit()
Function to invalidate that unit status displayed on the sidebar.
void set_location(const map_location &loc)
Sets this unit&#39;s map location.
Definition: unit.hpp:1355
const unit_map & get_units() const
Definition: display.hpp:130
int viewing_side() const
Definition: display.hpp:112
unit_mover(const unit_mover &)=delete
#define h
bool has_animation(unit_const_ptr animated_unit, const std::string &event, const map_location &src=map_location::null_location(), const map_location &dst=map_location::null_location(), const int value=0, const strike_result::type hit_type=strike_result::type::invalid, const_attack_ptr attack=nullptr, const_attack_ptr second_attack=nullptr, int value2=0) const
has_animation : return an boolean value if animated unit present and have animation specified...
Definition: animation.cpp:1349
void set_facing(map_location::DIRECTION dir) const
The this unit&#39;s facing.
Definition: unit.cpp:1586
std::shared_ptr< unit > unit_ptr
Definition: ptr.hpp:26
int get_animation_time_potential() const
Definition: animation.cpp:1480
void play_sound(const std::string &files, channel_group group, unsigned int repeats)
Definition: sound.cpp:1035
Contains a number of free functions which display units.
Definition: udisplay.cpp:39
void wait_until(int animation_time) const
Definition: animation.cpp:1430
#define b
unit_ptr shown_unit_
The unit to be (re-)shown after an animation finishes.
Definition: udisplay.hpp:71
This class stores all the data for a single &#39;side&#39; (in game nomenclature).
Definition: team.hpp:75
Data typedef for unit_ability_list.
Definition: unit.hpp:39
team & get_team(int i)
Definition: game_board.hpp:98
static mouse_handler * get_singleton()
const std::set< std::string > & checking_tags() const
Definition: unit.hpp:1713
std::size_t size(const std::string &str)
Length in characters of a UTF-8 string.
Definition: unicode.cpp:87
void finish(unit_ptr u, map_location::DIRECTION dir=map_location::NDIRECTIONS)
Finishes the display of movement for the supplied unit.
Definition: udisplay.cpp:437
void restart_animation()
Definition: animation.cpp:1506
bool tile_fully_on_screen(const map_location &loc) const
Check if a tile is fully visible on screen.
Definition: display.cpp:2051
const bool force_scroll_
Definition: udisplay.hpp:66
unit_animator animator_
Definition: udisplay.hpp:67
void update_shown_unit()
Switches the display back to *shown_unit_ after animating.
Definition: udisplay.cpp:246
game_board * gameboard
Definition: resources.cpp:21
The basic class for representing 8-bit RGB or RGBA colour values.
Definition: color.hpp:58
bool headless()
The game is running headless.
Definition: video.cpp:143
fake_unit_manager * fake_units
Definition: resources.cpp:31
std::string path
Definition: game_config.cpp:39
A class to encapsulate the steps of drawing a unit&#39;s move.
Definition: udisplay.hpp:45
void unit_healing(unit &healed, const std::vector< unit *> &healers, int healing, const std::string &extra_text)
This will use a poisoning anim if healing<0.
Definition: udisplay.cpp:851
void unit_attack(display *disp, game_board &board, const map_location &a, const map_location &b, int damage, const attack_type &attack, const_attack_ptr secondary_attack, int swing, const std::string &hit_text, int drain_amount, const std::string &att_text, const std::vector< std::string > *extra_hit_sounds, bool attacking)
Make the unit on tile &#39;a&#39; attack the unit on tile &#39;b&#39;.
Definition: udisplay.cpp:599
const std::vector< map_location > & path_
Definition: udisplay.hpp:72
void wait_for_anims()
Waits for the final animation of the most recent proceed_to() to finish.
Definition: udisplay.cpp:397
bool show_combat()
Definition: game.cpp:447
int wait_until_
The animation potential to wait until.
Definition: udisplay.hpp:69
void pump()
Process all events currently in the queue.
Definition: events.cpp:478
bool fogged(const map_location &loc) const
Returns true if location (x,y) is covered in fog.
Definition: display.cpp:735
Encapsulates the map of the game.
Definition: location.hpp:38
void add_animation(unit_const_ptr animated_unit, const unit_animation *animation, const map_location &src=map_location::null_location(), bool with_bars=false, const std::string &text="", const color_t text_color={0, 0, 0})
Definition: animation.cpp:1326
unit_iterator find(std::size_t id)
Definition: map.cpp:301
bool tiles_adjacent(const map_location &a, const map_location &b)
Function which tells if two locations are adjacent.
Definition: location.cpp:503
pointer get_shared_ptr() const
This is exactly the same as operator-> but it&#39;s slightly more readable, and can replace &*iter syntax...
Definition: map.hpp:218
void replace_temporary(unit_ptr u)
Makes the temporary unit used by this match the supplied unit.
Definition: udisplay.cpp:220
unit_animation_component & anim_comp() const
Definition: unit.hpp:1532
int get_end_time() const
Definition: animation.cpp:1485
void scroll_to_tile(const map_location &loc, SCROLL_TYPE scroll_type=ONSCREEN, bool check_fogged=true, bool force=true)
Scroll such that location loc is on-screen.
Definition: display.cpp:2150
void scroll_to_tiles(map_location loc1, map_location loc2, SCROLL_TYPE scroll_type=ONSCREEN, bool check_fogged=true, double add_spacing=0.0, bool force=true)
Scroll such that location loc1 is on-screen.
Definition: display.cpp:2162
static void update()
void pause_animation()
Definition: animation.cpp:1497
void proceed_to(unit_ptr u, std::size_t path_index, bool update=false, bool wait=true)
Visually moves a unit from the last hex we drew to the one specified by path_index.
Definition: udisplay.cpp:318
void unit_die(const map_location &loc, unit &loser, const_attack_ptr attack, const_attack_ptr secondary_attack, const map_location &winner_loc, unit_ptr winner)
Show a unit fading out.
Definition: udisplay.cpp:573
unit_map::iterator find_unit(const map_location &loc)
Definition: game_board.hpp:178
void start(unit_ptr u)
Initiates the display of movement for the supplied unit.
Definition: udisplay.cpp:261
#define log_scope(description)
Definition: log.hpp:235
const display_context & get_disp_context() const
Definition: display.hpp:177
void append(const unit_ability_list &other)
Appens the abilities from other to this, ignores other.loc()
Definition: unit.hpp:106
DIRECTION
Valid directions which can be moved in our hexagonal world.
Definition: location.hpp:40
void replace_anim_if_invalid(unit_const_ptr animated_unit, const std::string &event, const map_location &src=map_location::null_location(), const map_location &dst=map_location::null_location(), const int value=0, bool with_bars=false, const std::string &text="", const color_t text_color={0, 0, 0}, const strike_result::type hit_type=strike_result::type::invalid, const_attack_ptr attack=nullptr, const_attack_ptr second_attack=nullptr, int value2=0)
Definition: animation.cpp:1362
bool is_visible_to_team(const team &team, bool const see_all=true) const
Definition: unit.cpp:2484
void reset_helpers(const unit *attacker, const unit *defender)
Definition: udisplay.cpp:774
int get_animation_time() const
Definition: animation.cpp:1475
#define ON_SCOPE_EXIT(...)
Run some arbitrary code (a lambda) when the current scope exits The lambda body follows this header...
Definition: scope_exit.hpp:43
void set_all_standing()
Definition: animation.cpp:1515
const map_location & get_location() const
The current map location this unit is at.
Definition: unit.hpp:1345
void unit_recruited(const map_location &loc, const map_location &leader_loc)
Definition: udisplay.cpp:803
Standard logging facilities (interface).
fake_unit_ptr temp_unit_ptr_
Definition: udisplay.hpp:74
static const map_location & null_location()
Definition: location.hpp:81
Container associating units to locations.
Definition: map.hpp:98
void set_standing(bool with_bars=true)
Sets the animation state to standing.
specials_context_t specials_context(unit_const_ptr self, unit_const_ptr other, const map_location &unit_loc, const map_location &other_loc, bool attacking, const_attack_ptr other_attack) const
unit_ability_list get_abilities(const std::string &tag_name, const map_location &loc) const
Gets the unit&#39;s active abilities of a particular type if it were on a specified location.
Definition: abilities.cpp:189
bool valid() const
Definition: map.hpp:274
std::shared_ptr< const attack_type > const_attack_ptr
Definition: ptr.hpp:34
void display_unit_hex(map_location hex)
Change the unit to be displayed in the sidebar.
Holds a temporary unit that can be drawn on the map without being placed in the unit_map.
Display units performing various actions: moving, attacking, and dying.
void move_unit(const std::vector< map_location > &path, unit_ptr u, bool animate, map_location::DIRECTION dir, bool force_scroll)
Display a unit moving along a given path.
Definition: udisplay.cpp:509
static game_display * get_singleton()