The Battle for Wesnoth  1.15.1+dev
display_context.cpp
Go to the documentation of this file.
1 /*
2  Copyright (C) 2014 - 2018 by Chris Beck <render787@gmail.com>
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 #include "display_context.hpp"
16 
17 #include "map/map.hpp"
18 #include "map/location.hpp"
19 #include "team.hpp"
20 #include "units/unit.hpp"
21 #include "units/map.hpp"
22 
23 const team& display_context::get_team(int side) const
24 {
25  return teams().at(side - 1);
26 }
27 
28 bool display_context::would_be_discovered(const map_location & loc, int side_num, bool see_all)
29 {
31  get_adjacent_tiles(loc,adjs.data());
32 
33  for (const map_location &u_loc : adjs)
34  {
35  unit_map::const_iterator u_it = units().find(u_loc);
36  if (!u_it.valid()) {
37  continue;
38  }
39  const unit & u = *u_it;
40  if (get_team(side_num).is_enemy(u.side()) && !u.incapacitated()) {
41  // Enemy spotted in adjacent tiles, check if we can see him.
42  // Watch out to call invisible with see_all=true to avoid infinite recursive calls!
43  if(see_all) {
44  return true;
45  } else if (!get_team(side_num).fogged(u_loc)
46  && !u.invisible(u_loc, true)) {
47  return true;
48  }
49  }
50  }
51  return false;
52 }
53 
54 const unit * display_context::get_visible_unit(const map_location & loc, const team &current_team, bool see_all) const
55 {
56  if (!map().on_board(loc)) return nullptr;
57  const unit_map::const_iterator u = units().find(loc);
58  if (!u.valid() || !u->is_visible_to_team(current_team, see_all)) {
59  return nullptr;
60  }
61  return &*u;
62 }
63 
64 /**
65  * Will return true iff the unit @a u has any possible moves
66  * it can do (including attacking etc).
67  */
68 
70 {
71  if(!u.attacks_left() && u.movement_left()==0)
72  return false;
73 
74  // Units with goto commands that have already done their gotos this turn
75  // (i.e. don't have full movement left) should have red globes.
76  if(u.has_moved() && u.has_goto()) {
77  return false;
78  }
79 
80  const team &current_team = get_team(u.side());
81 
83  get_adjacent_tiles(u.get_location(), locs.data());
84  for(unsigned n = 0; n < locs.size(); ++n) {
85  if (map().on_board(locs[n])) {
86  const unit_map::const_iterator i = units().find(locs[n]);
87  if (i.valid() && !i->incapacitated() &&
88  current_team.is_enemy(i->side())) {
89  return true;
90  }
91 
92  if (u.movement_cost(map()[locs[n]]) <= u.movement_left()) {
93  return true;
94  }
95  }
96  }
97 
98  return false;
99 }
100 
101 
102 /**
103  * Given the location of a village, will return the 0-based index
104  * of the team that currently owns it, and -1 if it is unowned.
105  */
107 {
108  const std::vector<team> & t = teams();
109  for(std::size_t i = 0; i != t.size(); ++i) {
110  if(t[i].owns_village(loc))
111  return i;
112  }
113  return -1;
114 }
115 
116 /**
117  * Determine if we are an observer, by checking if every team is not locally controlled
118  */
120 {
121  for (const team &t : teams()) {
122  if (t.is_local())
123  return false;
124  }
125 
126  return true;
127 }
128 
129 /// Static info getters previously declared at global scope in unit.?pp
130 
131 int display_context::side_units(int side) const
132 {
133  int res = 0;
134  for (const unit &u : units()) {
135  if (u.side() == side) ++res;
136  }
137  return res;
138 }
139 
141 {
142  int res = 0;
143  for (const unit &u : units()) {
144  if (u.side() == side) res += u.cost();
145  }
146  return res;
147 }
148 
149 int display_context::side_upkeep(int side) const
150 {
151  int res = 0;
152  for (const unit &u : units()) {
153  if (u.side() == side) res += u.upkeep();
154  }
155  return res;
156 }
157 
159  : side(tm.side())
160  , units(dc.side_units(side))
161  , upkeep(dc.side_upkeep(side))
162  , expenses(std::max<int>(0, upkeep - tm.support()))
163  , net_income(tm.total_income() - expenses)
164 {
165 }
int village_owner(const map_location &loc) const
Given the location of a village, will return the 0-based index of the team that currently owns it...
int attacks_left() const
Gets the remaining number of attacks this unit can perform this turn.
Definition: unit.hpp:942
const team & get_team(int side) const
void get_adjacent_tiles(const map_location &a, map_location *res)
Function which, given a location, will place all adjacent locations in res.
Definition: location.cpp:517
This class represents a single unit of a specific type.
Definition: unit.hpp:99
int movement_cost(const t_translation::terrain_code &terrain) const
Get the unit&#39;s movement cost on a particular terrain.
Definition: unit.hpp:1341
const unit * get_visible_unit(const map_location &loc, const team &current_team, bool see_all=false) const
STL namespace.
bool on_board(const map_location &loc) const
Tell if a location is on the map.
Definition: map.cpp:377
-file sdl_utils.hpp
bool unit_can_move(const unit &u) const
Will return true iff the unit u has any possible moves it can do (including attacking etc)...
virtual const gamemap & map() const =0
team_data(const display_context &dc, const team &tm)
This class stores all the data for a single &#39;side&#39; (in game nomenclature).
Definition: team.hpp:44
int side_upkeep(int side_num) const
bool is_enemy(int n) const
Definition: team.hpp:243
virtual const unit_map & units() const =0
std::array< map_location, 6 > adjacent_loc_array_t
Definition: location.hpp:170
Encapsulates the map of the game.
Definition: location.hpp:42
int side_units_cost(int side_num) const
Returns the total cost of units of side side_num.
unit_iterator find(std::size_t id)
Definition: map.cpp:311
bool invisible(const map_location &loc, bool see_all=true) const
Definition: unit.cpp:2386
bool has_moved() const
Checks if this unit has moved.
Definition: unit.hpp:1213
std::size_t i
Definition: function.cpp:933
virtual const std::vector< team > & teams() const =0
bool is_observer() const
Check if we are an observer in this game.
bool has_goto() const
Gets whether this unit has a multi-turn destination set.
Definition: unit.hpp:1283
double t
Definition: astarsearch.cpp:64
const map_location & get_location() const
The current map location this unit is at.
Definition: unit.hpp:1258
bool incapacitated() const
Check if the unit has been petrified.
Definition: unit.hpp:854
bool fogged(const map_location &loc) const
Definition: team.cpp:653
int side() const
The side this unit belongs to.
Definition: unit.hpp:303
int side_units(int side_num) const
Returns the number of units of the side side_num.
bool valid() const
Definition: map.hpp:276
static map_location::DIRECTION n
bool would_be_discovered(const map_location &loc, int side_num, bool see_all=true)
Given a location and a side number, indicates whether an invisible unit of that side at that location...
int movement_left() const
Gets how far a unit can move, considering the incapacitated flag.
Definition: unit.hpp:1183