53 #define DBG_NG LOG_STREAM(debug, log_engine)
102 : ambusher_(units.end()),failed_teleport_(units.end()),seen_enemies_(),seen_friends_(),
unit_(units.end())
142 team *
t =
static_cast<unsigned>(side - 1) < teams.size() ? &teams[side - 1] :
nullptr;
143 if (
t &&
t->owns_village(loc)) {
149 bool grants_timebonus =
false;
151 int old_owner_side = 0;
154 for(
team& tm : teams) {
155 int i_side = tm.side();
156 if (!
t || not_defeated ||
t->is_enemy(i_side)) {
157 if(tm.owns_village(loc)) {
158 old_owner_side = i_side;
159 tm.lose_village(loc);
161 if (side != i_side && action_timebonus) {
162 grants_timebonus =
true;
171 if(grants_timebonus) {
172 t->set_action_bonus_count(1 +
t->action_bonus_count());
173 *action_timebonus =
true;
191 typedef std::vector<map_location>::const_iterator route_iterator;
194 unit_mover(
const unit_mover&) =
delete;
195 unit_mover& operator=(
const unit_mover&) =
delete;
197 unit_mover(
const std::vector<map_location> & route,
198 move_unit_spectator *move_spectator,
199 bool skip_sightings,
bool skip_ally_sightings);
203 bool check_expected_movement();
205 void try_actual_movement(
bool show);
209 void feedback()
const;
211 void try_teleport(
bool show);
214 std::vector<map_location> expected_path()
const
220 std::size_t steps_travelled()
const
228 bool interrupted(
bool include_end_of_move_events=
true)
const
239 void cache_hidden_units(
const route_iterator &
start,
240 const route_iterator & stop);
242 void fire_hex_event(
const std::string & event_name,
243 const route_iterator & current,
244 const route_iterator & other);
246 bool is_ai_move()
const {
return spectator_ !=
nullptr; }
248 route_iterator plot_turn(
const route_iterator &
start,
249 const route_iterator & stop);
254 void pump_sighted(
const route_iterator & from);
256 static std::string read_ambush_string(
const unit & ambusher);
258 void reveal_ambusher(
const map_location & hex,
bool update_alert=
true);
261 bool undo_blocked()
const
270 inline void check_for_ambushers(
const map_location & hex);
272 inline bool check_for_obstructing_unit(
const map_location & hex,
275 inline bool do_move(
const route_iterator & step_from,
276 const route_iterator & step_to,
283 inline void handle_fog(
const map_location & hex,
bool new_animation);
284 inline bool is_reasonable_stop(
const map_location & hex)
const;
286 inline void reveal_ambushers();
288 inline void validate_ambushers();
300 const std::vector<map_location> &
route_;
355 unit_mover::unit_mover(
const std::vector<map_location> & route,
356 move_unit_spectator *move_spectator,
357 bool skip_sightings,
bool skip_ally_sightings)
374 ,
goto_( is_ai_move() ?
move_it_->get_goto() : route.back() )
407 unit_mover::~unit_mover()
428 inline void unit_mover::check_for_ambushers(
const map_location & hex)
436 if ( neighbor_it != units.
end() &&
438 neighbor_it->invisible(loc) )
455 inline bool unit_mover::check_for_obstructing_unit(
const map_location & hex,
478 const auto allowed_teleports = teleports.
get_adjacents(prev_hex);
480 if(allowed_teleports.count(hex) == 0) {
506 inline bool unit_mover::do_move(
const route_iterator & step_from,
507 const route_iterator & step_to,
520 move_it_->anim_comp().invalidate(disp);
528 move_it_->set_facing(step_from->get_relative_dir(*step_to));
532 move_it_->anim_comp().set_standing(
false);
539 move_it_->appearance_changed(),
false);
540 move_it_->set_appearance_changed(
false);
555 const route_iterator step_to =
begin_ + 1;
558 move_it_->anim_comp().invalidate(disp);
568 move_it_->anim_comp().set_standing(
false);
576 move_it_->set_appearance_changed(
false);
588 inline void unit_mover::handle_fog(
const map_location & hex,
616 inline bool unit_mover::is_reasonable_stop(
const map_location & hex)
const
637 inline void unit_mover::reveal_ambushers()
645 reveal_ambusher(reveal,
true);
658 inline void unit_mover::validate_ambushers()
689 void unit_mover::cache_hidden_units(
const route_iterator &
start,
690 const route_iterator & stop)
700 validate_ambushers();
713 if (
start == stop ) {
747 void unit_mover::fire_hex_event(
const std::string & event_name,
748 const route_iterator & current,
749 const route_iterator & other)
766 unit_mover::route_iterator unit_mover::plot_turn(
const route_iterator &
start,
767 const route_iterator & stop)
776 int remaining_moves =
move_it_->movement_left();
790 for ( ;
end != stop; ++
end )
796 remaining_moves -=
move_it_->movement_cost(map[*end]);
797 if ( remaining_moves < 0 ) {
805 if (!
move_it_->get_ability_bool(
"skirmisher", *end) &&
848 const route_iterator new_limit = plot_turn(step,
expected_end_);
849 cache_hidden_units(step, new_limit);
867 void unit_mover::pump_sighted(
const route_iterator & from)
870 post_wml(pump_res, from);
877 std::string unit_mover::read_ambush_string(
const unit & ambusher)
881 const std::string & ambush_string = (*hide.ability_cfg)[
"alert"].str();
882 if (!ambush_string.empty()) {
883 return ambush_string;
888 return std::string();
897 void unit_mover::reveal_ambusher(
const map_location & hex,
bool update_alert)
905 if ( ambusher != units.
end() ) {
917 if ( update_alert ) {
931 auto [wml_undo_blocked, wml_move_aborted] =
actor_sighted(*ambusher, &sight_cache);
951 bool unit_mover::check_expected_movement()
964 void unit_mover::try_actual_movement(
bool show)
966 static const std::string enter_hex_str(
"enter hex");
967 static const std::string exit_hex_str(
"exit hex");
970 bool obstructed_stop =
false;
988 const route_iterator step_from =
real_end_ - 1;
995 if (
sighted_ && is_reasonable_stop(*step_from) ) {
1001 fire_hex_event(exit_hex_str, step_from,
real_end_);
1008 obstructed_stop =
true;
1013 bool new_animation = do_move(step_from,
real_end_, animator);
1023 fire_hex_event(enter_hex_str,
real_end_, step_from);
1046 if (!obstructed_stop) {
1060 void unit_mover::try_teleport(
bool show)
1062 const route_iterator step_from =
real_end_ - 1;
1069 fire_hex_event(
"exit hex", step_from,
begin_);
1071 bool new_animation = do_teleport(animator);
1074 handle_fog(*(
begin_ + 1), new_animation);
1078 fire_hex_event(
"enter hex",
begin_, step_from);
1080 if(is_reasonable_stop(*step_from)) {
1081 pump_sighted(step_from);
1084 pump_sighted(step_from);
1104 void unit_mover::post_move(undo_list *
undo_stack)
1108 int orig_village_owner = 0;
1109 bool action_time_bonus =
false;
1152 if ( mover_valid ) {
1156 action_time_bonus, orig_village_owner,
orig_dir_);
1159 if ( !mover_valid || undo_blocked() ||
1174 void unit_mover::feedback()
const
1181 std::string message_prefix =
"";
1186 message_prefix +=
" \n";
1194 std::string teleport_string =
_(
"Failed teleport! Exit not empty");
1196 message_prefix +=
" \n";
1210 symbols[
"friendphrase"] =
VNGETTEXT(
"Part of 'Units sighted! (...)' sentence^1 friendly",
"$friends friendly",
friend_count_, symbols);
1212 symbols[
"enemyphrase"] =
VNGETTEXT(
"Part of 'Units sighted! (...)' sentence^1 enemy",
"$enemies enemy",
enemy_count_, symbols);
1215 message =
VGETTEXT(
"Units sighted! ($friendphrase, $enemyphrase)", symbols);
1229 disp.
announce(message_prefix + message, msg_color, announce_options);
1230 message_prefix +=
" \n";
1237 if ( !name.empty() ) {
1239 symbols[
"hotkey"] = name;
1240 std::string
message =
VGETTEXT(
"(press $hotkey to keep moving)", symbols);
1242 message_prefix +=
" \n";
1251 bool show_move,
bool* interrupted, unit_mover& mover)
1256 *interrupted =
false;
1260 mover.try_actual_movement(show_move);
1264 "stopped_early", mover.stopped_early(),
1265 "final_hex_x", mover.final_hex().wml_x(),
1266 "final_hex_y", mover.final_hex().wml_y(),
1271 replay::process_error(
"calculated movement destination (x="+ cn[
"final_hex_x"].str() +
" y=" + cn[
"final_hex_y"].str() +
1272 ") didn't match the original destination(x="+ co[
"final_hex_x"].str() +
" y=" + co[
"final_hex_y"].str() +
")\n");
1286 *interrupted = mover.interrupted();
1289 return mover.steps_travelled();
1297 const bool skip_ally_sighted =
true;
1298 const bool continued_move =
false;
1300 const std::vector<map_location>& route{teleport_from, teleport_to};
1302 unit_mover mover(route, move_spectator, continued_move, skip_ally_sighted);
1309 config{
"teleport_from_x", teleport_from.
wml_x(),
"teleport_from_y", teleport_from.
wml_y(),
"teleport_to_x",
1310 teleport_to.
wml_x(),
"teleport_to_y", teleport_to.
wml_y()});
1312 mover.try_teleport(show_move);
1316 mover.try_teleport(show_move);
1321 bool continued_move,
bool skip_ally_sighted,
bool show_move)
1323 unit_mover mover(steps,
nullptr, continued_move, skip_ally_sighted);
1324 mover.try_teleport(show_move);
1354 if ( steps.size() < 2 || (steps.size() == 2 && steps.front() == steps.back()) ) {
1355 DBG_NG <<
"Ignoring a unit trying to jump on its hex at " <<
1366 const bool skip_ally_sighted = !
prefs::get().ally_sighted_interrupts();
1369 unit_mover mover(steps, move_spectator, continued_move, skip_ally_sighted);
1370 if ( !mover.check_expected_movement() )
1397 unit_mover mover(steps,
nullptr, continued_move,skip_ally_sighted);
1398 if ( !mover.check_expected_movement() )
std::string ambush_string_
bool event_mutated_mid_move_
std::vector< map_location > ambushers_
std::size_t friend_count_
unit_map::iterator move_it_
route_iterator expected_end_
map_location blocked_loc_
static lg::log_domain log_engine("engine")
const std::vector< map_location > & route_
map_location ambush_stop_
const bool playing_team_is_viewing_
route_iterator obstructed_
const map_location::direction orig_dir_
std::deque< int > moves_left_
route_iterator ambush_limit_
move_unit_spectator *const spectator_
const route_iterator begin_
const bool skip_sighting_
const route_iterator full_end_
const bool skip_ally_sighting_
Various functions related to moving units.
void set_ambusher(const unit_map::const_iterator &u)
set the location of an ambusher
void add_seen_friend(const unit_map::const_iterator &u)
add a location of a seen friend
const std::vector< unit_map::const_iterator > & get_seen_enemies() const
get the locations of seen enemies
const unit_map::const_iterator & get_ambusher() const
get the location of an ambusher
void add_seen_enemy(const unit_map::const_iterator &u)
add the location of new seen enemy
const unit_map::const_iterator & get_unit() const
get new location of moved unit
unit_map::const_iterator ambusher_
unit_map::const_iterator unit_
void reset(const unit_map &units)
reset all locations to empty values
void set_unit(const unit_map::const_iterator &u)
set the iterator to moved unit
std::vector< unit_map::const_iterator > seen_enemies_
void set_failed_teleport(const unit_map::const_iterator &u)
set the location of a failed teleport
std::vector< unit_map::const_iterator > seen_friends_
virtual ~move_unit_spectator()
destructor
const std::vector< unit_map::const_iterator > & get_seen_friends() const
get the locations of seen friends
const unit_map::const_iterator & get_failed_teleport() const
get the location of a failed teleport
unit_map::const_iterator failed_teleport_
move_unit_spectator(const unit_map &units)
constructor
Class to store the actions that a player can undo and redo.
void clear()
Clears the stack of undoable (and redoable) actions.
void add_move(const unit_const_ptr u, const std::vector< map_location >::const_iterator &begin, const std::vector< map_location >::const_iterator &end, int start_moves, int timebonus=0, int village_owner=-1, const map_location::direction dir=map_location::direction::indeterminate)
Adds a move to the undo stack.
virtual bool local_checkup(const config &expected_data, config &real_data)=0
Compares data to the results calculated during the original game.
A config object defines a single node in a WML file, with access to child nodes.
int village_owner(const map_location &loc) const
Given the location of a village, will return the 1-based number of the team that currently owns it,...
Sort-of-Singleton that many classes, both GUI and non-GUI, use to access the game data.
void redraw_minimap()
Schedule the minimap to be redrawn.
bool invalidate(const map_location &loc)
Function to invalidate a specific tile for redrawing.
void announce(const std::string &msg, const color_t &color=font::GOOD_COLOR, const announce_options &options=announce_options())
Announce a message prominently.
bool fogged(const map_location &loc) const
Returns true if location (x,y) is covered in fog.
static display * get_singleton()
Returns the display object if a display object exists.
virtual const std::vector< team > & teams() const override
bool team_is_defeated(const team &t) const
Calculates whether a team is defeated.
virtual const unit_map & units() const override
virtual const gamemap & map() const override
void invalidate_unit_after_move(const map_location &src, const map_location &dst)
Same as invalidate_unit() if moving the displayed unit.
static game_display * get_singleton()
Encapsulates the map of the game.
bool is_village(const map_location &loc) const
const std::unordered_set< map_location > & get_adjacents(map_location loc) const
void maybe_throw_return_to_play_side() const
void check_victory()
Checks to see if a side has won.
static config get_movement(const std::vector< map_location > &steps, bool skip_sighted, bool skip_ally_sighted)
Records a move that follows the provided steps.
void add_synced_command(const std::string &name, const config &command)
static void process_error(const std::string &msg)
A RAII object to enter the synced context, cannot be called if we are already in a synced context.
void do_final_checkup(bool dont_throw=false)
static bool undo_blocked()
static synced_state get_synced_state()
This class stores all the data for a single 'side' (in game nomenclature).
bool fog_or_shroud() const
bool auto_shroud_updates() const
bool is_enemy(int n) const
bool owns_village(const map_location &loc) const
A class to encapsulate the steps of drawing a unit's move.
void wait_for_anims()
Waits for the final animation of the most recent proceed_to() to finish.
void start(unit_ptr u)
Initiates the display of movement for the supplied unit.
void finish(unit_ptr u, map_location::direction dir=map_location::direction::indeterminate)
Finishes the display of movement for the supplied unit.
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.
Container associating units to locations.
std::size_t count(const map_location &loc) const
unit_iterator find(std::size_t id)
umap_retval_pair_t move(const map_location &src, const map_location &dst)
Moves a unit from location src to location dst.
This class represents a single unit of a specific type.
static void clear_status_caches()
Clear this unit status cache for all units.
static std::string _(const char *str)
unit_ability_list get_abilities(const std::string &tag_name, const map_location &loc) const
Gets the unit's active abilities of a particular type if it were on a specified location.
@ STATE_UNCOVERED
The unit is petrified - it cannot move or be attacked.
T end(const std::pair< T, T > &p)
T begin(const std::pair< T, T > &p)
void get_adjacent_tiles(const map_location &a, map_location *res)
Function which, given a location, will place all adjacent locations in res.
bool tiles_adjacent(const map_location &a, const map_location &b)
Function which tells if two locations are adjacent.
Standard logging facilities (interface).
std::vector< int > get_sides_not_seeing(const unit &target)
Returns the sides that cannot currently see target.
void teleport_unit_from_replay(const std::vector< map_location > &steps, bool continued_move, bool skip_ally_sighted, bool show_move)
Teleports a unit across the board.
std::size_t move_unit_from_replay(const std::vector< map_location > &steps, undo_list *undo_stack, bool continued_move, bool skip_ally_sighted, bool show_move)
Moves a unit across the board.
game_events::pump_result_t actor_sighted(const unit &target, const std::vector< int > *cache)
Fires sighted events for the sides that can see target.
std::size_t move_unit_and_record(const std::vector< map_location > &steps, undo_list *undo_stack, bool continued_move, bool show_move, bool *interrupted, move_unit_spectator *move_spectator)
Moves a unit across the board.
static std::size_t move_unit_internal(undo_list *undo_stack, bool show_move, bool *interrupted, unit_mover &mover)
game_events::pump_result_t get_village(const map_location &loc, int side, bool *action_timebonus, bool fire_event)
Makes it so the village at the given location is owned by the given side.
void teleport_unit_and_record(const map_location &teleport_from, const map_location &teleport_to, bool show_move, move_unit_spectator *move_spectator)
Teleports a unit across the board and enters the synced context.
EXIT_STATUS start(bool clear_id, const std::string &filename, bool take_screenshot, const std::string &screenshot_filename)
Main interface for launching the editor from the title screen.
void pump()
Process all events currently in the queue.
const color_t NORMAL_COLOR
std::tuple< bool, bool > pump_result_t
void show(const std::string &window_id, const t_string &message, const point &mouse, const SDL_Rect &source_rect)
Shows a tip.
bool fire_event(const ui_event event, const std::vector< std::pair< widget *, ui_event >> &event_chain, widget *dispatcher, widget *w, F &&... params)
Helper function for fire_event.
static bool is_active(const widget *wgt)
std::string get_names(const std::string &id)
Returns a comma-separated string of hotkey names.
bool enemy_zoc(const team ¤t_team, const map_location &loc, const team &viewing_team, bool see_all)
Determines if a given location is in an enemy zone of control.
const teleport_map get_teleport_locations(const unit &u, const team &viewing_team, bool see_all, bool ignore_units, bool check_vision)
game_events::manager * game_events
actions::undo_list * undo_stack
play_controller * controller
std::shared_ptr< wb::manager > whiteboard
std::map< std::string, t_string > string_map
This module contains various pathfinding functions and utilities.
Define the game's event mechanism.
The basic class for representing 8-bit RGB or RGBA colour values.
Holds options for calls to function 'announce' (announce).
bool discard_previous
An announcement according these options should replace the previous announce (typical of fast announc...
static const hotkey_command & get_command_by_command(HOTKEY_COMMAND command)
the execute_command argument was changed from HOTKEY_COMMAND to hotkey_command, to be able to call it...
Encapsulates the map of the game.
direction
Valid directions which can be moved in our hexagonal world.
static const map_location & null_location()
Data typedef for unit_ability_list.
pointer get_shared_ptr() const
This is exactly the same as operator-> but it's slightly more readable, and can replace &*iter syntax...
checkup * checkup_instance
Display units performing various actions: moving, attacking, and dying.
Various functions that implement the undoing (and redoing) of in-game commands.
Various functions implementing vision (through fog of war and shroud).