mirror of
https://github.com/wesnoth/wesnoth
synced 2025-04-21 21:16:02 +00:00
253 lines
6.4 KiB
C++
253 lines
6.4 KiB
C++
/* $Id$ */
|
|
/*
|
|
Copyright (C) 2003 by David White <davidnwhite@optusnet.com.au>
|
|
Part of the Battle for Wesnoth Project http://wesnoth.whitevine.net
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License.
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY.
|
|
|
|
See the COPYING file for more details.
|
|
*/
|
|
#ifndef DISPLAY_H_INCLUDED
|
|
#define DISPLAY_H_INCLUDED
|
|
|
|
#include "gamestatus.hpp"
|
|
#include "key.hpp"
|
|
#include "map.hpp"
|
|
#include "pathfind.hpp"
|
|
#include "team.hpp"
|
|
#include "unit.hpp"
|
|
#include "video.hpp"
|
|
|
|
#include "SDL.h"
|
|
|
|
#include <map>
|
|
#include <set>
|
|
#include <string>
|
|
|
|
class display
|
|
{
|
|
public:
|
|
typedef std::map<gamemap::location,unit> unit_map;
|
|
typedef short Pixel;
|
|
|
|
display(unit_map& units, CVideo& video,
|
|
const gamemap& map, const gamestatus& status,
|
|
const std::vector<team>& t);
|
|
~display();
|
|
|
|
Pixel rgb(int r, int g, int b) const;
|
|
|
|
void scroll(double xmov, double ymov);
|
|
void zoom(double amount);
|
|
void default_zoom();
|
|
|
|
enum SCROLL_TYPE { SCROLL, WARP };
|
|
void scroll_to_tile(int x, int y, SCROLL_TYPE scroll_type=SCROLL);
|
|
void scroll_to_tiles(int x1, int y1, int x2, int y2,
|
|
SCROLL_TYPE scroll_type=SCROLL);
|
|
|
|
void redraw_everything();
|
|
void draw(bool update=true,bool force=false);
|
|
|
|
int x() const;
|
|
int mapx() const;
|
|
int y() const;
|
|
|
|
void select_hex(gamemap::location hex);
|
|
void highlight_hex(gamemap::location hex);
|
|
gamemap::location hex_clicked_on(int x, int y);
|
|
gamemap::location minimap_location_on(int x, int y);
|
|
|
|
void set_paths(const paths* paths_list);
|
|
|
|
double get_location_x(const gamemap::location& loc) const;
|
|
double get_location_y(const gamemap::location& loc) const;
|
|
|
|
void move_unit(const std::vector<gamemap::location>& path, unit& u);
|
|
bool unit_attack(const gamemap::location& a, const gamemap::location& b,
|
|
int damage, const attack_type& attack);
|
|
void draw_tile(int x, int y, SDL_Surface* unit_image=NULL,
|
|
double alpha=1.0, short blend_to=0);
|
|
|
|
CVideo& video() { return screen_; }
|
|
|
|
enum IMAGE_TYPE { UNSCALED, SCALED, GREYED, BRIGHTENED };
|
|
SDL_Surface* getImage(const std::string& filename,IMAGE_TYPE type=SCALED);
|
|
|
|
//blits a surface with black as alpha
|
|
void blit_surface(int x, int y, SDL_Surface* surface);
|
|
|
|
void invalidate_all();
|
|
void invalidate_game_status();
|
|
void invalidate_unit();
|
|
|
|
void recalculate_minimap();
|
|
|
|
void add_overlay(const gamemap::location& loc, const std::string& image);
|
|
void remove_overlay(const gamemap::location& loc);
|
|
|
|
void draw_unit_details(int x, int y, const gamemap::location& loc,
|
|
const unit& u, SDL_Rect& description_rect, SDL_Rect& profile_rect);
|
|
|
|
void update_display();
|
|
void update_rect(const SDL_Rect& rect);
|
|
|
|
void draw_terrain_palette(int x, int y, gamemap::TERRAIN selected);
|
|
gamemap::TERRAIN get_terrain_on(int palx, int paly, int x, int y);
|
|
|
|
void set_team(int team);
|
|
|
|
void set_advancing_unit(const gamemap::location& loc, double amount);
|
|
|
|
void lock_updates(bool value);
|
|
bool update_locked() const;
|
|
|
|
bool turbo() const;
|
|
void set_turbo(bool turbo);
|
|
|
|
void set_grid(bool grid);
|
|
|
|
static void debug_highlight(const gamemap::location& loc, double amount);
|
|
static void clear_debug_highlights();
|
|
|
|
private:
|
|
display(const display&);
|
|
void operator=(const display&);
|
|
|
|
void move_unit_between(const gamemap::location& a,
|
|
const gamemap::location& b,
|
|
const unit& u);
|
|
|
|
void draw_unit(int x, int y, const SDL_Surface* image,
|
|
bool reverse, bool upside_down=false,
|
|
double alpha=1.0, short blendto=0);
|
|
|
|
void unit_die(const gamemap::location& loc, SDL_Surface* image=NULL);
|
|
|
|
bool unit_attack_ranged(const gamemap::location& a,
|
|
const gamemap::location& b,
|
|
int damage, const attack_type& attack);
|
|
|
|
void draw_sidebar();
|
|
SDL_Rect get_minimap_location(int x, int y, int w, int h);
|
|
void draw_minimap(int x, int y, int w, int h);
|
|
void draw_game_status(int x, int y);
|
|
|
|
SDL_Rect gameStatusRect_;
|
|
SDL_Rect unitDescriptionRect_;
|
|
SDL_Rect unitProfileRect_;
|
|
|
|
int lastTimeOfDay_;
|
|
|
|
void bounds_check_position();
|
|
|
|
std::vector<SDL_Surface*> getAdjacentTerrain(int x, int y, IMAGE_TYPE type);
|
|
SDL_Surface* getTerrain(gamemap::TERRAIN, IMAGE_TYPE type,
|
|
int x, int y, const std::string& dir="");
|
|
|
|
enum TINT { GREY_IMAGE, BRIGHTEN_IMAGE };
|
|
SDL_Surface* getImageTinted(const std::string& filename, TINT tint);
|
|
SDL_Surface* getMinimap(int w, int h);
|
|
|
|
void clearImageCache();
|
|
|
|
CVideo& screen_;
|
|
mutable CKey keys_;
|
|
double xpos_, ypos_, zoom_;
|
|
const gamemap& map_;
|
|
|
|
gamemap::location selectedHex_;
|
|
gamemap::location mouseoverHex_;
|
|
|
|
unit_map& units_;
|
|
|
|
std::map<std::string,SDL_Surface*> images_, scaledImages_,
|
|
greyedImages_, brightenedImages_;
|
|
|
|
//function which finds the start and end rows on the energy bar image
|
|
//where white pixels are substituted for the colour of the energy
|
|
const std::pair<int,int>& calculate_energy_bar();
|
|
std::pair<int,int> energy_bar_count_;
|
|
|
|
SDL_Surface* minimap_;
|
|
bool minimapDecorationsDrawn_;
|
|
|
|
const paths* pathsList_;
|
|
|
|
const gamestatus& status_;
|
|
|
|
const std::vector<team>& teams_;
|
|
|
|
int lastDraw_;
|
|
int drawSkips_;
|
|
|
|
void invalidate(const gamemap::location& loc);
|
|
|
|
std::set<gamemap::location> invalidated_;
|
|
bool invalidateAll_;
|
|
bool invalidateUnit_;
|
|
bool invalidateGameStatus_;
|
|
|
|
std::multimap<gamemap::location,std::string> overlays_;
|
|
|
|
void update_whole_screen();
|
|
void update_map_area();
|
|
void update_side_bar();
|
|
std::vector<SDL_Rect> updateRects_;
|
|
|
|
bool sideBarBgDrawn_;
|
|
|
|
int currentTeam_;
|
|
|
|
//used to store a unit that is not drawn, because it's currently
|
|
//being moved or otherwise changed
|
|
gamemap::location hiddenUnit_;
|
|
|
|
//used to store any unit that is currently being hit
|
|
gamemap::location hitUnit_;
|
|
|
|
//used to store any unit that is dying
|
|
gamemap::location deadUnit_;
|
|
double deadAmount_;
|
|
|
|
//used to store any unit that is advancing
|
|
gamemap::location advancingUnit_;
|
|
double advancingAmount_;
|
|
|
|
int updatesLocked_;
|
|
|
|
bool turbo_, grid_;
|
|
|
|
//for debug mode
|
|
static std::map<gamemap::location,double> debugHighlights_;
|
|
};
|
|
|
|
struct update_locker
|
|
{
|
|
update_locker(display& d, bool lock=true) : disp(d), unlock(lock) {
|
|
if(lock) {
|
|
disp.lock_updates(true);
|
|
}
|
|
}
|
|
|
|
~update_locker() {
|
|
unlock_update();
|
|
}
|
|
|
|
void unlock_update() {
|
|
if(unlock) {
|
|
disp.lock_updates(false);
|
|
unlock = false;
|
|
}
|
|
}
|
|
|
|
private:
|
|
display& disp;
|
|
bool unlock;
|
|
};
|
|
|
|
#endif
|