The Battle for Wesnoth  1.13.10+dev
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Modules Pages
vision.hpp
Go to the documentation of this file.
1 /*
2  Copyright (C) 2003 - 2017 by David White <dave@whitevine.net>
3  Part of the Battle for Wesnoth Project http://www.wesnoth.org/
4 
5  This program is free software; you can redistribute it and/or modify
6  it under the terms of the GNU General Public License as published by
7  the Free Software Foundation; either version 2 of the License, or
8  (at your option) any later version.
9  This program is distributed in the hope that it will be useful,
10  but WITHOUT ANY WARRANTY.
11 
12  See the COPYING file for more details.
13 */
14 
15 /**
16  * @file
17  * Various functions implementing vision (through fog of war and shroud).
18  */
19 
20 #pragma once
21 
22 #include "movetype.hpp"
23 #include "game_events/fwd.hpp"
24 
25 struct map_location;
26 class team;
27 class unit;
28 
29 #include <cstring>
30 #include <map>
31 #include <set>
32 #include <vector>
33 
34 
35 namespace actions {
36  class move_unit_spectator;
37 
38 /// Class that stores the part of a unit's data that is needed for fog clearing.
39 /// (Used by the undo stack as that cannot rely on a unit sticking around, and
40 /// we do not really need to copy the entire unit.)
41 struct clearer_info {
42  size_t underlying_id;
44  bool slowed;
46 
47  clearer_info(const unit & viewer);
48  clearer_info(const config & cfg);
49 
50  void write(config & cfg) const;
51 };
52 
53 /// Class to encapsulate fog/shroud clearing and the resultant sighted events.
54 /// Note: This class uses teams as parameters (instead of sides) since a
55 /// function using this should first check to see if fog/shroud is in use (to
56 /// save processing when it is not), which implies the team is readily available.
58 public:
59  shroud_clearer(const shroud_clearer&) = delete;
60  shroud_clearer& operator=(const shroud_clearer&) = delete;
61 
64 
65  /// Function to be called if units have moved or otherwise changed.
66  /// It can also be called if it is desirable to calculate the cache
67  /// in advance of fog clearing.
68  /// @param[in] new_team The team whose vision will be used. If left as
69  /// nullptr, the cache will be just be cleared (to be
70  /// recalculated later as needed).
71  void cache_units(const team * new_team=nullptr) { calculate_jamming(new_team); }
72  // cache_units() is currently a near-synonym for calculate_jamming(). The
73  // reason for the two names is so the private function says what it does,
74  // while the public one says why it might be invoked.
75 
76  /// Clears shroud (and fog) around the provided location for @a view_team
77  /// based on @a sight_range, @a costs, and @a slowed.
78  bool clear_unit(const map_location &view_loc, team &view_team,
79  size_t viewer_id, int sight_range, bool slowed,
80  const movetype::terrain_costs & costs,
81  const map_location & real_loc,
82  const std::set<map_location>* known_units = nullptr,
83  size_t * enemy_count = nullptr, size_t * friend_count = nullptr,
84  move_unit_spectator * spectator = nullptr, bool instant = true);
85  /// Clears shroud (and fog) around the provided location for @a view_team
86  /// as if @a viewer was standing there.
87  bool clear_unit(const map_location &view_loc,
88  const unit &viewer, team &view_team,
89  const std::set<map_location>* known_units = nullptr,
90  size_t * enemy_count = nullptr, size_t * friend_count = nullptr,
91  move_unit_spectator * spectator = nullptr, bool instant = true);
92  /// Clears shroud (and fog) around the provided location for @a view_team
93  /// as if @a viewer was standing there. Setting @a instant to false
94  /// allows some drawing delays that are used to make movement look better.
95  bool clear_unit(const map_location &view_loc, const unit &viewer,
96  team &view_team, bool instant)
97  { return clear_unit(view_loc, viewer, view_team, nullptr, nullptr, nullptr, nullptr, instant); }
98  /// Clears shroud (and fog) around the provided location for @a view_team
99  /// as if @a viewer was standing there.
100  bool clear_unit(const map_location &view_loc, team &view_team,
101  const clearer_info &viewer, bool instant);
102  /// Clears shroud (and fog) around the provided location as if @a viewer
103  /// was standing there.
104  bool clear_unit(const map_location &view_loc, const unit &viewer,
105  bool can_delay = false, bool invalidate = true,
106  bool instant = true);
107 
108  /// Clears shroud (and fog) at the provided location and its immediate neighbors.
109  bool clear_dest(const map_location &dest, const unit &viewer);
110 
111  /// Erases the record of sighted events from earlier fog/shroud clearing.
112  void drop_events();
113 
114  /// Fires the sighted events that were earlier recorded by fog/shroud clearing.
116 
117  /// The invalidations that should occur after invoking clear_unit().
118  void invalidate_after_clear();
119 
120 private:
121  /// A record of a sighting event.
122  struct sight_data;
123 
124  /// Causes this object's "jamming" map to be recalculated.
125  void calculate_jamming(const team * new_team);
126 
127  /// Clears shroud from a single location.
128  bool clear_loc(team &tm, const map_location &loc, const map_location &view_loc,
129  const map_location &event_non_loc, size_t viewer_id,
130  bool check_units, size_t &enemy_count, size_t &friend_count,
131  move_unit_spectator * spectator = nullptr);
132 
133  /// Convenience wrapper for adding sighting data to the sightings_ vector.
134  inline void record_sighting(const unit & seen, const map_location & seen_loc,
135  size_t sighter_id, const map_location & sighter_loc);
136 
137 private: // data
138  std::map<map_location, int> jamming_;
139  std::vector<sight_data> sightings_;
140  /// Keeps track of the team associated with jamming_.
141  const team * view_team_;
142 };
143 
144 
145 /// Returns the sides that cannot currently see @a target.
146 std::vector<int> get_sides_not_seeing(const unit & target);
147 /// Fires sighted events for the sides that can see @a target.
148 game_events::pump_result_t actor_sighted(const unit & target, const std::vector<int> * cache = nullptr);
149 
150 
151 /// Function that recalculates the fog of war.
152 void recalculate_fog(int side);
153 
154 /// Function that will clear shroud (and fog) based on current unit positions.
155 bool clear_shroud(int side, bool reset_fog = false, bool fire_events = true);
156 
157 
158 }//namespace actions
Class that stores the part of a unit's data that is needed for fog clearing.
Definition: vision.hpp:41
Stores a set of terrain costs (for movement, vision, or "jamming").
Definition: movetype.hpp:86
std::vector< sight_data > sightings_
Definition: vision.hpp:139
This class represents a single unit of a specific type.
Definition: unit.hpp:100
bool clear_unit(const map_location &view_loc, team &view_team, size_t viewer_id, int sight_range, bool slowed, const movetype::terrain_costs &costs, const map_location &real_loc, const std::set< map_location > *known_units=nullptr, size_t *enemy_count=nullptr, size_t *friend_count=nullptr, move_unit_spectator *spectator=nullptr, bool instant=true)
Clears shroud (and fog) around the provided location for view_team based on sight_range, costs, and slowed.
Definition: vision.cpp:330
bool clear_unit(const map_location &view_loc, const unit &viewer, team &view_team, bool instant)
Clears shroud (and fog) around the provided location for view_team as if viewer was standing there...
Definition: vision.hpp:95
~shroud_clearer()
Destructor.
Definition: vision.cpp:178
void record_sighting(const unit &seen, const map_location &seen_loc, size_t sighter_id, const map_location &sighter_loc)
Convenience wrapper for adding sighting data to the sightings_ vector.
Definition: vision.cpp:158
clearer_info(const unit &viewer)
Constructor from a unit.
Definition: vision.cpp:102
void calculate_jamming(const team *new_team)
Causes this object's "jamming" map to be recalculated.
Definition: vision.cpp:192
bool clear_dest(const map_location &dest, const unit &viewer)
Clears shroud (and fog) at the provided location and its immediate neighbors.
Definition: vision.cpp:494
bool clear_loc(team &tm, const map_location &loc, const map_location &view_loc, const map_location &event_non_loc, size_t viewer_id, bool check_units, size_t &enemy_count, size_t &friend_count, move_unit_spectator *spectator=nullptr)
Clears shroud from a single location.
Definition: vision.cpp:226
This class stores all the data for a single 'side' (in game nomenclature).
Definition: team.hpp:44
game_events::pump_result_t fire_events()
Fires the sighted events that were earlier recorded by fog/shroud clearing.
Definition: vision.cpp:546
void recalculate_fog(int side)
Function that recalculates the fog of war.
Definition: vision.cpp:705
shroud_clearer & operator=(const shroud_clearer &)=delete
Encapsulates the map of the game.
Definition: location.hpp:40
void drop_events()
Erases the record of sighted events from earlier fog/shroud clearing.
Definition: vision.cpp:533
static tcache cache
Definition: minimap.cpp:137
bool clear_shroud(int side, bool reset_fog, bool fire_events)
Function that will clear shroud (and fog) based on current unit positions.
Definition: vision.cpp:754
const team * view_team_
Keeps track of the team associated with jamming_.
Definition: vision.hpp:141
void write(config &cfg) const
Writes to a config.
Definition: vision.cpp:124
std::map< map_location, int > jamming_
Definition: vision.hpp:138
void cache_units(const team *new_team=nullptr)
Function to be called if units have moved or otherwise changed.
Definition: vision.hpp:71
Class to encapsulate fog/shroud clearing and the resultant sighted events.
Definition: vision.hpp:57
movetype::terrain_costs costs
Definition: vision.hpp:45
std::tuple< bool, bool > pump_result_t
Definition: fwd.hpp:28
void invalidate_after_clear()
The invalidations that should occur after invoking clear_unit().
Definition: vision.cpp:581
A config object defines a single node in a WML file, with access to child nodes.
Definition: config.hpp:93
shroud_clearer()
Default constructor.
Definition: vision.cpp:169
std::vector< int > get_sides_not_seeing(const unit &target)
Returns the sides that cannot currently see target.
Definition: vision.cpp:595
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.
Definition: vision.cpp:622