The Battle for Wesnoth  1.15.9+dev
vision.hpp
Go to the documentation of this file.
1 /*
2  Copyright (C) 2003 - 2018 by David White <dave@whitevine.net>
3  Part of the Battle for Wesnoth Project https://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 /**
39  * Class that stores the part of a unit's data that is needed for fog clearing.
40  * (Used by the undo stack as that cannot rely on a unit sticking around, and
41  * we do not really need to copy the entire unit.)
42  */
43 struct clearer_info {
44  std::size_t underlying_id;
46  bool slowed;
47  /** costs is always non-null, all of the constructors initialize it */
48  std::unique_ptr<movetype::terrain_costs> costs;
49 
50  clearer_info(const unit & viewer);
51  clearer_info(const config & cfg);
52 
53  void write(config & cfg) const;
54 };
55 
56 /**
57  * Class to encapsulate fog/shroud clearing and the resultant sighted events.
58  * Note: This class uses teams as parameters (instead of sides) since a
59  * function using this should first check to see if fog/shroud is in use (to
60  * save processing when it is not), which implies the team is readily available.
61  */
63 public:
64  shroud_clearer(const shroud_clearer&) = delete;
65  shroud_clearer& operator=(const shroud_clearer&) = delete;
66 
68  ~shroud_clearer();
69 
70  /**
71  * Function to be called if units have moved or otherwise changed.
72  * It can also be called if it is desirable to calculate the cache
73  * in advance of fog clearing.
74  * @param[in] new_team The team whose vision will be used. If left as
75  * nullptr, the cache will be just be cleared (to be
76  * recalculated later as needed).
77  */
78  void cache_units(const team * new_team=nullptr) { calculate_jamming(new_team); }
79  // cache_units() is currently a near-synonym for calculate_jamming(). The
80  // reason for the two names is so the private function says what it does,
81  // while the public one says why it might be invoked.
82 
83  /**
84  * Clears shroud (and fog) around the provided location for @a view_team
85  * based on @a sight_range, @a costs, and @a slowed.
86  */
87  bool clear_unit(const map_location &view_loc, team &view_team,
88  std::size_t viewer_id, int sight_range, bool slowed,
90  const map_location & real_loc,
91  const std::set<map_location>* known_units = nullptr,
92  std::size_t * enemy_count = nullptr, std::size_t * friend_count = nullptr,
93  move_unit_spectator * spectator = nullptr, bool instant = true);
94  /**
95  * Clears shroud (and fog) around the provided location for @a view_team
96  * as if @a viewer was standing there.
97  */
98  bool clear_unit(const map_location &view_loc,
99  const unit &viewer, team &view_team,
100  const std::set<map_location>* known_units = nullptr,
101  std::size_t * enemy_count = nullptr, std::size_t * friend_count = nullptr,
102  move_unit_spectator * spectator = nullptr, bool instant = true);
103  /**
104  * Clears shroud (and fog) around the provided location for @a view_team
105  * as if @a viewer was standing there. Setting @a instant to false
106  * allows some drawing delays that are used to make movement look better.
107  */
108  bool clear_unit(const map_location &view_loc, const unit &viewer,
109  team &view_team, bool instant)
110  { return clear_unit(view_loc, viewer, view_team, nullptr, nullptr, nullptr, nullptr, instant); }
111  /**
112  * Clears shroud (and fog) around the provided location for @a view_team
113  * as if @a viewer was standing there.
114  */
115  bool clear_unit(const map_location &view_loc, team &view_team,
116  const clearer_info &viewer, bool instant);
117  /**
118  * Clears shroud (and fog) around the provided location as if @a viewer
119  * was standing there.
120  */
121  bool clear_unit(const map_location &view_loc, const unit &viewer,
122  bool can_delay = false, bool invalidate = true,
123  bool instant = true);
124 
125  /** Clears shroud (and fog) at the provided location and its immediate neighbors. */
126  bool clear_dest(const map_location &dest, const unit &viewer);
127 
128  /** Erases the record of sighted events from earlier fog/shroud clearing. */
129  void drop_events();
130 
131  /** Fires the sighted events that were earlier recorded by fog/shroud clearing. */
132  game_events::pump_result_t fire_events();
133 
134  /** The invalidations that should occur after invoking clear_unit(). */
135  void invalidate_after_clear();
136 
137 private:
138  /** A record of a sighting event. */
139  struct sight_data;
140 
141  /** Causes this object's "jamming" map to be recalculated. */
142  void calculate_jamming(const team * new_team);
143 
144  /** Clears shroud from a single location. */
145  bool clear_loc(team &tm, const map_location &loc, const map_location &view_loc,
146  const map_location &event_non_loc, std::size_t viewer_id,
147  bool check_units, std::size_t &enemy_count, std::size_t &friend_count,
148  move_unit_spectator * spectator = nullptr);
149 
150  /** Convenience wrapper for adding sighting data to the sightings_ vector. */
151  inline void record_sighting(const unit & seen, const map_location & seen_loc,
152  std::size_t sighter_id, const map_location & sighter_loc);
153 
154 private: // data
155  std::map<map_location, int> jamming_;
156  std::vector<sight_data> sightings_;
157  /** Keeps track of the team associated with jamming_. */
158  const team * view_team_;
159 };
160 
161 
162 /** Returns the sides that cannot currently see @a target. */
163 std::vector<int> get_sides_not_seeing(const unit & target);
164 /** Fires sighted events for the sides that can see @a target. */
165 game_events::pump_result_t actor_sighted(const unit & target, const std::vector<int> * cache = nullptr);
166 
167 
168 /** Function that recalculates the fog of war. */
169 void recalculate_fog(int side);
170 
171 /** Function that will clear shroud (and fog) based on current unit positions. */
172 bool clear_shroud(int side, bool reset_fog = false, bool fire_events = true);
173 
174 
175 }//namespace actions
Class that stores the part of a unit&#39;s data that is needed for fog clearing.
Definition: vision.hpp:43
A const-only interface for how many (movement, vision, or "jamming") points a unit needs for each hex...
Definition: movetype.hpp:52
std::vector< sight_data > sightings_
Definition: vision.hpp:156
This class represents a single unit of a specific type.
Definition: unit.hpp:119
A record of a sighting event.
Definition: vision.cpp:141
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:108
std::size_t underlying_id
Definition: vision.hpp:44
clearer_info(const unit &viewer)
Constructor from a unit.
Definition: vision.cpp:102
This class stores all the data for a single &#39;side&#39; (in game nomenclature).
Definition: team.hpp:44
void recalculate_fog(int side)
Function that recalculates the fog of war.
Definition: vision.cpp:714
Encapsulates the map of the game.
Definition: location.hpp:37
static tcache cache
Definition: minimap.cpp:123
void write(config &cfg) const
Writes to a config.
Definition: vision.cpp:124
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:763
std::unique_ptr< movetype::terrain_costs > costs
costs is always non-null, all of the constructors initialize it
Definition: vision.hpp:48
const team * view_team_
Keeps track of the team associated with jamming_.
Definition: vision.hpp:158
std::map< map_location, int > jamming_
Definition: vision.hpp:155
void cache_units(const team *new_team=nullptr)
Function to be called if units have moved or otherwise changed.
Definition: vision.hpp:78
Class to encapsulate fog/shroud clearing and the resultant sighted events.
Definition: vision.hpp:62
std::tuple< bool, bool > pump_result_t
Definition: fwd.hpp:28
A config object defines a single node in a WML file, with access to child nodes.
Definition: config.hpp:60
std::vector< int > get_sides_not_seeing(const unit &target)
Returns the sides that cannot currently see target.
Definition: vision.cpp:604
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:631