* basic in-game console

CAdvmapInterface.cpp

@@ -1387,6 +1387,8 @@ void CAdvMapInt::activate()
 	terrain.activate();
 	KeyInterested::activate();
 	show();
+
+	LOCPLINT->cingconsole->activate();
 }
 void CAdvMapInt::deactivate()
 {
@@ -1397,6 +1399,8 @@ void CAdvMapInt::deactivate()
 	}
 	KeyInterested::deactivate();
 	hide();
+
+	LOCPLINT->cingconsole->deactivate();
 }
 void CAdvMapInt::show(SDL_Surface *to)
 {
@@ -1424,6 +1428,7 @@ void CAdvMapInt::show(SDL_Surface *to)
 	statusbar.show();
 
 	infoBar.draw();
+	LOCPLINT->cingconsole->show();
 }
 void CAdvMapInt::hide()
 {
@@ -1491,7 +1496,8 @@ void CAdvMapInt::update()
 		terrain.show();
 		for(int i=0;i<4;i++)
 			blitAt(gems[i]->ourImages[LOCPLINT->playerID].bitmap,ADVOPT.gemX[i],ADVOPT.gemY[i]);
-		updateScreen=false;
+		updateScreen=false;	
+		LOCPLINT->cingconsole->show();
 	}
 	if (updateMinimap)
 	{

CBattleInterface.cpp

@@ -350,6 +350,8 @@ void CBattleInterface::activate()
 		attackingHero->activate();
 	if(defendingHero)
 		defendingHero->activate();
+
+	LOCPLINT->cingconsole->activate();
 }
 
 void CBattleInterface::deactivate()
@@ -373,6 +375,8 @@ void CBattleInterface::deactivate()
 		attackingHero->deactivate();
 	if(defendingHero)
 		defendingHero->deactivate();
+
+	LOCPLINT->cingconsole->deactivate();
 }
 
 void CBattleInterface::show(SDL_Surface * to)
@@ -655,6 +659,8 @@ void CBattleInterface::show(SDL_Surface * to)
 		resWindow->show(to);
 	}
 
+	//showing in-gmae console
+	LOCPLINT->cingconsole->show();
 
 	//printing border around interface
 	if(screen->w != 800 || screen->h !=600)
@@ -2454,7 +2460,11 @@ CBattleConsole::~CBattleConsole()
 
 void CBattleConsole::show(SDL_Surface * to)
 {
-	if(alterTxt.size())
+	if(ingcAlter.size())
+	{
+		CSDL_Ext::printAtMiddleWB(ingcAlter, pos.x + pos.w/2, pos.y + 10, GEOR13, 80, zwykly, to);
+	}
+	else if(alterTxt.size())
 	{
 		CSDL_Ext::printAtMiddleWB(alterTxt, pos.x + pos.w/2, pos.y + 10, GEOR13, 80, zwykly, to);
 	}

CBattleInterface.h

@@ -1,287 +1,289 @@
-#ifndef __CBATTLEINTERFACE_H__
+#ifndef __CBATTLEINTERFACE_H__
-#define __CBATTLEINTERFACE_H__
+#define __CBATTLEINTERFACE_H__
-
-#include "global.h"
-#include "CPlayerInterface.h"
-#include <list>
-
-class CCreatureSet;
-class CGHeroInstance;
-class CDefHandler;
-class CStack;
-class CCallback;
-class AdventureMapButton;
-class CHighlightableButton;
-class CHighlightableButtonsGroup;
-struct BattleResult;
-struct SpellCasted;
-template <typename T> struct CondSh;
-
-class CBattleInterface;
-
-class CBattleHero : public IShowable, public ClickableL
-{
-public:
-	bool flip; //false if it's attacking hero, true otherwise
-	CDefHandler * dh, *flag; //animation and flag
-	const CGHeroInstance * myHero; //this animation's hero instance
-	const CBattleInterface * myOwner; //battle interface to which this animation is assigned
-	int phase; //stage of animation
-	int nextPhase; //stage of animation to be set after current phase is fully displayed
-	int image; //frame of animation
-	unsigned char flagAnim, flagAnimCount; //for flag animation
-	void show(SDL_Surface * to); //prints next frame of animation to to
-	void activate();
-	void deactivate();
-	void setPhase(int newPhase); //sets phase of hero animation
-	void clickLeft(boost::logic::tribool down); //call-in
-	CBattleHero(const std::string & defName, int phaseG, int imageG, bool filpG, unsigned char player, const CGHeroInstance * hero, const CBattleInterface * owner); //c-tor
-	~CBattleHero(); //d-tor
-};
-
-class CBattleHex : public Hoverable, public MotionInterested, public ClickableL, public ClickableR
-{
-private:
-	bool setAlterText; //if true, this hex has set alternative text in console and will clean it
-public:
-	unsigned int myNumber; //number of hex in commonly used format
-	bool accesible; //if true, this hex is accessible for units
-	//CStack * ourStack;
-	bool hovered, strictHovered; //for determining if hex is hovered by mouse (this is different problem than hex's graphic hovering)
-	CBattleInterface * myInterface; //interface that owns me
-	static std::pair<int, int> getXYUnitAnim(const int & hexNum, const bool & attacker, const CCreature * creature); //returns (x, y) of left top corner of animation
-	//for user interactions
-	void hover (bool on);
-	void activate();
-	void deactivate();
-	void mouseMoved (const SDL_MouseMotionEvent & sEvent);
-	void clickLeft(boost::logic::tribool down);
-	void clickRight(boost::logic::tribool down);
-	CBattleHex();
-};
-
-class CBattleObstacle
-{
-	std::vector<int> lockedHexes;
-};
-
-class CBattleConsole : public IShowable, public CIntObject
-{
-private:
-	std::vector< std::string > texts; //a place where texts are stored
-	int lastShown; //last shown line of text
-public:
-	std::string alterTxt; //if it's not empty, this text is displayed
-	int whoSetAlter; //who set alter text; 0 - battle interface or none, 1 - button
-	CBattleConsole(); //c-tor
-	~CBattleConsole(); //d-tor
-	void show(SDL_Surface * to = 0);
-	bool addText(const std::string & text); //adds text at the last position; returns false if failed (e.g. text longer than 70 characters)
-	void eraseText(unsigned int pos); //erases added text at position pos
-	void changeTextAt(const std::string & text, unsigned int pos); //if we have more than pos texts, pos-th is changed to given one
-	void scrollUp(unsigned int by = 1); //scrolls console up by 'by' positions
-	void scrollDown(unsigned int by = 1); //scrolls console up by 'by' positions
-};
-
-class CBattleReslutWindow : public IShowable, public CIntObject, public IActivable
-{
-private:
-	SDL_Surface * background;
-	AdventureMapButton * exit;
-public:
-	CBattleReslutWindow(const BattleResult & br, const SDL_Rect & pos, const CBattleInterface * owner); //c-tor
-	~CBattleReslutWindow(); //d-tor
-
-	void bExitf(); //exit button callback
-
-	void activate();
-	void deactivate();
-	void show(SDL_Surface * to = 0);
-};
-
-class CBattleOptionsWindow : public IShowable, public CIntObject, public IActivable
-{
-private:
-	CBattleInterface * myInt;
-	SDL_Surface * background;
-	AdventureMapButton * setToDefault, * exit;
-	CHighlightableButton * viewGrid, * movementShadow, * mouseShadow;
-	CHighlightableButtonsGroup * animSpeeds;
-public:
-	CBattleOptionsWindow(const SDL_Rect & position, CBattleInterface * owner); //c-tor
-	~CBattleOptionsWindow(); //d-tor
-
-	void bDefaultf(); //dafault button callback
-	void bExitf(); //exit button callback
-
-	void activate();
-	void deactivate();
-	void show(SDL_Surface * to = 0);
-};
-
-struct BattleSettings
-{
-	BattleSettings()
-	{
-		printCellBorders = true;
-		printStackRange = true;
-		animSpeed = 2;
-		printMouseShadow = true;
-	}
-	bool printCellBorders; //if true, cell borders will be printed
-	bool printStackRange; //if true,range of active stack will be printed
-	int animSpeed; //speed of animation; 1 - slowest, 2 - medium, 4 - fastest
-	bool printMouseShadow; //if true, hex under mouse will be shaded
-
 
-	template <typename Handler> void serialize(Handler &h, const int version)
+#include "global.h"
-	{
+#include "CPlayerInterface.h"
-		h & printCellBorders & printStackRange & printMouseShadow;
+#include <list>
-	}
+
-};
+class CCreatureSet;
-
+class CGHeroInstance;
-class CBattleInterface : public CMainInterface, public MotionInterested, public KeyInterested
+class CDefHandler;
-{
+class CStack;
-private:
+class CCallback;
-	SDL_Surface * background, * menu, * amountNormal, * amountNegative, * amountPositive, * amountEffNeutral, * cellBorders, * backgroundWithHexes;
+class AdventureMapButton;
-	AdventureMapButton * bOptions, * bSurrender, * bFlee, * bAutofight, * bSpell,
+class CHighlightableButton;
-		* bWait, * bDefence, * bConsoleUp, * bConsoleDown;
+class CHighlightableButtonsGroup;
-	CBattleConsole * console;
+struct BattleResult;
-	CBattleHero * attackingHero, * defendingHero; //fighting heroes
+struct SpellCasted;
-	CCreatureSet * army1, * army2; //fighting armies
+template <typename T> struct CondSh;
-	CGHeroInstance * attackingHeroInstance, * defendingHeroInstance;
+
-	std::map< int, CCreatureAnimation * > creAnims; //animations of creatures from fighting armies (order by BattleInfo's stacks' ID)
+class CBattleInterface;
-	std::map< int, CDefHandler * > idToProjectile; //projectiles of creaures (creatureID, defhandler)
+
-	std::map< int, CDefHandler * > idToObstacle; //obstacles located on the battlefield
+class CBattleHero : public IShowable, public ClickableL
-	std::map< int, bool > creDir; // <creatureID, if false reverse creature's animation>
+{
-	std::map< int, int > spellToEffect; //which effect should be played when different spells are casted (spellID, effectID)
+public:
-	unsigned char animCount;
+	bool flip; //false if it's attacking hero, true otherwise
-	int activeStack; //number of active stack; -1 - no one
+	CDefHandler * dh, *flag; //animation and flag
-	int mouseHoveredStack; //stack hovered by mouse; if -1 -> none
+	const CGHeroInstance * myHero; //this animation's hero instance
-	std::vector<int> shadedHexes; //hexes available for active stack
+	const CBattleInterface * myOwner; //battle interface to which this animation is assigned
-	int previouslyHoveredHex; //number of hex that was hovered by the cursor a while ago
+	int phase; //stage of animation
-	int currentlyHoveredHex; //number of hex that is supposed to be hovered (for a while it may be inappropriately set, but will be renewed soon)
+	int nextPhase; //stage of animation to be set after current phase is fully displayed
-	float getAnimSpeedMultiplier() const; //returns multiplier for number of frames in a group
+	int image; //frame of animation
-	std::map<int, int> standingFrame; //number of frame in standing animation by stack ID, helps in showing 'random moves'
+	unsigned char flagAnim, flagAnimCount; //for flag animation
-
+	void show(SDL_Surface * to); //prints next frame of animation to to
-	bool spellDestSelectMode; //if true, player is choosing destination for his spell
+	void activate();
-	int spellSelMode; //0 - any location, 1 - any firendly creature, 2 - any hostile creature, 3 - any creature, 4 - obstacle, -1 - no location
+	void deactivate();
-	BattleAction * spellToCast; //spell for which player is choosing destination
+	void setPhase(int newPhase); //sets phase of hero animation
-
+	void clickLeft(boost::logic::tribool down); //call-in
-	class CAttHelper
+	CBattleHero(const std::string & defName, int phaseG, int imageG, bool filpG, unsigned char player, const CGHeroInstance * hero, const CBattleInterface * owner); //c-tor
-	{
+	~CBattleHero(); //d-tor
-	public:
+};
-		int ID; //attacking stack
+
-		int IDby; //attacked stack
+class CBattleHex : public Hoverable, public MotionInterested, public ClickableL, public ClickableR
-		int dest; //atacked hex
+{
-		int frame, maxframe; //frame of animation, number of frames of animation
+private:
-		int hitCount; //for delaying animation
+	bool setAlterText; //if true, this hex has set alternative text in console and will clean it
-		bool reversing;
+public:
-		int posShiftDueToDist;
+	unsigned int myNumber; //number of hex in commonly used format
-		bool shooting;
+	bool accesible; //if true, this hex is accessible for units
-		int shootingGroup; //if shooting is true, print this animation group
+	//CStack * ourStack;
-	} * attackingInfo;
+	bool hovered, strictHovered; //for determining if hex is hovered by mouse (this is different problem than hex's graphic hovering)
-	void attackingShowHelper();
+	CBattleInterface * myInterface; //interface that owns me
-	void redrawBackgroundWithHexes(int activeStack);
+	static std::pair<int, int> getXYUnitAnim(const int & hexNum, const bool & attacker, const CCreature * creature); //returns (x, y) of left top corner of animation
-	void printConsoleAttacked(int ID, int dmg, int killed, int IDby);
+	//for user interactions
-
+	void hover (bool on);
-	struct SProjectileInfo
+	void activate();
-	{
+	void deactivate();
-		int x, y; //position on the screen
+	void mouseMoved (const SDL_MouseMotionEvent & sEvent);
-		int dx, dy; //change in position in one step
+	void clickLeft(boost::logic::tribool down);
-		int step, lastStep; //to know when finish showing this projectile
+	void clickRight(boost::logic::tribool down);
-		int creID; //ID of creature that shot this projectile
+	CBattleHex();
-		int frameNum; //frame to display form projectile animation
+};
-		bool spin; //if true, frameNum will be increased
+
-		int animStartDelay; //how many times projectile must be attempted to be shown till it's really show (decremented after hit)
+class CBattleObstacle
-		bool reverse; //if true, projectile will be flipped by vertical asix
+{
-	};
+	std::vector<int> lockedHexes;
-	std::list<SProjectileInfo> projectiles; //projectiles flying on battlefield
+};
-	void projectileShowHelper(SDL_Surface * to=NULL); //prints projectiles present on the battlefield
+
-	void giveCommand(ui8 action, ui16 tile, ui32 stack, si32 additional=-1);
+class CBattleConsole : public IShowable, public CIntObject
-	bool isTileAttackable(const int & number) const; //returns true if tile 'number' is neighbouring any tile from active stack's range or is one of these tiles
+{
-
+private:
-	struct SBattleEffect
+	std::vector< std::string > texts; //a place where texts are stored
-	{
+	int lastShown; //last shown line of text
-		int x, y; //position on the screen
+public:
-		int frame, maxFrame;
+	std::string alterTxt; //if it's not empty, this text is displayed
-		CDefHandler * anim; //animation to display
+	std::string ingcAlter; //alternative text set by in-game console - very important!
-	};
+	int whoSetAlter; //who set alter text; 0 - battle interface or none, 1 - button
-	std::list<SBattleEffect> battleEffects; //different animations to display on the screen like spell effects
+	CBattleConsole(); //c-tor
-public:
+	~CBattleConsole(); //d-tor
-	CBattleInterface(CCreatureSet * army1, CCreatureSet * army2, CGHeroInstance *hero1, CGHeroInstance *hero2, const SDL_Rect & myRect); //c-tor
+	void show(SDL_Surface * to = 0);
-	~CBattleInterface(); //d-tor
+	bool addText(const std::string & text); //adds text at the last position; returns false if failed (e.g. text longer than 70 characters)
-
+	void eraseText(unsigned int pos); //erases added text at position pos
-	//std::vector<TimeInterested*> timeinterested; //animation handling
+	void changeTextAt(const std::string & text, unsigned int pos); //if we have more than pos texts, pos-th is changed to given one
-	static BattleSettings settings;
+	void scrollUp(unsigned int by = 1); //scrolls console up by 'by' positions
-	void setPrintCellBorders(bool set); //if true, cell borders will be printed
+	void scrollDown(unsigned int by = 1); //scrolls console up by 'by' positions
-	void setPrintStackRange(bool set); //if true,range of active stack will be printed
+};
-	void setPrintMouseShadow(bool set); //if true, hex under mouse will be shaded
+
-	void setAnimSpeed(int set); //speed of animation; 1 - slowest, 2 - medium, 4 - fastest
+class CBattleReslutWindow : public IShowable, public CIntObject, public IActivable
-	int getAnimSpeed() const; //speed of animation; 1 - slowest, 2 - medium, 4 - fastest
+{
-
+private:
-	CBattleHex bfield[BFIELD_SIZE]; //11 lines, 17 hexes on each
+	SDL_Surface * background;
-	std::vector< CBattleObstacle * > obstacles; //vector of obstacles on the battlefield
+	AdventureMapButton * exit;
-	SDL_Surface * cellBorder, * cellShade;
+public:
-	CondSh<BattleAction *> *givenCommand; //data != NULL if we have i.e. moved current unit
+	CBattleReslutWindow(const BattleResult & br, const SDL_Rect & pos, const CBattleInterface * owner); //c-tor
-	bool myTurn; //if true, interface is active (commands can be ordered
+	~CBattleReslutWindow(); //d-tor
-	CBattleReslutWindow * resWindow; //window of end of battle
+
-	bool showStackQueue; //if true, queue of stacks will be shown
+	void bExitf(); //exit button callback
-
+
-	bool moveStarted; //if true, the creature that is already moving is going to make its first step
+	void activate();
-
+	void deactivate();
-	//button handle funcs:
+	void show(SDL_Surface * to = 0);
-	void bOptionsf();
+};
-	void bSurrenderf();
+
-	void bFleef();
+class CBattleOptionsWindow : public IShowable, public CIntObject, public IActivable
-	void reallyFlee(); //performs fleeing without asking player
+{
-	void bAutofightf();
+private:
-	void bSpellf();
+	CBattleInterface * myInt;
-	void bWaitf();
+	SDL_Surface * background;
-	void bDefencef();
+	AdventureMapButton * setToDefault, * exit;
-	void bConsoleUpf();
+	CHighlightableButton * viewGrid, * movementShadow, * mouseShadow;
-	void bConsoleDownf();
+	CHighlightableButtonsGroup * animSpeeds;
-	//end of button handle funcs
+public:
-	//napisz tu klase odpowiadajaca za wyswietlanie bitwy i obsluge uzytkownika, polecenia ma przekazywac callbackiem
+	CBattleOptionsWindow(const SDL_Rect & position, CBattleInterface * owner); //c-tor
-	void activate();
+	~CBattleOptionsWindow(); //d-tor
-	void deactivate();
+
-	void show(SDL_Surface * to = NULL);
+	void bDefaultf(); //dafault button callback
-	void keyPressed(const SDL_KeyboardEvent & key);
+	void bExitf(); //exit button callback
-	void mouseMoved(const SDL_MouseMotionEvent &sEvent);
+
-	bool reverseCreature(int number, int hex, bool wideTrick = false); //reverses animation of given creature playing animation of reversing
+	void activate();
-	void handleStartMoving(int number); //animation of starting move; some units don't have this animation (ie. halberdier)
+	void deactivate();
-
+	void show(SDL_Surface * to = 0);
-	struct SStackAttackedInfo
+};
-	{
+
-		int ID; //id of attacked stack
+struct BattleSettings
-		int dmg; //damage dealt
+{
-		int amountKilled; //how many creatures in stack has been killed
+	BattleSettings()
-		int IDby; //ID of attacking stack
+	{
-		bool byShooting; //if true, stack has been attacked by shooting
+		printCellBorders = true;
-		bool killed; //if true, stack has been killed
+		printStackRange = true;
-	};
+		animSpeed = 2;
-
+		printMouseShadow = true;
-	//call-ins
+	}
-	void newStack(CStack stack); //new stack appeared on battlefield
+	bool printCellBorders; //if true, cell borders will be printed
-	void stackRemoved(CStack stack); //stack disappeared from batlefiled
+	bool printStackRange; //if true,range of active stack will be printed
-	//void stackKilled(int ID, int dmg, int killed, int IDby, bool byShooting); //stack has been killed (but corpses remain)
+	int animSpeed; //speed of animation; 1 - slowest, 2 - medium, 4 - fastest
-	void stackActivated(int number); //active stack has been changed
+	bool printMouseShadow; //if true, hex under mouse will be shaded
-	void stackMoved(int number, int destHex, bool endMoving, int distance); //stack with id number moved to destHex
+
-	void stacksAreAttacked(std::vector<SStackAttackedInfo> attackedInfos); //called when a certain amount of stacks has been attacked
+
-	void stackAttacking(int ID, int dest); //called when stack with id ID is attacking something on hex dest
+	template <typename Handler> void serialize(Handler &h, const int version)
-	void newRound(int number); //caled when round is ended; number is the number of round
+	{
-	void hexLclicked(int whichOne); //hex only call-in
+		h & printCellBorders & printStackRange & printMouseShadow;
-	void stackIsShooting(int ID, int dest); //called when stack with id ID is shooting to hex dest
+	}
-	void battleFinished(const BattleResult& br); //called when battle is finished - battleresult window should be printed
+};
-	void spellCasted(SpellCasted * sc); //called when a hero casts a spell
+
-	void battleStacksEffectsSet(const SetStackEffect & sse); //called when a specific effect is set to stacks
+class CBattleInterface : public CMainInterface, public MotionInterested, public KeyInterested
-	void castThisSpell(int spellID); //called when player has chosen a spell from spellbook
+{
-	void displayEffect(ui32 effect, int destTile); //displays effect of a spell on the battlefield; affected: true - attacker. false - defender
+private:
-
+	SDL_Surface * background, * menu, * amountNormal, * amountNegative, * amountPositive, * amountEffNeutral, * cellBorders, * backgroundWithHexes;
-	friend class CBattleHex;
+	AdventureMapButton * bOptions, * bSurrender, * bFlee, * bAutofight, * bSpell,
-	friend class CBattleReslutWindow;
+		* bWait, * bDefence, * bConsoleUp, * bConsoleDown;
-	friend class CPlayerInterface;
+	CBattleConsole * console;
-	friend class AdventureMapButton;
+	CBattleHero * attackingHero, * defendingHero; //fighting heroes
-};
+	CCreatureSet * army1, * army2; //fighting armies
-
+	CGHeroInstance * attackingHeroInstance, * defendingHeroInstance;
-#endif // __CBATTLEINTERFACE_H__
+	std::map< int, CCreatureAnimation * > creAnims; //animations of creatures from fighting armies (order by BattleInfo's stacks' ID)
+	std::map< int, CDefHandler * > idToProjectile; //projectiles of creaures (creatureID, defhandler)
+	std::map< int, CDefHandler * > idToObstacle; //obstacles located on the battlefield
+	std::map< int, bool > creDir; // <creatureID, if false reverse creature's animation>
+	std::map< int, int > spellToEffect; //which effect should be played when different spells are casted (spellID, effectID)
+	unsigned char animCount;
+	int activeStack; //number of active stack; -1 - no one
+	int mouseHoveredStack; //stack hovered by mouse; if -1 -> none
+	std::vector<int> shadedHexes; //hexes available for active stack
+	int previouslyHoveredHex; //number of hex that was hovered by the cursor a while ago
+	int currentlyHoveredHex; //number of hex that is supposed to be hovered (for a while it may be inappropriately set, but will be renewed soon)
+	float getAnimSpeedMultiplier() const; //returns multiplier for number of frames in a group
+	std::map<int, int> standingFrame; //number of frame in standing animation by stack ID, helps in showing 'random moves'
+
+	bool spellDestSelectMode; //if true, player is choosing destination for his spell
+	int spellSelMode; //0 - any location, 1 - any firendly creature, 2 - any hostile creature, 3 - any creature, 4 - obstacle, -1 - no location
+	BattleAction * spellToCast; //spell for which player is choosing destination
+
+	class CAttHelper
+	{
+	public:
+		int ID; //attacking stack
+		int IDby; //attacked stack
+		int dest; //atacked hex
+		int frame, maxframe; //frame of animation, number of frames of animation
+		int hitCount; //for delaying animation
+		bool reversing;
+		int posShiftDueToDist;
+		bool shooting;
+		int shootingGroup; //if shooting is true, print this animation group
+	} * attackingInfo;
+	void attackingShowHelper();
+	void redrawBackgroundWithHexes(int activeStack);
+	void printConsoleAttacked(int ID, int dmg, int killed, int IDby);
+
+	struct SProjectileInfo
+	{
+		int x, y; //position on the screen
+		int dx, dy; //change in position in one step
+		int step, lastStep; //to know when finish showing this projectile
+		int creID; //ID of creature that shot this projectile
+		int frameNum; //frame to display form projectile animation
+		bool spin; //if true, frameNum will be increased
+		int animStartDelay; //how many times projectile must be attempted to be shown till it's really show (decremented after hit)
+		bool reverse; //if true, projectile will be flipped by vertical asix
+	};
+	std::list<SProjectileInfo> projectiles; //projectiles flying on battlefield
+	void projectileShowHelper(SDL_Surface * to=NULL); //prints projectiles present on the battlefield
+	void giveCommand(ui8 action, ui16 tile, ui32 stack, si32 additional=-1);
+	bool isTileAttackable(const int & number) const; //returns true if tile 'number' is neighbouring any tile from active stack's range or is one of these tiles
+
+	struct SBattleEffect
+	{
+		int x, y; //position on the screen
+		int frame, maxFrame;
+		CDefHandler * anim; //animation to display
+	};
+	std::list<SBattleEffect> battleEffects; //different animations to display on the screen like spell effects
+public:
+	CBattleInterface(CCreatureSet * army1, CCreatureSet * army2, CGHeroInstance *hero1, CGHeroInstance *hero2, const SDL_Rect & myRect); //c-tor
+	~CBattleInterface(); //d-tor
+
+	//std::vector<TimeInterested*> timeinterested; //animation handling
+	static BattleSettings settings;
+	void setPrintCellBorders(bool set); //if true, cell borders will be printed
+	void setPrintStackRange(bool set); //if true,range of active stack will be printed
+	void setPrintMouseShadow(bool set); //if true, hex under mouse will be shaded
+	void setAnimSpeed(int set); //speed of animation; 1 - slowest, 2 - medium, 4 - fastest
+	int getAnimSpeed() const; //speed of animation; 1 - slowest, 2 - medium, 4 - fastest
+
+	CBattleHex bfield[BFIELD_SIZE]; //11 lines, 17 hexes on each
+	std::vector< CBattleObstacle * > obstacles; //vector of obstacles on the battlefield
+	SDL_Surface * cellBorder, * cellShade;
+	CondSh<BattleAction *> *givenCommand; //data != NULL if we have i.e. moved current unit
+	bool myTurn; //if true, interface is active (commands can be ordered
+	CBattleReslutWindow * resWindow; //window of end of battle
+	bool showStackQueue; //if true, queue of stacks will be shown
+
+	bool moveStarted; //if true, the creature that is already moving is going to make its first step
+
+	//button handle funcs:
+	void bOptionsf();
+	void bSurrenderf();
+	void bFleef();
+	void reallyFlee(); //performs fleeing without asking player
+	void bAutofightf();
+	void bSpellf();
+	void bWaitf();
+	void bDefencef();
+	void bConsoleUpf();
+	void bConsoleDownf();
+	//end of button handle funcs
+	//napisz tu klase odpowiadajaca za wyswietlanie bitwy i obsluge uzytkownika, polecenia ma przekazywac callbackiem
+	void activate();
+	void deactivate();
+	void show(SDL_Surface * to = NULL);
+	void keyPressed(const SDL_KeyboardEvent & key);
+	void mouseMoved(const SDL_MouseMotionEvent &sEvent);
+	bool reverseCreature(int number, int hex, bool wideTrick = false); //reverses animation of given creature playing animation of reversing
+	void handleStartMoving(int number); //animation of starting move; some units don't have this animation (ie. halberdier)
+
+	struct SStackAttackedInfo
+	{
+		int ID; //id of attacked stack
+		int dmg; //damage dealt
+		int amountKilled; //how many creatures in stack has been killed
+		int IDby; //ID of attacking stack
+		bool byShooting; //if true, stack has been attacked by shooting
+		bool killed; //if true, stack has been killed
+	};
+
+	//call-ins
+	void newStack(CStack stack); //new stack appeared on battlefield
+	void stackRemoved(CStack stack); //stack disappeared from batlefiled
+	//void stackKilled(int ID, int dmg, int killed, int IDby, bool byShooting); //stack has been killed (but corpses remain)
+	void stackActivated(int number); //active stack has been changed
+	void stackMoved(int number, int destHex, bool endMoving, int distance); //stack with id number moved to destHex
+	void stacksAreAttacked(std::vector<SStackAttackedInfo> attackedInfos); //called when a certain amount of stacks has been attacked
+	void stackAttacking(int ID, int dest); //called when stack with id ID is attacking something on hex dest
+	void newRound(int number); //caled when round is ended; number is the number of round
+	void hexLclicked(int whichOne); //hex only call-in
+	void stackIsShooting(int ID, int dest); //called when stack with id ID is shooting to hex dest
+	void battleFinished(const BattleResult& br); //called when battle is finished - battleresult window should be printed
+	void spellCasted(SpellCasted * sc); //called when a hero casts a spell
+	void battleStacksEffectsSet(const SetStackEffect & sse); //called when a specific effect is set to stacks
+	void castThisSpell(int spellID); //called when player has chosen a spell from spellbook
+	void displayEffect(ui32 effect, int destTile); //displays effect of a spell on the battlefield; affected: true - attacker. false - defender
+
+	friend class CBattleHex;
+	friend class CBattleReslutWindow;
+	friend class CPlayerInterface;
+	friend class AdventureMapButton;
+	friend class CInGameConsole;
+};
+
+#endif // __CBATTLEINTERFACE_H__

CMT.cpp

@@ -79,6 +79,7 @@ int main(int argc, char** argv)
 	CGameInfo * cgi = CGI = new CGameInfo; //contains all global informations about game (texts, lodHandlers, map handler itp.)
 	if(SDL_Init(SDL_INIT_VIDEO|SDL_INIT_TIMER|SDL_INIT_AUDIO)==0)
 	{
+		SDL_EnableUNICODE(1);
 		screen = SDL_SetVideoMode(800,600,conf.cc.bpp,SDL_SWSURFACE|SDL_DOUBLEBUF|(conf.cc.fullscreen?SDL_FULLSCREEN:0));  //initializing important global surface
 		tlog0 <<"\tInitializing screen: "<<pomtime.getDif();
 			tlog0 << std::endl;

CPlayerInterface.cpp

@@ -1099,6 +1099,7 @@ CPlayerInterface::CPlayerInterface(int Player, int serial)
 	SDL_initFramerate(mainFPSmng);
 	SDL_setFramerate(mainFPSmng, 48);
 	//framerate keeper initialized
+	cingconsole = new CInGameConsole;
 }
 CPlayerInterface::~CPlayerInterface()
 {
@@ -1106,6 +1107,7 @@ CPlayerInterface::~CPlayerInterface()
 	delete showingDialog;
 	delete mainFPSmng;
 	delete adventureInt;
+	delete cingconsole;
 
 	for(std::map<int,SDL_Surface*>::iterator i=graphics->heroWins.begin(); i!= graphics->heroWins.end(); i++)
 		SDL_FreeSurface(i->second);
@@ -1911,9 +1913,19 @@ void CPlayerInterface::handleEvent(SDL_Event *sEvent)
 			key.keysym.sym = (SDLKey)SDLK_RETURN;
 		}
 
+		bool keysCaptured = false;
+		for(std::list<KeyInterested*>::iterator i=keyinterested.begin(); i != keyinterested.end();i++)
+		{
+			if((*i)->captureAllKeys)
+			{
+				keysCaptured = true;
+				break;
+			}
+		}
+
 		std::list<KeyInterested*> miCopy = keyinterested;
 		for(std::list<KeyInterested*>::iterator i=miCopy.begin(); i != miCopy.end();i++)
-			if(vstd::contains(keyinterested,*i))
+			if(vstd::contains(keyinterested,*i) && (!keysCaptured || (*i)->captureAllKeys))
 				(**i).keyPressed(key);
 	}
 	else if(sEvent->type==SDL_MOUSEMOTION)
@@ -2605,16 +2617,19 @@ CStatusBar::~CStatusBar()
 }
 void CStatusBar::clear()
 {
-	current="";
+	if(LOCPLINT->cingconsole->enteredText == "") //for appropriate support for in-game console
-	SDL_Rect pom = genRect(pos.h,pos.w,pos.x,pos.y);
+	{
-	SDL_BlitSurface(bg,&genRect(pos.h,pos.w,0,0),screen,&pom);
+		current="";
+		show();
+	}
 }
 void CStatusBar::print(const std::string & text)
 {
-	current=text;
+	if(LOCPLINT->cingconsole->enteredText == "" || text == LOCPLINT->cingconsole->enteredText) //for appropriate support for in-game console
-	SDL_Rect pom = genRect(pos.h,pos.w,pos.x,pos.y);
+	{
-	SDL_BlitSurface(bg,&genRect(pos.h,pos.w,0,0),screen,&pom);
+		current=text;
-	printAtMiddle(current,middlex,middley,GEOR13,zwykly);
+		show();
+	}
 }
 void CStatusBar::show()
 {
@@ -4570,4 +4585,132 @@ void CTavernWindow::HeroPortrait::hover( bool on )
 		LOCPLINT->statusbar->print(hoverName);
 	else
 		LOCPLINT->statusbar->clear();
-}
+}
+
+void CInGameConsole::activate()
+{
+	KeyInterested::activate();
+}
+
+void CInGameConsole::deactivate()
+{
+	KeyInterested::deactivate();
+}
+
+void CInGameConsole::show(SDL_Surface * to)
+{
+	int number = 0;
+
+	std::vector<std::list< std::pair< std::string, int > >::iterator> toDel;
+
+	for(std::list< std::pair< std::string, int > >::iterator it = texts.begin(); it != texts.end(); ++it, ++number)
+	{
+		SDL_Color green = {0,0xff,0,0};
+		CSDL_Ext::printAtWR(it->first, 50, conf.cc.resy - texts.size() * 30 - 80 + number*30, GEOR16, green);
+		if(SDL_GetTicks() - it->second > defaultTimeout)
+		{
+			toDel.push_back(it);
+		}
+	}
+
+	for(int it=0; it<toDel.size(); ++it)
+	{
+		texts.erase(toDel[it]);
+	}
+}
+
+void CInGameConsole::keyPressed (const SDL_KeyboardEvent & key)
+{
+	if(key.type == SDL_KEYDOWN)
+	{
+		switch(key.keysym.sym)
+		{
+		case SDLK_TAB:
+			{
+				if(captureAllKeys)
+				{
+					captureAllKeys = false;
+					endEnteringText(false);
+				}
+				else
+				{
+					captureAllKeys = true;
+					startEnteringText();
+				}
+				break;
+			}
+		case SDLK_RETURN: //enter key
+			{
+				if(enteredText.size() > 0)
+				{
+					if(captureAllKeys)
+					{
+						captureAllKeys = false;
+						endEnteringText(true);
+					}
+				}
+				break;
+			}
+		default:
+			{
+				if(enteredText.size() > 0)
+				{
+					if( key.keysym.unicode < 0x80 && key.keysym.unicode > 0 )
+					{
+						enteredText[enteredText.size()-1] = (char)key.keysym.unicode;
+						enteredText += "_";
+						if(LOCPLINT->curint == LOCPLINT->adventureInt)
+						{
+							LOCPLINT->statusbar->print(enteredText);
+						}
+						else if(LOCPLINT->curint == LOCPLINT->battleInt)
+						{
+							LOCPLINT->battleInt->console->ingcAlter = enteredText;
+						}
+					}
+				}
+				break;
+			}
+		}
+	}
+}
+
+void CInGameConsole::startEnteringText()
+{
+	enteredText = "_";
+	if(LOCPLINT->curint == LOCPLINT->adventureInt)
+	{
+		LOCPLINT->statusbar->print(enteredText);
+	}
+	else if(LOCPLINT->curint == LOCPLINT->battleInt)
+	{
+		LOCPLINT->battleInt->console->ingcAlter = enteredText;
+	}
+}
+
+void CInGameConsole::endEnteringText(bool printEnteredText)
+{
+	if(printEnteredText)
+	{
+		texts.push_back(std::make_pair(enteredText.substr(0, enteredText.size()-1), SDL_GetTicks()));
+		if(texts.size() > maxDisplayedTexts)
+		{
+			texts.pop_front();
+		}
+	}
+	enteredText = "";
+	if(LOCPLINT->curint == LOCPLINT->adventureInt)
+	{
+		LOCPLINT->statusbar->clear();
+	}
+	else if(LOCPLINT->curint == LOCPLINT->battleInt)
+	{
+		LOCPLINT->battleInt->console->ingcAlter = "";
+	}
+
+}
+
+CInGameConsole::CInGameConsole() : defaultTimeout(10000), maxDisplayedTexts(10)
+{
+}
+

CPlayerInterface.h

@@ -40,6 +40,7 @@ class CGObjectInstance;
 class CSlider;
 struct UpgradeInfo;
 template <typename T> struct CondSh;
+class CInGameConsole;
 
 namespace boost
 {
@@ -290,7 +291,7 @@ public:
 class Hoverable  : public virtual CIntObject
 {
 public:
-	Hoverable(){hovered=false;} //c-tor
+	Hoverable() : hovered(false){} //c-tor
 	virtual ~Hoverable();//{}; //d-tor
 	bool hovered;  //for determining if object is hovered
 	virtual void hover (bool on)=0;
@@ -298,8 +299,10 @@ public:
 	virtual void deactivate()=0;
 };
 class KeyInterested : public virtual CIntObject
-{
+{	
 public:
+	bool captureAllKeys; //if true, only this object should get info about pressed keys
+	KeyInterested(): captureAllKeys(false){}
 	virtual ~KeyInterested();//{};
 	virtual void keyPressed(const SDL_KeyboardEvent & key)=0;
 	virtual void activate()=0;
@@ -335,6 +338,7 @@ public:
 	virtual void activate();
 	virtual void deactivate();
 };
+
 class CInfoWindow : public CSimpleWindow //text + comp. + ok button
 { //window able to delete its components when closed
 public:
@@ -506,6 +510,7 @@ public:
 	CAdvMapInt * adventureInt;
 	CCastleInterface * castleInt;
 	CBattleInterface * battleInt;
+	CInGameConsole * cingconsole;
 	FPSmanager * mainFPSmng;
 	IStatusBar *statusbar; //advmap statusbar; should it be used by other windows with statusbar?
 	//to commucate with engine
@@ -546,7 +551,7 @@ public:
 	void yourTurn();
 	void availableCreaturesChanged(const CGTownInstance *town);
 	void heroBonusChanged(const CGHeroInstance *hero, const HeroBonus &bonus, bool gain);//if gain hero received bonus, else he lost it
-	void serialize(COSer<CSaveFile> &h, const int version); //saving
+	void serialize(COSer<CSaveFile> &h, const int version); //saving
 	void serialize(CISer<CLoadFile> &h, const int version); //loading
 
 	//for battles
@@ -897,6 +902,25 @@ public:
 	void show(SDL_Surface * to = NULL);
 };
 
+class CInGameConsole : public IShowActivable, public KeyInterested
+{
+private:
+	std::list< std::pair< std::string, int > > texts; //<text to show, time of add>
+	int defaultTimeout; //timeout for new texts (in ms)
+	int maxDisplayedTexts; //hiw many texts can be displayed simultaneously
+public:
+	std::string enteredText;
+	void activate();
+	void deactivate();
+	void show(SDL_Surface * to = NULL);
+	void keyPressed (const SDL_KeyboardEvent & key); //call-in
+
+	void startEnteringText();
+	void endEnteringText(bool printEnteredText);
+
+	CInGameConsole(); //c-tor
+};
+
 extern CPlayerInterface * LOCPLINT;
 
 

SDL_Extensions.cpp

@@ -139,6 +139,34 @@ void CSDL_Ext::printAtMiddle(const std::string & text, int x, int y, TTF_Font *
 		SDL_UpdateRect(dst,x-(temp->w/2),y-(temp->h/2),temp->w,temp->h);
 	SDL_FreeSurface(temp);
 }
+void CSDL_Ext::printAtWR(const std::string & text, int x, int y, TTF_Font * font, SDL_Color kolor, SDL_Surface * dst, unsigned char quality)
+{
+	if (text.length()==0)
+		return;
+	SDL_Surface * temp;
+	switch (quality)
+	{
+	case 0:
+		temp = TTF_RenderText_Solid(font,text.c_str(),kolor);
+		break;
+	case 1:
+		SDL_Color tem;
+		tem.b = 0xff-kolor.b;
+		tem.g = 0xff-kolor.g;
+		tem.r = 0xff-kolor.r;
+		tem.unused = 0xff-kolor.unused;
+		temp = TTF_RenderText_Shaded(font,text.c_str(),kolor,tem);
+		break;
+	case 2:
+		temp = TTF_RenderText_Blended(font,text.c_str(),kolor);
+		break;
+	default:
+		temp = TTF_RenderText_Blended(font,text.c_str(),kolor);
+		break;
+	}
+	SDL_BlitSurface(temp,NULL,dst,&genRect(temp->h,temp->w,x,y));
+	SDL_FreeSurface(temp);
+}
 void CSDL_Ext::printAt(const std::string & text, int x, int y, TTF_Font * font, SDL_Color kolor, SDL_Surface * dst, unsigned char quality)
 {
 	if (text.length()==0)

SDL_Extensions.h

@@ -67,6 +67,7 @@ namespace CSDL_Ext
 	void printAtMiddleWB(const std::string & text, int x, int y, TTF_Font * font, int charpr, SDL_Color kolor=tytulowy, SDL_Surface * dst=screen);
 	void printAtWB(const std::string & text, int x, int y, TTF_Font * font, int charpr, SDL_Color kolor=tytulowy, SDL_Surface * dst=screen);
 	void printAt(const std::string & text, int x, int y, TTF_Font * font, SDL_Color kolor=tytulowy, SDL_Surface * dst=screen, unsigned char quality = 2); // quality: 0 - lowest, 1 - medium, 2 - highest
+	void printAtWR(const std::string & text, int x, int y, TTF_Font * font, SDL_Color kolor=tytulowy, SDL_Surface * dst=screen, unsigned char quality = 2); // quality: 0 - lowest, 1 - medium, 2 - highest
 	void update(SDL_Surface * what = screen); //updates whole surface (default - main screen)
 	void drawBorder(SDL_Surface * sur, int x, int y, int w, int h, int3 color);
 	void setPlayerColor(SDL_Surface * sur, unsigned char player); //sets correct color of flags; -1 for neutral