/** * Constructor from a unit. */ clearer_info::clearer_info(const unit & viewer) : underlying_id(viewer.underlying_id()), sight_range(viewer.vision()), slowed(viewer.get_state(unit::STATE_SLOWED)), costs(viewer.movement_type().get_vision()) { }
/** * Constructs a list of jamming paths for a unit. * * This is used to construct a list of hexes that the indicated unit can jam. * It differs from pathfinding in that it will only ever go out one turn. * @param jammer The unit doing the jamming. * @param loc The location from which the jamming occurs * (does not have to be the unit's location). */ jamming_path::jamming_path(const unit& jammer, map_location const &loc) : paths() { const int jamming_range = jammer.jamming(); // The five NULL parameters indicate (in order): no edges, no teleports, // ignore units, ignore ZoC (no effect), and see all (no effect). find_routes(loc, jammer.movement_type().get_jamming(), jammer.get_state(unit::STATE_SLOWED), jamming_range, jamming_range, 0, destinations, NULL, NULL, NULL, NULL, NULL); }
/** * Constructs a list of vision paths for a unit. * * This is used to construct a list of hexes that the indicated unit can see. * It differs from pathfinding in that it will only ever go out one turn, * and that it will also collect a set of border hexes (the "one hex beyond" * movement to which vision extends). * @param viewer The unit doing the viewing. * @param loc The location from which the viewing occurs * (does not have to be the unit's location). */ vision_path::vision_path(const unit& viewer, map_location const &loc, const std::map<map_location, int>& jamming_map) : paths(), edges() { const int sight_range = viewer.vision(); // The four NULL parameters indicate (in order): no teleports, // ignore units, ignore ZoC (no effect), and see all (no effect). find_routes(loc, viewer.movement_type().get_vision(), viewer.get_state(unit::STATE_SLOWED), sight_range, sight_range, 0, destinations, &edges, NULL, NULL, NULL, NULL, &jamming_map); }
/** * Clears shroud (and fog) around the provided location for @a view_team * as if @a viewer was standing there. * This will also record sighted events, which should be either fired or * explicitly dropped. * * This should only be called if delayed shroud updates is off. * It is wasteful to call this if view_team uses neither fog nor shroud. * * @param known_units These locations are not checked for uncovered units. * @param enemy_count Incremented for each enemy uncovered (excluding known_units). * @param friend_count Incremented for each friend uncovered (excluding known_units). * @param spectator Will be told of uncovered units (excluding known_units). * @param instant If false, then drawing delays (used to make movement look better) are allowed. * * @return whether or not information was uncovered (i.e. returns true if any * locations in visual range were fogged/shrouded under shared vision/maps). */ bool shroud_clearer::clear_unit(const map_location &view_loc, const unit &viewer, team &view_team, const std::set<map_location>* known_units, std::size_t * enemy_count, std::size_t * friend_count, move_unit_spectator * spectator, bool instant) { // This is just a translation to the more general interface. It is // not inlined so that vision.hpp does not have to include unit.hpp. return clear_unit(view_loc, view_team, viewer.underlying_id(), viewer.vision(), viewer.get_state(unit::STATE_SLOWED), viewer.movement_type().get_vision(), viewer.get_location(), known_units, enemy_count, friend_count, spectator, instant); }
/** * Construct a list of paths for the specified unit. * * This function is used for several purposes, including showing a unit's * potential moves and generating currently possible paths. * @param u The unit whose moves and movement type will be used. * @param force_ignore_zoc Set to true to completely ignore zones of control. * @param allow_teleport Set to true to consider teleportation abilities. * @param viewing_team Usually the current team, except for "show enemy moves", etc. * @param additional_turns The number of turns to account for, in addition to the current. * @param see_all Set to true to remove unit visibility from consideration. * @param ignore_units Set to true if units should never obstruct paths (implies ignoring ZoC as well). */ paths::paths(const unit& u, bool force_ignore_zoc, bool allow_teleport, const team &viewing_team, int additional_turns, bool see_all, bool ignore_units) : destinations() { std::vector<team> const &teams = *resources::teams; if (u.side() < 1 || u.side() > int(teams.size())) { return; } find_routes(u.get_location(), u.movement_type().get_movement(), u.get_state(unit::STATE_SLOWED), u.movement_left(), u.total_movement(), additional_turns, destinations, NULL, allow_teleport ? &u : NULL, ignore_units ? NULL : &teams[u.side()-1], force_ignore_zoc ? NULL : &u, see_all ? NULL : &viewing_team); }