33 return cfg[
"healed_sound"].
empty() ?
"heal.wav" : cfg[
"healed_sound"].str();
54 std::vector<config::const_all_children_iterator>
children;
64 branches.back().attributes.merge_attributes(cfg);
74 bool previously_hits_set =
false;
75 bool previously_direction_set =
false;
76 bool previously_terrain_set =
false;
77 bool previously_value_set =
false;
78 bool previously_value_2nd_set =
false;
80 const std::string s_cfg_hits = cfg[
"hits"];
81 const std::string s_cfg_direction = cfg[
"direction"];
82 const std::string s_cfg_terrain = cfg[
"terrain_types"];
83 const std::string s_cfg_value = cfg[
"value"];
84 const std::string s_cfg_value_2nd = cfg[
"value_2nd"];
87 const std::string s_branch_hits = branch.attributes[
"hits"];
88 const std::string s_branch_direction = branch.attributes[
"direction"];
89 const std::string s_branch_terrain = branch.attributes[
"terrain_types"];
90 const std::string s_branch_value = branch.attributes[
"value"];
91 const std::string s_branch_value_2nd = branch.attributes[
"value_second"];
93 if(!s_branch_hits.empty() && s_branch_hits == s_cfg_hits) {
94 previously_hits_set =
true;
97 if(!s_branch_direction.empty() && s_branch_direction == s_cfg_direction) {
98 previously_direction_set =
true;
101 if(!s_branch_terrain.empty() && s_branch_terrain == s_cfg_terrain) {
102 previously_terrain_set =
true;
105 if(!s_branch_value.empty() && s_branch_value == s_cfg_value) {
106 previously_value_set =
true;
109 if(!s_branch_value_2nd.empty() && s_branch_value_2nd == s_cfg_value_2nd) {
110 previously_value_2nd_set =
true;
117 const std::string s_branch_hits = (*iter).attributes[
"hits"];
118 const std::string s_branch_direction = (*iter).attributes[
"direction"];
119 const std::string s_branch_terrain = (*iter).attributes[
"terrain_types"];
120 const std::string s_branch_value = (*iter).attributes[
"value"];
121 const std::string s_branch_value_2nd = (*iter).attributes[
"value_second"];
123 const bool hits_match = (previously_hits_set && s_branch_hits != s_cfg_hits);
124 const bool direction_match = (previously_direction_set && s_branch_direction != s_cfg_direction);
125 const bool terrain_match = (previously_terrain_set && s_branch_terrain != s_cfg_terrain);
126 const bool value_match = (previously_value_set && s_branch_value != s_cfg_value);
127 const bool value_2nd_match = (previously_value_2nd_set && s_branch_value_2nd != s_cfg_value_2nd);
129 if((!previously_hits_set || hits_match) &&
130 (!previously_direction_set || direction_match) &&
131 (!previously_terrain_set || terrain_match) &&
132 (!previously_value_set || value_match) &&
133 (!previously_value_2nd_set || value_2nd_match) &&
134 (hits_match || direction_match || terrain_match || value_match || value_2nd_match))
138 (*iter).attributes.merge_attributes(cfg);
146 const std::string s_branch_hits = (*iter).attributes[
"hits"];
147 const std::string s_branch_direction = (*iter).attributes[
"direction"];
148 const std::string s_branch_terrain = (*iter).attributes[
"terrain_types"];
149 const std::string s_branch_value = (*iter).attributes[
"value"];
150 const std::string s_branch_value_2nd = (*iter).attributes[
"value_second"];
152 const bool hits_match = (previously_hits_set && s_branch_hits == s_cfg_hits);
153 const bool direction_match = (previously_direction_set && s_branch_direction == s_cfg_direction);
154 const bool terrain_match = (previously_terrain_set && s_branch_terrain == s_cfg_terrain);
155 const bool value_match = (previously_value_set && s_branch_value == s_cfg_value);
156 const bool value_2nd_match = (previously_value_2nd_set && s_branch_value_2nd == s_cfg_value_2nd);
158 if((!previously_hits_set || hits_match) &&
159 (!previously_direction_set || direction_match) &&
160 (!previously_terrain_set || terrain_match) &&
161 (!previously_value_set || value_match) &&
162 (!previously_value_2nd_set || value_2nd_match) &&
163 (hits_match || direction_match || terrain_match || value_match || value_2nd_match))
185 std::list<animation_cursor> anim_cursors;
186 anim_cursors.emplace_back(anim_cfg);
188 while(!anim_cursors.empty()) {
192 if(ac.
itors.empty()) {
197 anim_cursors.pop_back();
201 if(ac.
itors.front().key !=
"if") {
207 ac.
itors.pop_front();
215 anim_cursors.emplace_back(ac.
itors.front().cfg, &ac);
216 ac.
itors.pop_front();
218 }
while (!ac.
itors.empty() && ac.
itors.front().key ==
"else");
229 std::cout <<
"--branch--\n" << ab.attributes;
231 std::cout <<
"--branchcfg--\n" << ci->cfg;
238 assert(anim_cursors.size() == 1);
250 return expanded_animations;
257 , secondary_unit_filter_()
260 , base_score_(variation)
263 , primary_attack_filter_()
264 , secondary_attack_filter_()
268 , unit_anim_(start_time,builder)
271 , invalidated_(false)
272 , play_offscreen_(true)
281 , secondary_unit_filter_()
283 , frequency_(cfg[
"frequency"])
284 , base_score_(cfg[
"base_score"])
287 , primary_attack_filter_()
288 , secondary_attack_filter_()
292 , unit_anim_(cfg,frame_string)
295 , invalidated_(false)
296 , play_offscreen_(true)
302 if(fr.key == frame_string) {
306 if(fr.key.find(
"_frame", fr.key.size() - 6) == std::string::npos) {
319 const std::vector<std::string>& my_directions =
utils::split(cfg[
"direction"]);
320 for(
const auto& direction : my_directions) {
345 value_.push_back(atoi(v.c_str()));
349 if(
h ==
"yes" ||
h == strike_result::hit) {
350 hits_.push_back(strike_result::type::hit);
353 if(
h ==
"no" ||
h == strike_result::miss) {
354 hits_.push_back(strike_result::type::miss);
357 if(
h ==
"yes" ||
h == strike_result::kill ) {
358 hits_.push_back(strike_result::type::kill);
362 for(
const auto& v2 :
utils::split(cfg[
"value_second"])) {
363 value2_.push_back(atoi(v2.c_str()));
384 if(!event.empty() && !
event_.empty()) {
466 if(!attack->matches_filter(iter))
return MATCH_FAIL;
477 if(!second_attack->matches_filter(iter))
return MATCH_FAIL;
488 std::vector<unit_animation> animation_base;
489 for(
const auto& anim : animations) {
490 if(std::find(anim.event_.begin(), anim.event_.end(),
"default") != anim.event_.end()) {
491 animation_base.push_back(anim);
493 animation_base.back().event_.clear();
497 const std::string default_image = cfg[
"image"];
499 if(animation_base.empty()) {
505 frame_builder().
image(default_image).duration(300).blend(
"0.0~0.3:100,0.3~0.0:200", {255,255,255}),
506 "_disabled_selected_", 0));
508 for(
const auto& base : animation_base) {
509 animations.push_back(base);
510 animations.back().event_ = {
"standing" };
511 animations.back().play_offscreen_ =
false;
513 animations.push_back(base);
514 animations.back().event_ = {
"_ghosted_" };
515 animations.back().unit_anim_.override(0, animations.back().unit_anim_.get_animation_duration(),
particle::UNSET,
"0.9",
"", {0,0,0},
"",
"",
"~GS()");
517 animations.push_back(base);
518 animations.back().event_ = {
"_disabled_ghosted_" };
519 animations.back().unit_anim_.override(0, 1,
particle::UNSET,
"0.4",
"", {0,0,0},
"",
"",
"~GS()");
521 animations.push_back(base);
522 animations.back().event_ = {
"selected" };
523 animations.back().unit_anim_.override(0, 300,
particle::UNSET,
"",
"0.0~0.3:100,0.3~0.0:200", {255,255,255});
525 animations.push_back(base);
526 animations.back().event_ = {
"recruited" };
529 animations.push_back(base);
530 animations.back().event_ = {
"levelin" };
531 animations.back().unit_anim_.override(0, 600,
particle::NO_CYCLE,
"",
"1~0:600", {255,255,255});
533 animations.push_back(base);
534 animations.back().event_ = {
"levelout" };
535 animations.back().unit_anim_.override(0, 600,
particle::NO_CYCLE,
"",
"0~1:600,1", {255,255,255});
537 animations.push_back(base);
538 animations.back().event_ = {
"pre_movement" };
541 animations.push_back(base);
542 animations.back().event_ = {
"post_movement" };
545 animations.push_back(base);
546 animations.back().event_ = {
"movement" };
547 animations.back().unit_anim_.override(0, 200,
550 animations.push_back(base);
551 animations.back().event_ = {
"defend" };
552 animations.back().unit_anim_.override(0, animations.back().unit_anim_.get_animation_duration(),
554 animations.back().hits_.push_back(strike_result::type::hit);
555 animations.back().hits_.push_back(strike_result::type::kill);
557 animations.push_back(base);
558 animations.back().event_ = {
"defend" };
560 animations.push_back(base);
561 animations.back().event_ = {
"attack" };
562 animations.back().unit_anim_.override(-150, 300,
particle::NO_CYCLE,
"",
"", {0,0,0},
"0~0.6:150,0.6~0:150", std::to_string(
display::LAYER_UNIT_MOVE_DEFAULT-
display::LAYER_UNIT_FIRST));
563 animations.back().primary_attack_filter_.emplace_back(
"range",
"melee");
565 animations.push_back(base);
566 animations.back().event_ = {
"attack" };
568 animations.back().primary_attack_filter_.emplace_back(
"range",
"ranged");
570 animations.push_back(base);
571 animations.back().event_ = {
"death" };
573 animations.back().sub_anims_[
"_death_sound"] =
particle();
574 animations.back().sub_anims_[
"_death_sound"].add_frame(1,
frame_builder().
sound(cfg[
"die_sound"]),
true);
576 animations.push_back(base);
577 animations.back().event_ = {
"victory" };
578 animations.back().unit_anim_.override(0, animations.back().unit_anim_.get_animation_duration(),
particle::CYCLE);
580 animations.push_back(base);
582 animations.back().event_ = {
"pre_teleport" };
584 animations.push_back(base);
586 animations.back().event_ = {
"post_teleport" };
588 animations.push_back(base);
589 animations.back().event_ = {
"healing" };
591 animations.push_back(base);
592 animations.back().event_ = {
"healed" };
593 animations.back().unit_anim_.override(0, 300,
particle::NO_CYCLE,
"",
"0:30,0.5:30,0:30,0.5:30,0:30,0.5:30,0:30,0.5:30,0:30", {255,255,255});
597 animations.back().sub_anims_[
"_healed_sound"].add_frame(1,
frame_builder().
sound(healed_sound),
true);
599 animations.push_back(base);
600 animations.back().event_ = {
"poisoned" };
601 animations.back().unit_anim_.override(0, 300,
particle::NO_CYCLE,
"",
"0:30,0.5:30,0:30,0.5:30,0:30,0.5:30,0:30,0.5:30,0:30", {0,255,0});
602 animations.back().sub_anims_[
"_poison_sound"] =
particle();
608 const config& cfg,
char const* tag_name,
char const* apply_to,
610 bool offscreen =
true)
614 anim[
"apply_to"] = apply_to;
618 if(v.
empty()) v =
false;
624 animations.emplace_back(anim);
631 animations.emplace_back(ab.merge());
649 anim[
"apply_to"] =
"standing";
650 anim[
"cycles"] =
true;
654 std::string sub_frame_name = ci->key;
655 std::size_t pos = sub_frame_name.find(
"_frame");
656 if(pos != std::string::npos) {
657 anim[sub_frame_name.substr(0, pos) +
"_cycles"] =
true;
661 if(anim[
"layer"].empty()) {
662 anim[
"layer"] = default_layer;
665 if(anim[
"offscreen"].empty()) {
666 anim[
"offscreen"] =
false;
669 animations.emplace_back(anim);
675 anim[
"apply_to"] =
"default";
676 anim[
"cycles"] =
true;
679 std::string sub_frame_name = ci->key;
680 std::size_t pos = sub_frame_name.find(
"_frame");
681 if(pos != std::string::npos) {
682 anim[sub_frame_name.substr(0, pos) +
"_cycles"] =
true;
686 if(anim[
"layer"].empty()) {
687 anim[
"layer"] = default_layer;
690 if(anim[
"offscreen"].empty()) {
691 anim[
"offscreen"] =
false;
694 animations.emplace_back(anim);
699 anim[
"apply_to"] =
"healing";
700 anim[
"value"] = anim[
"damage"];
702 if(anim[
"layer"].empty()) {
703 anim[
"layer"] = default_layer;
706 animations.emplace_back(anim);
711 anim[
"apply_to"] =
"healed";
712 anim[
"value"] = anim[
"healing"];
714 if(anim[
"layer"].empty()) {
715 anim[
"layer"] = default_layer;
718 animations.emplace_back(anim);
719 animations.back().sub_anims_[
"_healed_sound"] =
particle();
722 animations.back().sub_anims_[
"_healed_sound"].add_frame(1,
frame_builder().
sound(healed_sound),
true);
727 anim[
"apply_to"] =
"poisoned";
728 anim[
"value"] = anim[
"damage"];
730 if(anim[
"layer"].empty()) {
731 anim[
"layer"] = default_layer;
734 animations.emplace_back(anim);
735 animations.back().sub_anims_[
"_poison_sound"] =
particle();
743 anim[
"apply_to"] =
"movement";
745 if(anim[
"offset"].empty()) {
746 anim[
"offset"] =
"0~1:200,0~1:200,0~1:200,0~1:200,0~1:200,0~1:200,0~1:200,0~1:200,0~1:200,0~1:200,0~1:200,0~1:200,0~1:200,0~1:200,0~1:200,0~1:200,0~1:200,0~1:200,0~1:200,0~1:200,0~1:200,0~1:200,0~1:200,0~1:200,0~1:200,0~1:200,0~1:200,0~1:200,0~1:200,0~1:200,0~1:200,0~1:200,0~1:200,0~1:200,";
749 if(anim[
"layer"].empty()) {
750 anim[
"layer"] = move_layer;
753 animations.emplace_back(anim);
760 anim[
"apply_to"] =
"defend";
762 if(anim[
"layer"].empty()) {
763 anim[
"layer"] = default_layer;
766 if(!anim[
"damage"].empty() && anim[
"value"].empty()) {
767 anim[
"value"] = anim[
"damage"];
770 if(anim[
"hits"].empty()) {
771 anim[
"hits"] =
false;
772 animations.emplace_back(anim);
773 animations.back().base_score_--;
776 animations.emplace_back(anim);
777 animations.back().base_score_--;
779 image::locator image_loc = animations.back().get_last_frame().end_parameters().image;
783 .blend(
"0.0,0.5:75,0.0:75,0.5:75,0.0", {255,0,0}));
785 for(
const std::string& hit_type :
utils::split(anim[
"hits"])) {
787 tmp[
"hits"] = hit_type;
789 animations.emplace_back(tmp);
791 image::locator image_loc = animations.back().get_last_frame().end_parameters().image;
792 if(hit_type ==
"yes" || hit_type == strike_result::hit || hit_type == strike_result::kill) {
796 .blend(
"0.0,0.5:75,0.0:75,0.5:75,0.0", {255,0,0}));
807 anim[
"apply_to"] =
"attack";
809 if(anim[
"layer"].empty()) {
810 anim[
"layer"] = move_layer;
814 if(anim[
"offset"].empty() && missile_fs.
empty()) {
815 anim[
"offset"] =
"0~0.6,0.6~0";
818 if(!missile_fs.empty()) {
819 if(anim[
"missile_offset"].empty()) {
820 anim[
"missile_offset"] =
"0~0.8";
823 if(anim[
"missile_layer"].empty()) {
824 anim[
"missile_layer"] = missile_layer;
834 animations.emplace_back(anim);
839 anim[
"apply_to"] =
"death";
841 if(anim[
"layer"].empty()) {
842 anim[
"layer"] = default_layer;
845 animations.emplace_back(anim);
846 image::locator image_loc = animations.back().get_last_frame().end_parameters().image;
851 .highlight(
"1~0:600"));
853 if(!cfg[
"die_sound"].empty()) {
854 animations.back().sub_anims_[
"_death_sound"] =
particle();
855 animations.back().sub_anims_[
"_death_sound"].add_frame(1,
frame_builder().
sound(cfg[
"die_sound"]),
true);
863 anim[
"apply_to"] = anim[
"flag"];
865 if(anim[
"layer"].empty()) {
866 anim[
"layer"] = default_layer;
869 animations.emplace_back(anim);
874 if(anim[
"layer"].empty()) {
875 anim[
"layer"] = default_layer;
878 anim[
"apply_to"] =
"pre_teleport";
879 animations.emplace_back(anim);
880 animations.back().unit_anim_.set_end_time(0);
882 anim[
"apply_to"] =
"post_teleport";
883 animations.emplace_back(anim);
884 animations.back().unit_anim_.remove_frames_until(0);
891 ,
const std::string& highlight
892 ,
const std::string& blend_ratio
894 ,
const std::string& offset
895 ,
const std::string& layer
896 ,
const std::string& modifiers)
918 if(parameters_.need_update())
return true;
932 , last_frame_begin_time_(0)
938 if(!range.empty() && cfg[frame_string +
"start_time"].
empty()) {
939 for(
const config& frame : range) {
946 for(
const config& frame : range) {
951 cycles_ = cfg[frame_string +
"cycles"].to_bool(
false);
963 if(anim.second.need_update())
return true;
978 if(anim.second.need_minimal_update())
return true;
988 if(!anim.second.animation_finished())
return false;
998 if(!anim.second.animation_finished_potential())
return false;
1009 anim.second.update_last_draw_time(acceleration);
1017 result = std::max<int>(result, anim.second.get_end_time());
1027 result = std::min<int>(result, anim.second.get_begin_time());
1036 ,
const std::string& text
1038 ,
const bool accelerate)
1055 anim.second.start_animation(start_time);
1070 anim.second.pause_animation();
1079 anim.second.restart_animation();
1093 anim.second.redraw(value,
src_,
dst_, halo_man);
1102 anim.second.clear_halo();
1114 if(complete_redraw) {
1120 std::set<map_location> tmp = anim.second.get_overlaped_hex(value,
src_,
dst_);
1130 if(complete_redraw) {
1152 std::ostringstream outstream;
1154 return outstream.str();
1160 outstream <<
"[" << events_string <<
"]\n";
1162 outstream <<
"\tstart_time=" << u_animation.
get_begin_time() <<
'\n';
1164 if(u_animation.
hits_.size() > 0) {
1165 std::vector<std::string> hits;
1167 outstream <<
"\thits=" <<
utils::join(hits) <<
'\n';
1171 std::vector<std::string> dirs;
1173 outstream <<
"\tdirections=" <<
utils::join(dirs) <<
'\n';
1183 outstream <<
"[filter]\n";
1185 outstream << cfg.
debug();
1188 outstream <<
"[/filter]\n";
1192 outstream <<
"[filter_second]\n";
1194 outstream << cfg.
debug();
1197 outstream <<
"[/filter_second]\n";
1201 outstream <<
"[filter_attack]\n";
1203 outstream << cfg.
debug();
1206 outstream <<
"[/filter_attack]\n";
1210 outstream <<
"[filter_second_attack]\n";
1212 outstream << cfg.
debug();
1215 outstream <<
"[/filter_second_attack]\n";
1219 outstream <<
"\t[frame]\n";
1221 outstream <<
"\t\t" << frame_string <<
"\n";
1223 outstream <<
"\t[/frame]\n";
1226 for(std::pair<std::string, unit_animation::particle>
p : u_animation.
sub_anims_) {
1227 for(std::size_t
i = 0;
i <
p.second.get_frames_count();
i++) {
1228 std::string sub_frame_name =
p.first;
1229 std::size_t pos = sub_frame_name.find(
"_frame");
1230 if(pos != std::string::npos) sub_frame_name = sub_frame_name.substr(0, pos);
1232 outstream <<
"\t" << sub_frame_name <<
"_start_time=" <<
p.second.get_begin_time() <<
'\n';
1233 outstream <<
"\t[" <<
p.first <<
"]\n";
1235 for(
const std::string& frame_string :
p.second.get_frame(
i).debug_strings()) {
1236 outstream <<
"\t\t" << frame_string <<
'\n';
1239 outstream <<
"\t[/" <<
p.first <<
"]\n";
1243 outstream <<
"[/" << events_string <<
"]\n";
1249 const unit_frame& current_frame = get_current_frame();
1256 if(animation_time > get_current_frame_end_time()) in_scope_of_frame =
false;
1265 current_frame.
redraw(get_current_frame_time(),
true, in_scope_of_frame, src, dst, halo_id_, halo_man, default_val, value);
1267 current_frame.
redraw(get_current_frame_time(),
false, in_scope_of_frame, src, dst, halo_id_, halo_man, default_val, value);
1278 const unit_frame& current_frame = get_current_frame();
1280 return current_frame.
get_overlaped_hex(get_current_frame_time(), src, dst, default_val,value);
1291 parameters_.override(get_animation_duration());
1297 ,
const std::string& event
1302 ,
const std::string& text
1309 if(!animated_unit)
return;
1312 tmp.
my_unit = std::move(animated_unit);
1317 tmp.
animation = tmp.
my_unit->anim_comp().choose_animation(src, event, dst, value, hit_type, attack, second_attack, value2);
1322 animated_units_.push_back(std::move(tmp));
1329 ,
const std::string& text
1332 if(!animated_unit)
return;
1335 tmp.
my_unit = std::move(animated_unit);
1345 animated_units_.push_back(std::move(tmp));
1349 ,
const std::string& event
1358 return (animated_unit && animated_unit->anim_comp().choose_animation(src, event, dst, value, hit_type, attack, second_attack, value2));
1362 ,
const std::string& event
1367 ,
const std::string& text
1374 if(!animated_unit)
return;
1376 if(animated_unit->anim_comp().get_animation() &&
1377 !animated_unit->anim_comp().get_animation()->animation_finished_potential() &&
1378 animated_unit->anim_comp().get_animation()->matches(
1389 animated_units_.push_back(std::move(tmp));
1391 add_animation(animated_unit,event,src,dst,value,with_bars,text,text_color,hit_type,attack,second_attack,value2);
1397 int begin_time = INT_MAX;
1399 for(
const auto& anim : animated_units_) {
1400 if(anim.my_unit->anim_comp().get_animation()) {
1401 if(anim.animation) {
1402 begin_time = std::min<int>(begin_time, anim.animation->get_begin_time());
1404 begin_time = std::min<int>(begin_time, anim.my_unit->anim_comp().get_animation()->get_begin_time());
1409 for(
auto& anim : animated_units_) {
1410 if(anim.animation) {
1411 anim.my_unit->anim_comp().start_animation(begin_time, anim.animation, anim.with_bars, anim.text, anim.text_color);
1412 anim.animation =
nullptr;
1414 anim.my_unit->anim_comp().get_animation()->update_parameters(anim.src, anim.src.get_direction(anim.my_unit->facing()));
1421 bool finished =
true;
1422 for(
const auto& anim : animated_units_) {
1423 finished &= anim.my_unit->anim_comp().get_animation()->animation_finished_potential();
1431 if(animated_units_.empty()) {
1436 animated_units_[0].my_unit->anim_comp().get_animation()->set_max_animation_time(animation_time);
1443 int end_tick = animated_units_[0].my_unit->anim_comp().get_animation()->time_to_tick(animation_time);
1444 while(SDL_GetTicks() <
unsigned(end_tick - std::min(
int(20 / speed), 20))) {
1449 end_tick = animated_units_[0].my_unit->anim_comp().get_animation()->time_to_tick(animation_time);
1453 SDL_Delay(std::max<int>(0, end_tick - SDL_GetTicks() + 5));
1457 animated_units_[0].my_unit->anim_comp().get_animation()->set_max_animation_time(0);
1464 bool finished =
false;
1471 for(
const auto& anim : animated_units_) {
1472 finished &= anim.my_unit->anim_comp().get_animation()->animation_finished_potential();
1479 if(animated_units_.empty()) {
1482 return animated_units_[0].my_unit->anim_comp().get_animation()->get_animation_time() ;
1487 if(animated_units_.empty()) {
1490 return animated_units_[0].my_unit->anim_comp().get_animation()->get_animation_time_potential() ;
1495 int end_time = INT_MIN;
1496 for(
const auto& anim : animated_units_) {
1497 if(anim.my_unit->anim_comp().get_animation()) {
1498 end_time = std::max<int>(end_time, anim.my_unit->anim_comp().get_animation()->get_end_time());
1507 for(
const auto& anim : animated_units_) {
1508 if(anim.my_unit->anim_comp().get_animation()) {
1509 anim.my_unit->anim_comp().get_animation()->pause_animation();
1516 for(
const auto& anim : animated_units_) {
1517 if(anim.my_unit->anim_comp().get_animation()) {
1518 anim.my_unit->anim_comp().get_animation()->restart_animation();
1525 for(
const auto& anim : animated_units_) {
1526 anim.my_unit->anim_comp().set_standing();
void new_animation_frame()
std::list< animation_branch > animation_branches
static void prepare_single_animation(const config &anim_cfg, animation_branches &expanded_anims)
static std::string get_heal_sound(const config &cfg)
static animation_branches prepare_animation(const config &cfg, const std::string &animation_tag)
static void add_simple_anim(std::vector< unit_animation > &animations, const config &cfg, char const *tag_name, char const *apply_to, display::drawing_layer layer=display::LAYER_UNIT_DEFAULT, bool offscreen=true)
const T & get_frame(std::size_t n) const
void set_end_time(int ending_time)
bool animation_finished_potential() const
int get_begin_time() const
void update_last_draw_time(double acceleration=0)
void start_animation(int start_time, bool cycles=false)
Starts an animation cycle.
int get_animation_duration() const
const unit_frame & get_last_frame() const
void set_begin_time(int new_begin_time)
bool animation_finished() const
Returns true if the current animation was finished.
std::size_t get_frames_count() const
void add_frame(int duration, const unit_frame &value, bool force_change=false)
Adds a frame to an animation.
Variant for storing WML attributes.
bool empty() const
Tests for an attribute that either was never set or was set to "".
A config object defines a single node in a WML file, with access to child nodes.
boost::iterator_range< const_all_children_iterator > const_all_children_itors
config & add_child_at(config_key_type key, const config &val, std::size_t index)
const_all_children_itors all_children_range() const
In-order iteration over all children.
child_itors child_range(config_key_type key)
std::string debug() const
boost::iterator_range< const_child_iterator > const_child_itors
config & add_child(config_key_type key)
virtual void play_slice(bool is_delay_enabled=true)
Sort-of-Singleton that many classes, both GUI and non-GUI, use to access the game data.
const unit_map & get_units() const
bool invalidate(const map_location &loc)
Function to invalidate a specific tile for redrawing.
drawing_layer
The layers to render something on.
@ LAYER_UNIT_FIRST
Reserve layers to be selected for WML.
@ LAYER_UNIT_MISSILE_DEFAULT
default layer for missile frames
@ LAYER_UNIT_DEFAULT
default layer for drawing units
@ LAYER_UNIT_MOVE_DEFAULT
default layer for drawing moving units
double turbo_speed() const
bool propagate_invalidation(const std::set< map_location > &locs)
If this set is partially invalidated, invalidate all its hexes.
const gamemap & get_map() const
bool tile_nearly_on_screen(const map_location &loc) const
Checks if location loc or one of the adjacent tiles is visible on screen.
static display * get_singleton()
Returns the display object if a display object exists.
Easily build frame parameters with the serialized constructors.
Keep most parameters in a separate class to simplify the handling of the large number of parameters b...
void override(int duration, const std::string &highlight="", const std::string &blend_ratio="", color_t blend_color={0, 0, 0}, const std::string &offset="", const std::string &layer="", const std::string &modifiers="")
bool does_not_change() const
terrain_code get_terrain(const map_location &loc) const
Looks up terrain at a particular location.
Generic locator abstracting the location of an image.
const std::string & get_filename() const
const std::string & get_modifications() const
static rng & default_instance()
void start_animation(int start_time)
std::set< map_location > get_overlaped_hex(const frame_parameters &value, const map_location &src, const map_location &dst)
frame_parsed_parameters parameters_
bool need_minimal_update() const
void override(int start_time, int duration, const cycle_state cycles, const std::string &highlight="", const std::string &blend_ratio="", color_t blend_color={0, 0, 0}, const std::string &offset="", const std::string &layer="", const std::string &modifiers="")
particle(int start_time=0, const frame_builder &builder=frame_builder())
void redraw(const frame_parameters &value, const map_location &src, const map_location &dst, halo::manager &halo_man)
bool invalidate(frame_parameters &value)
std::vector< config > primary_attack_filter_
std::vector< int > value2_
bool need_minimal_update() const
void start_animation(int start_time, const map_location &src=map_location::null_location(), const map_location &dst=map_location::null_location(), const std::string &text="", const color_t text_color={0, 0, 0}, const bool accelerate=true)
int get_animation_time() const
bool animation_finished_potential() const
std::vector< config > secondary_unit_filter_
void add_frame(int duration, const unit_frame &value, bool force_change=false)
int matches(const map_location &loc, const map_location &second_loc, unit_const_ptr my_unit, const std::string &event="", const int value=0, strike_result::type hit=strike_result::type::invalid, const_attack_ptr attack=nullptr, const_attack_ptr second_attack=nullptr, int value2=0) const
t_translation::ter_list terrain_types_
std::vector< std::string > event_
int get_current_frame_begin_time() const
std::vector< int > value_
std::string debug() const
void update_last_draw_time()
std::map< std::string, particle > sub_anims_
void update_parameters(const map_location &src, const map_location &dst)
int get_begin_time() const
void redraw(frame_parameters &value, halo::manager &halo_man)
std::set< map_location > overlaped_hex_
std::vector< map_location::DIRECTION > directions_
friend std::ostream & operator<<(std::ostream &outstream, const unit_animation &u_animation)
static void fill_initial_animations(std::vector< unit_animation > &animations, const config &cfg)
std::vector< config > secondary_attack_filter_
std::vector< config > unit_filter_
static void add_anims(std::vector< unit_animation > &animations, const config &cfg)
std::vector< strike_result::type > hits_
bool animation_finished() const
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)
void wait_until(int animation_time) const
int get_animation_time() const
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,...
void wait_for_end() const
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})
int get_animation_time_potential() const
Describes a unit's animation sequence.
void redraw(const int frame_time, bool on_start_time, bool in_scope_of_frame, const map_location &src, const map_location &dst, halo::handle &halo_id, halo::manager &halo_man, const frame_parameters &animation_val, const frame_parameters &engine_val) const
bool does_not_change() const
std::vector< std::string > debug_strings() const
std::set< map_location > get_overlaped_hex(const int frame_time, const map_location &src, const map_location &dst, const frame_parameters &animation_val, const frame_parameters &engine_val) const
unit_iterator find(std::size_t id)
This class represents a single unit of a specific type.
A variable-expanding proxy for the config class.
Functions to load and save images from/to disk.
play_controller * controller
Audio output for sound and music.
bool terrain_matches(const terrain_code &src, const terrain_code &dest)
Tests whether a specific terrain matches an expression, for matching rules see above.
ter_list read_list(std::string_view str, const ter_layer filler)
Reads a list of terrains from a string, when reading the.
std::string join(const T &v, const std::string &s=",")
Generates a new string joining container items in a list.
std::vector< std::string > split(const config_attribute_value &val)
std::shared_ptr< const unit > unit_const_ptr
std::shared_ptr< const attack_type > const_attack_ptr
std::vector< config::const_all_children_iterator > children
animation_branches branches
animation_cursor(const config &cfg)
animation_cursor(const config &cfg, animation_cursor *p)
config::const_all_children_itors itors
animation_cursor * parent
The basic class for representing 8-bit RGB or RGBA colour values.
All parameters from a frame at a given instant.
boost::tribool primary_frame
Encapsulates the map of the game.
static DIRECTION parse_direction(const std::string &str)
DIRECTION
Valid directions which can be moved in our hexagonal world.
static std::string write_direction(DIRECTION dir)
static std::string get_string(enum_type key)
Converts a enum to its string equivalent.
const unit_animation * animation