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;
155 int i_side = std::distance(teams.begin(),
i) + 1;
156 if (!
t || not_defeated ||
t->is_enemy(i_side)) {
157 if(
i->owns_village(loc)) {
158 old_owner_side = i_side;
159 i->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;
212 std::vector<map_location> expected_path()
const
218 std::size_t steps_travelled()
const
226 bool interrupted(
bool include_end_of_move_events=
true)
const
237 void cache_hidden_units(
const route_iterator &
start,
238 const route_iterator & stop);
240 void fire_hex_event(
const std::string & event_name,
241 const route_iterator & current,
242 const route_iterator & other);
244 bool is_ai_move()
const {
return spectator_ !=
nullptr; }
246 route_iterator plot_turn(
const route_iterator &
start,
247 const route_iterator & stop);
252 void pump_sighted(
const route_iterator & from);
254 static std::string read_ambush_string(
const unit & ambusher);
256 void reveal_ambusher(
const map_location & hex,
bool update_alert=
true);
259 bool undo_blocked()
const
268 inline void check_for_ambushers(
const map_location & hex);
270 inline bool check_for_obstructing_unit(
const map_location & hex,
273 inline bool do_move(
const route_iterator & step_from,
274 const route_iterator & step_to,
277 inline void handle_fog(
const map_location & hex,
bool new_animation);
278 inline bool is_reasonable_stop(
const map_location & hex)
const;
280 inline void reveal_ambushers();
282 inline void validate_ambushers();
294 const std::vector<map_location> &
route_;
349 unit_mover::unit_mover(
const std::vector<map_location> & route,
350 move_unit_spectator *move_spectator,
351 bool skip_sightings,
bool skip_ally_sightings)
368 ,
goto_( is_ai_move() ?
move_it_->get_goto() : route.back() )
401 unit_mover::~unit_mover()
422 inline void unit_mover::check_for_ambushers(
const map_location & hex)
430 if ( neighbor_it != units.
end() &&
432 neighbor_it->invisible(loc) )
449 inline bool unit_mover::check_for_obstructing_unit(
const map_location & hex,
472 const auto allowed_teleports = teleports.
get_adjacents(prev_hex);
474 if(allowed_teleports.count(hex) == 0) {
500 inline bool unit_mover::do_move(
const route_iterator & step_from,
501 const route_iterator & step_to,
514 move_it_->anim_comp().invalidate(disp);
522 move_it_->set_facing(step_from->get_relative_dir(*step_to));
526 move_it_->anim_comp().set_standing(
false);
533 move_it_->appearance_changed(),
false);
534 move_it_->set_appearance_changed(
false);
548 inline void unit_mover::handle_fog(
const map_location & hex,
576 inline bool unit_mover::is_reasonable_stop(
const map_location & hex)
const
597 inline void unit_mover::reveal_ambushers()
605 reveal_ambusher(reveal,
true);
618 inline void unit_mover::validate_ambushers()
649 void unit_mover::cache_hidden_units(
const route_iterator &
start,
650 const route_iterator & stop)
660 validate_ambushers();
673 if (
start == stop ) {
707 void unit_mover::fire_hex_event(
const std::string & event_name,
708 const route_iterator & current,
709 const route_iterator & other)
726 unit_mover::route_iterator unit_mover::plot_turn(
const route_iterator &
start,
727 const route_iterator & stop)
736 int remaining_moves =
move_it_->movement_left();
750 for ( ;
end != stop; ++
end )
756 remaining_moves -=
move_it_->movement_cost(map[*end]);
757 if ( remaining_moves < 0 ) {
765 if (!
move_it_->get_ability_bool(
"skirmisher", *end) &&
808 const route_iterator new_limit = plot_turn(step,
expected_end_);
809 cache_hidden_units(step, new_limit);
827 void unit_mover::pump_sighted(
const route_iterator & from)
830 post_wml(pump_res, from);
837 std::string unit_mover::read_ambush_string(
const unit & ambusher)
841 const std::string & ambush_string = (*hide.ability_cfg)[
"alert"].str();
842 if (!ambush_string.empty()) {
843 return ambush_string;
848 return std::string();
857 void unit_mover::reveal_ambusher(
const map_location & hex,
bool update_alert)
865 if ( ambusher != units.
end() ) {
877 if ( update_alert ) {
891 auto [wml_undo_blocked, wml_move_aborted] =
actor_sighted(*ambusher, &sight_cache);
911 bool unit_mover::check_expected_movement()
924 void unit_mover::try_actual_movement(
bool show)
926 static const std::string enter_hex_str(
"enter hex");
927 static const std::string exit_hex_str(
"exit hex");
930 bool obstructed_stop =
false;
948 const route_iterator step_from =
real_end_ - 1;
955 if (
sighted_ && is_reasonable_stop(*step_from) ) {
961 fire_hex_event(exit_hex_str, step_from,
real_end_);
968 obstructed_stop =
true;
973 bool new_animation = do_move(step_from,
real_end_, animator);
983 fire_hex_event(enter_hex_str,
real_end_, step_from);
1006 if (!obstructed_stop) {
1020 void unit_mover::post_move(undo_list *
undo_stack)
1024 int orig_village_owner = 0;
1025 bool action_time_bonus =
false;
1068 if ( mover_valid ) {
1072 action_time_bonus, orig_village_owner,
orig_dir_);
1075 if ( !mover_valid || undo_blocked() ||
1090 void unit_mover::feedback()
const
1097 std::string message_prefix =
"";
1102 message_prefix +=
" \n";
1110 std::string teleport_string =
_(
"Failed teleport! Exit not empty");
1112 message_prefix +=
" \n";
1126 symbols[
"friendphrase"] =
VNGETTEXT(
"Part of 'Units sighted! (...)' sentence^1 friendly",
"$friends friendly",
friend_count_, symbols);
1128 symbols[
"enemyphrase"] =
VNGETTEXT(
"Part of 'Units sighted! (...)' sentence^1 enemy",
"$enemies enemy",
enemy_count_, symbols);
1131 message =
VGETTEXT(
"Units sighted! ($friendphrase, $enemyphrase)", symbols);
1145 disp.
announce(message_prefix + message, msg_color, announce_options);
1146 message_prefix +=
" \n";
1153 if ( !name.empty() ) {
1155 symbols[
"hotkey"] = name;
1156 std::string
message =
VGETTEXT(
"(press $hotkey to keep moving)", symbols);
1158 message_prefix +=
" \n";
1167 bool show_move,
bool* interrupted, unit_mover& mover)
1172 *interrupted =
false;
1176 mover.try_actual_movement(show_move);
1180 "stopped_early", mover.stopped_early(),
1181 "final_hex_x", mover.final_hex().wml_x(),
1182 "final_hex_y", mover.final_hex().wml_y(),
1187 replay::process_error(
"calculated movement destination (x="+ cn[
"final_hex_x"].str() +
" y=" + cn[
"final_hex_y"].str() +
1188 ") didn't match the original destination(x="+ co[
"final_hex_x"].str() +
" y=" + co[
"final_hex_y"].str() +
")\n");
1202 *interrupted = mover.interrupted();
1205 return mover.steps_travelled();
1235 if ( steps.size() < 2 || (steps.size() == 2 && steps.front() == steps.back()) ) {
1236 DBG_NG <<
"Ignoring a unit trying to jump on its hex at " <<
1250 unit_mover mover(steps, move_spectator, continued_move, skip_ally_sighted);
1251 if ( !mover.check_expected_movement() )
1278 unit_mover mover(steps,
nullptr, continued_move,skip_ally_sighted);
1279 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_
std::deque< int > moves_left_
route_iterator ambush_limit_
move_unit_spectator *const spectator_
const route_iterator begin_
const bool skip_sighting_
const map_location::DIRECTION orig_dir_
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 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::NDIRECTIONS)
Adds a move to the undo stack.
void clear()
Clears the stack of undoable (and redoable) actions.
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
std::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::NDIRECTIONS)
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.
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.
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)
bool interrupt_when_ally_sighted()
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
std::string::const_iterator iterator
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).