2008-02-25 01:06:27 +02:00
# include "CBattleInterface.h"
2008-02-26 20:01:26 +02:00
# include "CGameInfo.h"
2008-07-01 11:01:02 +03:00
# include "hch/CLodHandler.h"
2008-02-26 20:01:26 +02:00
# include "SDL_Extensions.h"
# include "CAdvmapInterface.h"
# include "AdventureMapButton.h"
2008-07-02 11:39:56 +03:00
# include "hch/CObjectHandler.h"
2008-07-01 11:01:02 +03:00
# include "hch/CHeroHandler.h"
# include "hch/CDefHandler.h"
2008-08-06 20:49:47 +03:00
# include "CCursorHandler.h"
2008-03-10 22:19:41 +02:00
# include "CCallback.h"
# include "CGameState.h"
2008-07-01 11:01:02 +03:00
# include "hch/CGeneralTextHandler.h"
2008-06-07 20:16:52 +03:00
# include "client/CCreatureAnimation.h"
2008-06-30 03:06:41 +03:00
# include "client/Graphics.h"
2008-03-23 19:25:38 +02:00
# include <queue>
2008-04-14 21:24:46 +03:00
# include <sstream>
2008-08-04 18:56:36 +03:00
# include "lib/CondSh.h"
2008-08-04 12:05:52 +03:00
# ifndef __GNUC__
2008-08-02 18:08:03 +03:00
const double M_PI = 3.14159265358979323846 ;
2008-08-04 12:05:52 +03:00
# else
# define _USE_MATH_DEFINES
# include <cmath>
# endif
2008-08-02 18:08:03 +03:00
2008-03-03 21:41:10 +02:00
extern SDL_Surface * screen ;
2008-04-14 21:24:46 +03:00
extern TTF_Font * GEOR13 ;
extern SDL_Color zwykly ;
2008-03-14 20:24:37 +02:00
SDL_Surface * CBattleInterface : : cellBorder , * CBattleInterface : : cellShade ;
2008-02-25 01:06:27 +02:00
2008-08-02 18:08:03 +03:00
CBattleInterface : : CBattleInterface ( CCreatureSet * army1 , CCreatureSet * army2 , CGHeroInstance * hero1 , CGHeroInstance * hero2 )
: printCellBorders ( true ) , attackingHeroInstance ( hero1 ) , defendingHeroInstance ( hero2 ) , animCount ( 0 ) , activeStack ( - 1 ) , givenCommand ( NULL ) , attackingInfo ( NULL ) , myTurn ( false )
2008-02-25 01:06:27 +02:00
{
2008-08-04 18:56:36 +03:00
givenCommand = new CondSh < BattleAction * > ( NULL ) ;
2008-03-05 19:01:41 +02:00
//initializing armies
this - > army1 = army1 ;
this - > army2 = army2 ;
2008-03-14 20:24:37 +02:00
std : : map < int , CStack > stacks = LOCPLINT - > cb - > battleGetStacks ( ) ;
for ( std : : map < int , CStack > : : iterator b = stacks . begin ( ) ; b ! = stacks . end ( ) ; + + b )
2008-03-05 19:01:41 +02:00
{
2008-04-14 21:24:46 +03:00
std : : pair < int , int > coords = CBattleHex : : getXYUnitAnim ( b - > second . position , b - > second . owner = = attackingHeroInstance - > tempOwner , b - > second . creature ) ;
2008-03-14 20:24:37 +02:00
creAnims [ b - > second . ID ] = ( new CCreatureAnimation ( b - > second . creature - > animDefName ) ) ;
creAnims [ b - > second . ID ] - > setType ( 2 ) ;
2008-04-07 20:51:46 +03:00
creAnims [ b - > second . ID ] - > pos = genRect ( creAnims [ b - > second . ID ] - > fullHeight , creAnims [ b - > second . ID ] - > fullWidth , coords . first , coords . second ) ;
2008-04-14 21:24:46 +03:00
creDir [ b - > second . ID ] = b - > second . owner = = attackingHeroInstance - > tempOwner ;
2008-03-05 19:01:41 +02:00
}
2008-03-03 21:41:10 +02:00
//preparing menu background and terrain
2008-07-02 11:39:56 +03:00
std : : vector < std : : string > & backref = graphics - > battleBacks [ LOCPLINT - > cb - > battleGetBattlefieldType ( ) ] ;
2008-06-12 09:45:51 +03:00
background = BitmapHandler : : loadBitmap ( backref [ rand ( ) % backref . size ( ) ] ) ;
menu = BitmapHandler : : loadBitmap ( " CBAR.BMP " ) ;
2008-06-30 03:06:41 +03:00
graphics - > blueToPlayersAdv ( menu , hero1 - > tempOwner ) ;
2008-02-26 20:01:26 +02:00
2008-04-14 21:24:46 +03:00
//preparing graphics for displaying amounts of creatures
2008-06-12 09:45:51 +03:00
amountBasic = BitmapHandler : : loadBitmap ( " CMNUMWIN.BMP " ) ;
amountNormal = BitmapHandler : : loadBitmap ( " CMNUMWIN.BMP " ) ;
2008-04-14 21:24:46 +03:00
CSDL_Ext : : alphaTransform ( amountNormal ) ;
for ( int g = 0 ; g < amountNormal - > format - > palette - > ncolors ; + + g )
{
if ( ( amountNormal - > format - > palette - > colors + g ) - > b ! = 132 & &
( amountNormal - > format - > palette - > colors + g ) - > g ! = 231 & &
( amountNormal - > format - > palette - > colors + g ) - > r ! = 255 ) //it's not yellow border
{
( amountNormal - > format - > palette - > colors + g ) - > r = ( float ) ( ( amountNormal - > format - > palette - > colors + g ) - > r ) * 0.54f ;
( amountNormal - > format - > palette - > colors + g ) - > g = ( float ) ( ( amountNormal - > format - > palette - > colors + g ) - > g ) * 0.19f ;
( amountNormal - > format - > palette - > colors + g ) - > b = ( float ) ( ( amountNormal - > format - > palette - > colors + g ) - > b ) * 0.93f ;
}
}
2008-04-20 18:56:03 +03:00
////blitting menu background and terrain
2008-02-26 20:01:26 +02:00
blitAt ( background , 0 , 0 ) ;
blitAt ( menu , 0 , 556 ) ;
CSDL_Ext : : update ( ) ;
2008-08-02 18:08:03 +03:00
2008-04-16 20:21:02 +03:00
//preparing buttons and console
2008-05-18 20:33:39 +03:00
bOptions = new AdventureMapButton ( std : : string ( ) , std : : string ( ) , boost : : bind ( & CBattleInterface : : bOptionsf , this ) , 3 , 561 , " icm003.def " , false , NULL , false ) ;
bSurrender = new AdventureMapButton ( std : : string ( ) , std : : string ( ) , boost : : bind ( & CBattleInterface : : bSurrenderf , this ) , 54 , 561 , " icm001.def " , false , NULL , false ) ;
bFlee = new AdventureMapButton ( std : : string ( ) , std : : string ( ) , boost : : bind ( & CBattleInterface : : bFleef , this ) , 105 , 561 , " icm002.def " , false , NULL , false ) ;
bAutofight = new AdventureMapButton ( std : : string ( ) , std : : string ( ) , boost : : bind ( & CBattleInterface : : bAutofightf , this ) , 157 , 561 , " icm004.def " , false , NULL , false ) ;
bSpell = new AdventureMapButton ( std : : string ( ) , std : : string ( ) , boost : : bind ( & CBattleInterface : : bSpellf , this ) , 645 , 561 , " icm005.def " , false , NULL , false ) ;
bWait = new AdventureMapButton ( std : : string ( ) , std : : string ( ) , boost : : bind ( & CBattleInterface : : bWaitf , this ) , 696 , 561 , " icm006.def " , false , NULL , false ) ;
bDefence = new AdventureMapButton ( std : : string ( ) , std : : string ( ) , boost : : bind ( & CBattleInterface : : bDefencef , this ) , 747 , 561 , " icm007.def " , false , NULL , false ) ;
bConsoleUp = new AdventureMapButton ( std : : string ( ) , std : : string ( ) , boost : : bind ( & CBattleInterface : : bConsoleUpf , this ) , 624 , 561 , " ComSlide.def " , false , NULL , false ) ;
bConsoleDown = new AdventureMapButton ( std : : string ( ) , std : : string ( ) , boost : : bind ( & CBattleInterface : : bConsoleDownf , this ) , 624 , 580 , " ComSlide.def " , false , NULL , false ) ;
2008-03-03 21:41:10 +02:00
bConsoleDown - > bitmapOffset = 2 ;
2008-04-16 20:21:02 +03:00
console = new CBattleConsole ( ) ;
console - > pos . x = 211 ;
console - > pos . y = 560 ;
console - > pos . w = 406 ;
console - > pos . h = 38 ;
2008-08-02 18:08:03 +03:00
2008-03-03 21:41:10 +02:00
//loading hero animations
if ( hero1 ) // attacking hero
{
2008-07-02 11:39:56 +03:00
attackingHero = new CBattleHero ( graphics - > battleHeroes [ hero1 - > type - > heroType ] , 0 , 0 , false , hero1 - > tempOwner ) ;
2008-03-04 19:25:58 +02:00
attackingHero - > pos = genRect ( attackingHero - > dh - > ourImages [ 0 ] . bitmap - > h , attackingHero - > dh - > ourImages [ 0 ] . bitmap - > w , - 40 , 0 ) ;
2008-03-03 21:41:10 +02:00
}
else
{
attackingHero = NULL ;
}
if ( hero2 ) // defending hero
{
2008-07-02 11:39:56 +03:00
defendingHero = new CBattleHero ( graphics - > battleHeroes [ hero2 - > type - > heroType ] , 0 , 0 , true , hero2 - > tempOwner ) ;
2008-03-04 19:25:58 +02:00
defendingHero - > pos = genRect ( defendingHero - > dh - > ourImages [ 0 ] . bitmap - > h , defendingHero - > dh - > ourImages [ 0 ] . bitmap - > w , 690 , 0 ) ;
2008-03-03 21:41:10 +02:00
}
else
{
defendingHero = NULL ;
}
2008-03-04 19:25:58 +02:00
//preparing cells and hexes
2008-06-12 09:45:51 +03:00
cellBorder = BitmapHandler : : loadBitmap ( " CCELLGRD.BMP " ) ;
2008-04-20 18:56:03 +03:00
CSDL_Ext : : alphaTransform ( cellBorder ) ;
2008-06-12 09:45:51 +03:00
cellShade = BitmapHandler : : loadBitmap ( " CCELLSHD.BMP " ) ;
2008-04-20 18:56:03 +03:00
CSDL_Ext : : alphaTransform ( cellShade ) ;
2008-03-10 22:19:41 +02:00
for ( int h = 0 ; h < 187 ; + + h )
{
bfield [ h ] . myNumber = h ;
2008-08-02 18:08:03 +03:00
2008-03-10 22:19:41 +02:00
int x = 14 + ( ( h / 17 ) % 2 = = 0 ? 22 : 0 ) + 44 * ( h % 17 ) ;
int y = 86 + 42 * ( h / 17 ) ;
bfield [ h ] . pos = genRect ( cellShade - > h , cellShade - > w , x , y ) ;
2008-03-23 19:25:38 +02:00
bfield [ h ] . accesible = true ;
2008-03-24 21:04:30 +02:00
bfield [ h ] . myInterface = this ;
2008-03-10 22:19:41 +02:00
}
2008-03-23 19:25:38 +02:00
//locking occupied positions on batlefield
for ( std : : map < int , CStack > : : iterator it = stacks . begin ( ) ; it ! = stacks . end ( ) ; + + it ) //stacks gained at top of this function
{
bfield [ it - > second . position ] . accesible = false ;
}
2008-08-02 18:08:03 +03:00
//loading projectiles for units
for ( std : : map < int , CStack > : : iterator g = stacks . begin ( ) ; g ! = stacks . end ( ) ; + + g )
{
if ( g - > second . creature - > isShooting ( ) & & CGI - > creh - > idToProjectile [ g - > second . creature - > idNumber ] ! = std : : string ( ) )
{
idToProjectile [ g - > second . creature - > idNumber ] = CDefHandler : : giveDef ( CGI - > creh - > idToProjectile [ g - > second . creature - > idNumber ] ) ;
if ( idToProjectile [ g - > second . creature - > idNumber ] - > ourImages . size ( ) > 2 ) //add symmetric images
{
for ( int k = idToProjectile [ g - > second . creature - > idNumber ] - > ourImages . size ( ) - 2 ; k > 1 ; - - k )
{
Cimage ci ;
ci . bitmap = CSDL_Ext : : rotate01 ( idToProjectile [ g - > second . creature - > idNumber ] - > ourImages [ k ] . bitmap ) ;
ci . groupNumber = 0 ;
ci . imName = std : : string ( ) ;
idToProjectile [ g - > second . creature - > idNumber ] - > ourImages . push_back ( ci ) ;
}
}
for ( int s = 0 ; s < idToProjectile [ g - > second . creature - > idNumber ] - > ourImages . size ( ) ; + + s ) //alpha transforming
{
CSDL_Ext : : alphaTransform ( idToProjectile [ g - > second . creature - > idNumber ] - > ourImages [ s ] . bitmap ) ;
}
}
}
2008-08-31 20:23:40 +03:00
//prepairing graphic with cell borders
cellBorders = CSDL_Ext : : newSurface ( background - > w , background - > h , cellBorder ) ;
* cellBorders - > format - > palette = * cellBorder - > format - > palette ;
for ( int i = 0 ; i < 11 ; + + i ) //rows
{
for ( int j = 0 ; j < 15 ; + + j ) //columns
{
int x = 58 + ( i % 2 = = 0 ? 22 : 0 ) + 44 * j ;
int y = 86 + 42 * i ;
//SDL_BlitSurface(cellBorder, NULL, cellBorders, &genRect(cellBorder->h, cellBorder->w, x, y));
for ( int cellX = 0 ; cellX < cellBorder - > w ; + + cellX )
{
for ( int cellY = 0 ; cellY < cellBorder - > h ; + + cellY )
{
if ( y + cellY < cellBorders - > h & & x + cellX < cellBorders - > w )
* ( ( Uint8 * ) cellBorders - > pixels + ( y + cellY ) * cellBorders - > pitch + ( x + cellX ) ) | = * ( ( Uint8 * ) cellBorder - > pixels + cellY * cellBorder - > pitch + cellX ) ;
}
}
}
}
shadedHexesGraphic = CSDL_Ext : : newSurface ( background - > w , background - > h , cellBorder ) ;
2008-02-25 01:06:27 +02:00
}
2008-02-26 20:01:26 +02:00
CBattleInterface : : ~ CBattleInterface ( )
{
SDL_FreeSurface ( background ) ;
SDL_FreeSurface ( menu ) ;
2008-04-15 19:52:31 +03:00
SDL_FreeSurface ( amountBasic ) ;
SDL_FreeSurface ( amountNormal ) ;
2008-08-31 20:23:40 +03:00
SDL_FreeSurface ( cellBorders ) ;
SDL_FreeSurface ( shadedHexesGraphic ) ;
2008-03-01 13:49:25 +02:00
delete bOptions ;
delete bSurrender ;
delete bFlee ;
delete bAutofight ;
delete bSpell ;
delete bWait ;
delete bDefence ;
2008-03-03 21:41:10 +02:00
delete bConsoleUp ;
delete bConsoleDown ;
2008-04-16 20:21:02 +03:00
delete console ;
2008-08-04 18:56:36 +03:00
delete givenCommand ;
2008-03-03 21:41:10 +02:00
delete attackingHero ;
delete defendingHero ;
2008-03-04 19:25:58 +02:00
SDL_FreeSurface ( cellBorder ) ;
SDL_FreeSurface ( cellShade ) ;
2008-03-05 19:01:41 +02:00
2008-04-20 18:56:03 +03:00
for ( std : : map < int , CCreatureAnimation * > : : iterator g = creAnims . begin ( ) ; g ! = creAnims . end ( ) ; + + g )
delete g - > second ;
2008-08-02 18:08:03 +03:00
for ( std : : map < int , CDefHandler * > : : iterator g = idToProjectile . begin ( ) ; g ! = idToProjectile . end ( ) ; + + g )
delete g - > second ;
2008-02-26 20:01:26 +02:00
}
2008-02-25 01:06:27 +02:00
void CBattleInterface : : activate ( )
{
2008-08-30 00:41:32 +03:00
subInt = NULL ;
2008-02-26 20:01:26 +02:00
bOptions - > activate ( ) ;
2008-03-01 13:49:25 +02:00
bSurrender - > activate ( ) ;
bFlee - > activate ( ) ;
bAutofight - > activate ( ) ;
bSpell - > activate ( ) ;
bWait - > activate ( ) ;
bDefence - > activate ( ) ;
2008-03-03 21:41:10 +02:00
bConsoleUp - > activate ( ) ;
bConsoleDown - > activate ( ) ;
2008-03-10 22:19:41 +02:00
for ( int b = 0 ; b < 187 ; + + b )
{
bfield [ b ] . activate ( ) ;
}
2008-02-25 01:06:27 +02:00
}
2008-02-26 20:01:26 +02:00
2008-02-25 01:06:27 +02:00
void CBattleInterface : : deactivate ( )
{
2008-02-26 20:01:26 +02:00
bOptions - > deactivate ( ) ;
2008-03-01 13:49:25 +02:00
bSurrender - > deactivate ( ) ;
bFlee - > deactivate ( ) ;
bAutofight - > deactivate ( ) ;
bSpell - > deactivate ( ) ;
bWait - > deactivate ( ) ;
bDefence - > deactivate ( ) ;
2008-03-03 21:41:10 +02:00
bConsoleUp - > deactivate ( ) ;
bConsoleDown - > deactivate ( ) ;
2008-03-10 22:19:41 +02:00
for ( int b = 0 ; b < 187 ; + + b )
{
bfield [ b ] . deactivate ( ) ;
}
2008-02-26 20:01:26 +02:00
}
void CBattleInterface : : show ( SDL_Surface * to )
{
2008-03-23 19:25:38 +02:00
std : : map < int , CStack > stacks = LOCPLINT - > cb - > battleGetStacks ( ) ; //used in a few places
2008-03-15 19:48:05 +02:00
+ + animCount ;
2008-03-03 21:41:10 +02:00
if ( ! to ) //"evaluating" to
to = screen ;
//showing background
2008-02-26 20:01:26 +02:00
blitAt ( background , 0 , 0 , to ) ;
2008-08-31 20:23:40 +03:00
if ( printCellBorders )
2008-03-04 19:25:58 +02:00
{
2008-08-31 20:23:40 +03:00
CSDL_Ext : : blit8bppAlphaTo24bpp ( cellBorders , NULL , to , NULL ) ;
2008-03-04 19:25:58 +02:00
}
2008-03-10 22:19:41 +02:00
//printing hovered cell
for ( int b = 0 ; b < 187 ; + + b )
{
2008-03-15 19:48:05 +02:00
if ( bfield [ b ] . strictHovered & & bfield [ b ] . hovered )
2008-03-10 22:19:41 +02:00
{
int x = 14 + ( ( b / 17 ) % 2 = = 0 ? 22 : 0 ) + 44 * ( b % 17 ) ;
int y = 86 + 42 * ( b / 17 ) ;
CSDL_Ext : : blit8bppAlphaTo24bpp ( cellShade , NULL , to , & genRect ( cellShade - > h , cellShade - > w , x , y ) ) ;
}
}
2008-03-23 19:25:38 +02:00
//showing selected unit's range
2008-06-21 16:27:52 +03:00
if ( activeStack ! = - 1 & & creAnims [ activeStack ] - > getType ( ) ! = 0 ) //don't show if unit is moving
2008-06-11 04:58:18 +03:00
{
showRange ( to , activeStack ) ;
}
2008-03-29 12:59:18 +02:00
2008-04-16 20:21:02 +03:00
//showing menu background and console
2008-03-04 19:25:58 +02:00
blitAt ( menu , 0 , 556 , to ) ;
2008-04-16 20:21:02 +03:00
console - > show ( to ) ;
2008-03-03 21:41:10 +02:00
//showing buttons
2008-02-26 20:01:26 +02:00
bOptions - > show ( to ) ;
2008-03-03 21:41:10 +02:00
bSurrender - > show ( to ) ;
bFlee - > show ( to ) ;
bAutofight - > show ( to ) ;
bSpell - > show ( to ) ;
bWait - > show ( to ) ;
bDefence - > show ( to ) ;
bConsoleUp - > show ( to ) ;
bConsoleDown - > show ( to ) ;
//showing hero animations
2008-03-05 19:01:41 +02:00
if ( attackingHero )
attackingHero - > show ( to ) ;
if ( defendingHero )
defendingHero - > show ( to ) ;
2008-08-02 18:08:03 +03:00
////showing units //a lot of work...
2008-06-21 16:27:52 +03:00
std : : vector < int > stackAliveByHex [ 187 ] ;
//double loop because dead stacks should be printed first
2008-04-14 21:24:46 +03:00
for ( std : : map < int , CStack > : : iterator j = stacks . begin ( ) ; j ! = stacks . end ( ) ; + + j )
2008-03-08 17:23:04 +02:00
{
2008-06-21 16:27:52 +03:00
if ( j - > second . alive )
stackAliveByHex [ j - > second . position ] . push_back ( j - > second . ID ) ;
}
std : : vector < int > stackDeadByHex [ 187 ] ;
for ( std : : map < int , CStack > : : iterator j = stacks . begin ( ) ; j ! = stacks . end ( ) ; + + j )
{
if ( ! j - > second . alive )
stackDeadByHex [ j - > second . position ] . push_back ( j - > second . ID ) ;
2008-04-14 21:24:46 +03:00
}
2008-06-11 04:58:18 +03:00
attackingShowHelper ( ) ; // handle attack animation
2008-06-21 16:27:52 +03:00
for ( int b = 0 ; b < 187 ; + + b ) //showing dead stacks
{
for ( int v = 0 ; v < stackDeadByHex [ b ] . size ( ) ; + + v )
{
2008-08-07 03:38:44 +03:00
creAnims [ stackDeadByHex [ b ] [ v ] ] - > nextFrame ( to , creAnims [ stackDeadByHex [ b ] [ v ] ] - > pos . x , creAnims [ stackDeadByHex [ b ] [ v ] ] - > pos . y , creDir [ stackDeadByHex [ b ] [ v ] ] , ( animCount % 4 = = 0 | | creAnims [ stackDeadByHex [ b ] [ v ] ] - > getType ( ) ! = 2 ) & & stacks [ stackDeadByHex [ b ] [ v ] ] . alive , stackDeadByHex [ b ] [ v ] = = activeStack ) ; //increment always when moving, never if stack died
2008-06-21 16:27:52 +03:00
//printing amount
if ( stacks [ stackDeadByHex [ b ] [ v ] ] . amount > 0 ) //don't print if stack is not alive
{
2008-08-07 15:29:53 +03:00
int xAdd = stacks [ stackDeadByHex [ b ] [ v ] ] . attackerOwned ? 220 : 202 ;
CSDL_Ext : : blit8bppAlphaTo24bpp ( amountNormal , NULL , to , & genRect ( amountNormal - > h , amountNormal - > w , creAnims [ stackDeadByHex [ b ] [ v ] ] - > pos . x + xAdd , creAnims [ stackDeadByHex [ b ] [ v ] ] - > pos . y + 260 ) ) ;
std : : stringstream ss ;
ss < < stacks [ stackDeadByHex [ b ] [ v ] ] . amount ;
CSDL_Ext : : printAtMiddleWB ( ss . str ( ) , creAnims [ stackDeadByHex [ b ] [ v ] ] - > pos . x + xAdd + 14 , creAnims [ stackDeadByHex [ b ] [ v ] ] - > pos . y + 260 + 4 , GEOR13 , 20 , zwykly , to ) ;
2008-06-21 16:27:52 +03:00
}
}
}
for ( int b = 0 ; b < 187 ; + + b ) //showing alive stacks
2008-04-14 21:24:46 +03:00
{
2008-06-21 16:27:52 +03:00
for ( int v = 0 ; v < stackAliveByHex [ b ] . size ( ) ; + + v )
2008-04-14 21:24:46 +03:00
{
2008-08-07 03:38:44 +03:00
creAnims [ stackAliveByHex [ b ] [ v ] ] - > nextFrame ( to , creAnims [ stackAliveByHex [ b ] [ v ] ] - > pos . x , creAnims [ stackAliveByHex [ b ] [ v ] ] - > pos . y , creDir [ stackAliveByHex [ b ] [ v ] ] , ( animCount % 4 = = 0 ) & & stacks [ stackAliveByHex [ b ] [ v ] ] . alive , stackAliveByHex [ b ] [ v ] = = activeStack ) ; //increment always when moving, never if stack died
2008-04-14 21:24:46 +03:00
//printing amount
2008-06-21 16:27:52 +03:00
if ( stacks [ stackAliveByHex [ b ] [ v ] ] . amount > 0 ) //don't print if stack is not alive
2008-04-14 21:24:46 +03:00
{
2008-08-07 15:29:53 +03:00
int xAdd = stacks [ stackAliveByHex [ b ] [ v ] ] . attackerOwned ? 220 : 202 ;
CSDL_Ext : : blit8bppAlphaTo24bpp ( amountNormal , NULL , to , & genRect ( amountNormal - > h , amountNormal - > w , creAnims [ stackAliveByHex [ b ] [ v ] ] - > pos . x + xAdd , creAnims [ stackAliveByHex [ b ] [ v ] ] - > pos . y + 260 ) ) ;
std : : stringstream ss ;
ss < < stacks [ stackAliveByHex [ b ] [ v ] ] . amount ;
CSDL_Ext : : printAtMiddleWB ( ss . str ( ) , creAnims [ stackAliveByHex [ b ] [ v ] ] - > pos . x + xAdd + 14 , creAnims [ stackAliveByHex [ b ] [ v ] ] - > pos . y + 260 + 4 , GEOR13 , 20 , zwykly , to ) ;
2008-04-14 21:24:46 +03:00
}
}
2008-03-08 17:23:04 +02:00
}
2008-03-05 19:01:41 +02:00
//units shown
2008-08-02 18:08:03 +03:00
projectileShowHelper ( to ) ; //showing projectiles
2008-02-26 20:01:26 +02:00
}
2008-05-03 18:18:48 +03:00
bool CBattleInterface : : reverseCreature ( int number , int hex , bool wideTrick )
2008-04-14 21:24:46 +03:00
{
if ( creAnims [ number ] = = NULL )
return false ; //there is no such creature
creAnims [ number ] - > setType ( 8 ) ;
for ( int g = 0 ; g < creAnims [ number ] - > framesInGroup ( 8 ) ; + + g )
{
show ( ) ;
2008-05-27 16:16:35 +03:00
CSDL_Ext : : update ( ) ;
2008-04-14 21:24:46 +03:00
SDL_framerateDelay ( LOCPLINT - > mainFPSmng ) ;
2008-08-07 03:38:44 +03:00
if ( ( animCount + 1 ) % 4 )
creAnims [ number ] - > incrementFrame ( ) ;
2008-04-14 21:24:46 +03:00
}
creDir [ number ] = ! creDir [ number ] ;
2008-07-02 11:39:56 +03:00
CStack curs = * LOCPLINT - > cb - > battleGetStackByID ( number ) ;
2008-04-14 21:24:46 +03:00
std : : pair < int , int > coords = CBattleHex : : getXYUnitAnim ( hex , creDir [ number ] , curs . creature ) ;
creAnims [ number ] - > pos . x = coords . first ;
2008-05-03 18:18:48 +03:00
//creAnims[number]->pos.y = coords.second;
if ( wideTrick & & curs . creature - > isDoubleWide ( ) )
{
2008-08-07 03:38:44 +03:00
if ( ! creDir [ number ] )
creAnims [ number ] - > pos . x - = 44 ;
2008-05-03 18:18:48 +03:00
}
2008-04-14 21:24:46 +03:00
creAnims [ number ] - > setType ( 7 ) ;
for ( int g = 0 ; g < creAnims [ number ] - > framesInGroup ( 7 ) ; + + g )
{
show ( ) ;
2008-05-27 16:16:35 +03:00
CSDL_Ext : : update ( ) ;
2008-04-14 21:24:46 +03:00
SDL_framerateDelay ( LOCPLINT - > mainFPSmng ) ;
}
creAnims [ number ] - > setType ( 2 ) ;
return true ;
}
2008-02-26 20:01:26 +02:00
void CBattleInterface : : bOptionsf ( )
{
}
void CBattleInterface : : bSurrenderf ( )
{
}
void CBattleInterface : : bFleef ( )
{
2008-08-04 18:56:36 +03:00
giveCommand ( 4 , 0 , 0 ) ;
2008-08-07 15:29:53 +03:00
CGI - > curh - > changeGraphic ( 0 , 0 ) ;
2008-02-26 20:01:26 +02:00
}
void CBattleInterface : : bAutofightf ( )
{
}
void CBattleInterface : : bSpellf ( )
{
}
void CBattleInterface : : bWaitf ( )
{
}
void CBattleInterface : : bDefencef ( )
{
2008-08-04 18:56:36 +03:00
giveCommand ( 3 , 0 , activeStack ) ;
2008-02-26 20:01:26 +02:00
}
void CBattleInterface : : bConsoleUpf ( )
{
2008-04-16 20:21:02 +03:00
console - > scrollUp ( ) ;
2008-02-26 20:01:26 +02:00
}
void CBattleInterface : : bConsoleDownf ( )
{
2008-04-16 20:21:02 +03:00
console - > scrollDown ( ) ;
2008-02-26 20:01:26 +02:00
}
2008-03-03 21:41:10 +02:00
2008-03-14 20:24:37 +02:00
void CBattleInterface : : newStack ( CStack stack )
{
creAnims [ stack . ID ] = new CCreatureAnimation ( stack . creature - > animDefName ) ;
creAnims [ stack . ID ] - > setType ( 2 ) ;
2008-04-14 21:24:46 +03:00
creDir [ stack . ID ] = stack . owner = = attackingHeroInstance - > tempOwner ;
2008-03-14 20:24:37 +02:00
}
void CBattleInterface : : stackRemoved ( CStack stack )
{
delete creAnims [ stack . ID ] ;
creAnims . erase ( stack . ID ) ;
}
2008-08-02 18:08:03 +03:00
void CBattleInterface : : stackKilled ( int ID , int dmg , int killed , int IDby , bool byShooting )
2008-05-30 14:53:04 +03:00
{
2008-08-02 18:08:03 +03:00
if ( creAnims [ ID ] - > getType ( ) ! = 2 )
{
return ; //something went wrong
}
if ( byShooting ) //delay hit animation
{
CStack attacker = * LOCPLINT - > cb - > battleGetStackByID ( IDby ) ;
while ( true )
{
bool found = false ;
for ( std : : list < SProjectileInfo > : : const_iterator it = projectiles . begin ( ) ; it ! = projectiles . end ( ) ; + + it )
{
if ( it - > creID = = attacker . creature - > idNumber )
{
found = true ;
break ;
}
}
if ( ! found )
break ;
else
{
show ( ) ;
CSDL_Ext : : update ( ) ;
SDL_framerateDelay ( LOCPLINT - > mainFPSmng ) ;
}
}
}
2008-06-11 04:58:18 +03:00
creAnims [ ID ] - > setType ( 5 ) ; //death
2008-08-20 22:02:48 +03:00
for ( int i = 0 ; i < creAnims [ ID ] - > framesInGroup ( 5 ) ; + + i )
2008-06-11 04:58:18 +03:00
{
2008-08-30 00:41:32 +03:00
if ( i )
creAnims [ ID ] - > incrementFrame ( ) ;
2008-06-11 04:58:18 +03:00
show ( ) ;
CSDL_Ext : : update ( ) ;
SDL_framerateDelay ( LOCPLINT - > mainFPSmng ) ;
}
2008-08-02 18:08:03 +03:00
2008-06-11 04:58:18 +03:00
printConsoleAttacked ( ID , dmg , killed , IDby ) ;
2008-05-30 14:53:04 +03:00
}
2008-03-23 19:25:38 +02:00
void CBattleInterface : : stackActivated ( int number )
{
2008-08-04 18:56:36 +03:00
//givenCommand = NULL;
2008-03-23 19:25:38 +02:00
activeStack = number ;
2008-08-02 18:08:03 +03:00
shadedHexes = LOCPLINT - > cb - > battleGetAvailableHexes ( number ) ;
myTurn = true ;
2008-08-31 20:23:40 +03:00
//preparating graphic with shaded hexes
//prepairing graphic with cell borders
shadedHexesGraphic = CSDL_Ext : : newSurface ( background - > w , background - > h , cellShade ) ;
* shadedHexesGraphic - > format - > palette = * cellShade - > format - > palette ;
for ( int m = 0 ; m < shadedHexes . size ( ) ; + + m ) //rows
{
int i = shadedHexes [ m ] / 17 ; //row
int j = shadedHexes [ m ] % 17 - 1 ; //column
int x = 58 + ( i % 2 = = 0 ? 22 : 0 ) + 44 * j ;
int y = 86 + 42 * i ;
for ( int cellX = 0 ; cellX < cellShade - > w ; + + cellX )
{
for ( int cellY = 0 ; cellY < cellShade - > h ; + + cellY )
{
if ( y + cellY < shadedHexesGraphic - > h & & x + cellX < shadedHexesGraphic - > w )
* ( ( Uint8 * ) shadedHexesGraphic - > pixels + ( y + cellY ) * shadedHexesGraphic - > pitch + ( x + cellX ) ) | = * ( ( Uint8 * ) cellShade - > pixels + cellY * cellShade - > pitch + cellX ) ;
}
}
}
2008-03-23 19:25:38 +02:00
}
2008-04-14 21:24:46 +03:00
void CBattleInterface : : stackMoved ( int number , int destHex , bool startMoving , bool endMoving )
2008-03-23 19:25:38 +02:00
{
2008-05-03 18:18:48 +03:00
//a few useful variables
2008-03-29 12:59:18 +02:00
int curStackPos = LOCPLINT - > cb - > battleGetPos ( number ) ;
2008-04-14 21:24:46 +03:00
int steps = creAnims [ number ] - > framesInGroup ( 0 ) ;
2008-04-07 20:51:46 +03:00
int hexWbase = 44 , hexHbase = 42 ;
2008-08-07 03:38:44 +03:00
bool twoTiles = LOCPLINT - > cb - > battleGetCreature ( number ) . isDoubleWide ( ) ;
2008-04-14 21:24:46 +03:00
if ( startMoving ) //animation of starting move
{
2008-08-07 03:38:44 +03:00
deactivate ( ) ;
CGI - > curh - > hide ( ) ;
creAnims [ number ] - > setType ( 20 ) ;
//LOCPLINT->objsToBlit.erase(std::find(LOCPLINT->objsToBlit.begin(),LOCPLINT->objsToBlit.end(),this));
2008-04-14 21:24:46 +03:00
for ( int i = 0 ; i < creAnims [ number ] - > framesInGroup ( 20 ) ; + + i )
{
show ( ) ;
2008-05-27 16:16:35 +03:00
CSDL_Ext : : update ( ) ;
2008-04-14 21:24:46 +03:00
SDL_framerateDelay ( LOCPLINT - > mainFPSmng ) ;
2008-08-07 03:38:44 +03:00
if ( ( animCount + 1 ) % 4 )
creAnims [ number ] - > incrementFrame ( ) ;
2008-04-14 21:24:46 +03:00
}
}
2008-08-06 20:49:47 +03:00
int mutPos = BattleInfo : : mutualPosition ( curStackPos , destHex ) ;
2008-05-03 18:18:48 +03:00
2008-04-14 21:24:46 +03:00
{
2008-08-07 03:38:44 +03:00
switch ( mutPos ) //reverse unit if necessary
2008-05-03 18:18:48 +03:00
{
2008-08-07 03:38:44 +03:00
case 0 : case 4 : case 5 :
2008-05-03 18:18:48 +03:00
if ( creDir [ number ] = = true )
2008-08-07 03:38:44 +03:00
reverseCreature ( number , curStackPos , twoTiles ) ;
2008-05-03 18:18:48 +03:00
break ;
2008-08-07 03:38:44 +03:00
case 1 : case 2 : case 3 :
2008-05-03 18:18:48 +03:00
if ( creDir [ number ] = = false )
2008-08-07 03:38:44 +03:00
reverseCreature ( number , curStackPos , twoTiles ) ;
2008-05-03 18:18:48 +03:00
break ;
}
//moving instructions
creAnims [ number ] - > setType ( 0 ) ;
for ( int i = 0 ; i < steps ; + + i )
{
2008-08-07 03:38:44 +03:00
switch ( mutPos )
2008-05-03 18:18:48 +03:00
{
case 0 :
creAnims [ number ] - > pos . x - = hexWbase / ( 2 * steps ) ;
creAnims [ number ] - > pos . y - = hexHbase / steps ;
break ;
case 1 :
creAnims [ number ] - > pos . x + = hexWbase / ( 2 * steps ) ;
creAnims [ number ] - > pos . y - = hexHbase / steps ;
break ;
case 2 :
creAnims [ number ] - > pos . x + = hexWbase / steps ;
break ;
case 3 :
creAnims [ number ] - > pos . x + = hexWbase / ( 2 * steps ) ;
creAnims [ number ] - > pos . y + = hexHbase / steps ;
break ;
case 4 :
creAnims [ number ] - > pos . x - = hexWbase / ( 2 * steps ) ;
creAnims [ number ] - > pos . y + = hexHbase / steps ;
break ;
case 5 :
creAnims [ number ] - > pos . x - = hexWbase / steps ;
break ;
}
show ( ) ;
2008-05-27 16:16:35 +03:00
CSDL_Ext : : update ( ) ;
2008-05-03 18:18:48 +03:00
SDL_framerateDelay ( LOCPLINT - > mainFPSmng ) ;
2008-08-07 03:38:44 +03:00
if ( ( animCount + 1 ) % 4 )
creAnims [ number ] - > incrementFrame ( ) ;
2008-05-03 18:18:48 +03:00
}
2008-03-29 12:59:18 +02:00
}
2008-04-14 21:24:46 +03:00
2008-05-03 18:18:48 +03:00
if ( endMoving ) //animation of ending move
2008-04-14 21:24:46 +03:00
{
2008-08-07 03:38:44 +03:00
creAnims [ number ] - > setType ( 21 ) ;
2008-04-14 21:24:46 +03:00
for ( int i = 0 ; i < creAnims [ number ] - > framesInGroup ( 21 ) ; + + i )
{
show ( ) ;
2008-05-27 16:16:35 +03:00
CSDL_Ext : : update ( ) ;
2008-04-14 21:24:46 +03:00
SDL_framerateDelay ( LOCPLINT - > mainFPSmng ) ;
2008-08-07 03:38:44 +03:00
if ( ( animCount + 1 ) % 4 )
creAnims [ number ] - > incrementFrame ( ) ;
2008-04-14 21:24:46 +03:00
}
2008-08-06 20:49:47 +03:00
creAnims [ number ] - > setType ( 2 ) ; //resetting to default
2008-08-07 03:38:44 +03:00
activate ( ) ;
CGI - > curh - > show ( ) ;
2008-04-14 21:24:46 +03:00
}
2008-05-03 18:18:48 +03:00
2008-07-02 11:39:56 +03:00
CStack curs = * LOCPLINT - > cb - > battleGetStackByID ( number ) ;
2008-04-14 21:24:46 +03:00
if ( endMoving ) //resetting to default
{
if ( creDir [ number ] ! = ( curs . owner = = attackingHeroInstance - > tempOwner ) )
2008-08-07 03:38:44 +03:00
reverseCreature ( number , destHex , twoTiles ) ;
2008-04-14 21:24:46 +03:00
}
std : : pair < int , int > coords = CBattleHex : : getXYUnitAnim ( destHex , creDir [ number ] , curs . creature ) ;
2008-04-07 20:51:46 +03:00
creAnims [ number ] - > pos . x = coords . first ;
2008-08-07 03:38:44 +03:00
if ( ! endMoving & & twoTiles & & ( creDir [ number ] ! = ( curs . owner = = attackingHeroInstance - > tempOwner ) ) ) //big creature is reversed
creAnims [ number ] - > pos . x - = 44 ;
2008-04-07 20:51:46 +03:00
creAnims [ number ] - > pos . y = coords . second ;
}
2008-08-02 18:08:03 +03:00
void CBattleInterface : : stackIsAttacked ( int ID , int dmg , int killed , int IDby , bool byShooting )
2008-05-27 16:16:35 +03:00
{
2008-08-02 18:08:03 +03:00
if ( creAnims [ ID ] - > getType ( ) ! = 2 )
{
return ; //something went wrong
}
if ( byShooting ) //delay hit animation
{
CStack attacker = * LOCPLINT - > cb - > battleGetStackByID ( IDby ) ;
while ( true )
{
bool found = false ;
for ( std : : list < SProjectileInfo > : : const_iterator it = projectiles . begin ( ) ; it ! = projectiles . end ( ) ; + + it )
{
if ( it - > creID = = attacker . creature - > idNumber )
{
found = true ;
break ;
}
}
if ( ! found )
break ;
else
{
show ( ) ;
CSDL_Ext : : update ( ) ;
SDL_framerateDelay ( LOCPLINT - > mainFPSmng ) ;
}
}
}
2008-06-11 04:58:18 +03:00
creAnims [ ID ] - > setType ( 3 ) ; //getting hit
for ( int i = 0 ; i < creAnims [ ID ] - > framesInGroup ( 3 ) ; + + i )
{
show ( ) ;
CSDL_Ext : : update ( ) ;
SDL_framerateDelay ( LOCPLINT - > mainFPSmng ) ;
2008-08-09 02:02:32 +03:00
if ( ( animCount + 1 ) % 4 )
creAnims [ ID ] - > incrementFrame ( ) ;
2008-06-11 04:58:18 +03:00
}
creAnims [ ID ] - > setType ( 2 ) ;
printConsoleAttacked ( ID , dmg , killed , IDby ) ;
2008-05-27 16:16:35 +03:00
}
2008-04-07 20:51:46 +03:00
void CBattleInterface : : stackAttacking ( int ID , int dest )
{
2008-08-02 18:08:03 +03:00
if ( attackingInfo ! = NULL )
{
return ; //something went wrong
}
2008-07-02 11:39:56 +03:00
CStack aStack = * LOCPLINT - > cb - > battleGetStackByID ( ID ) ; //attacking stack
2008-05-27 16:16:35 +03:00
if ( aStack . creature - > isDoubleWide ( ) )
{
2008-08-06 20:49:47 +03:00
switch ( BattleInfo : : mutualPosition ( aStack . position , dest ) ) //attack direction
2008-05-27 16:16:35 +03:00
{
case 0 :
2008-05-31 23:37:54 +03:00
//reverseCreature(ID, aStack.position, true);
2008-05-27 16:16:35 +03:00
break ;
case 1 :
break ;
case 2 :
break ;
case 3 :
break ;
case 4 :
2008-05-31 23:37:54 +03:00
//reverseCreature(ID, aStack.position, true);
2008-05-27 16:16:35 +03:00
break ;
case 5 :
2008-05-31 23:37:54 +03:00
reverseCreature ( ID , aStack . position , true ) ;
2008-05-27 16:16:35 +03:00
break ;
}
}
else //else for if(aStack.creature->isDoubleWide())
{
2008-08-06 20:49:47 +03:00
switch ( BattleInfo : : mutualPosition ( aStack . position , dest ) ) //attack direction
2008-05-27 16:16:35 +03:00
{
case 0 :
reverseCreature ( ID , aStack . position , true ) ;
break ;
case 1 :
break ;
case 2 :
break ;
case 3 :
break ;
case 4 :
reverseCreature ( ID , aStack . position , true ) ;
break ;
case 5 :
reverseCreature ( ID , aStack . position , true ) ;
break ;
}
2008-06-11 04:58:18 +03:00
}
attackingInfo = new CAttHelper ;
attackingInfo - > dest = dest ;
attackingInfo - > frame = 0 ;
attackingInfo - > ID = ID ;
attackingInfo - > reversing = false ;
2008-08-02 18:08:03 +03:00
attackingInfo - > shooting = false ;
2008-06-11 04:58:18 +03:00
2008-08-06 20:49:47 +03:00
switch ( BattleInfo : : mutualPosition ( aStack . position , dest ) ) //attack direction
2008-06-11 04:58:18 +03:00
{
2008-08-02 18:08:03 +03:00
case 0 :
2008-08-09 02:02:32 +03:00
attackingInfo - > maxframe = creAnims [ ID ] - > framesInGroup ( 11 ) ;
2008-08-02 18:08:03 +03:00
break ;
case 1 :
2008-08-09 02:02:32 +03:00
attackingInfo - > maxframe = creAnims [ ID ] - > framesInGroup ( 11 ) ;
2008-08-02 18:08:03 +03:00
break ;
case 2 :
2008-08-09 02:02:32 +03:00
attackingInfo - > maxframe = creAnims [ ID ] - > framesInGroup ( 12 ) ;
2008-08-02 18:08:03 +03:00
break ;
case 3 :
2008-08-09 02:02:32 +03:00
attackingInfo - > maxframe = creAnims [ ID ] - > framesInGroup ( 13 ) ;
2008-08-02 18:08:03 +03:00
break ;
case 4 :
2008-08-09 02:02:32 +03:00
attackingInfo - > maxframe = creAnims [ ID ] - > framesInGroup ( 13 ) ;
2008-08-02 18:08:03 +03:00
break ;
case 5 :
2008-08-09 02:02:32 +03:00
attackingInfo - > maxframe = creAnims [ ID ] - > framesInGroup ( 12 ) ;
2008-08-02 18:08:03 +03:00
break ;
2008-05-27 16:16:35 +03:00
}
2008-03-23 19:25:38 +02:00
}
2008-04-19 20:10:57 +03:00
void CBattleInterface : : newRound ( int number )
{
console - > addText ( CGI - > generaltexth - > allTexts [ 412 ] ) ;
}
2008-08-09 02:02:32 +03:00
void CBattleInterface : : giveCommand ( ui8 action , ui16 tile , ui32 stack , si32 additional )
2008-08-04 18:56:36 +03:00
{
2008-08-09 02:02:32 +03:00
BattleAction * ba = new BattleAction ( ) ; //is deleted in CPlayerInterface::activeStack()
2008-08-04 18:56:36 +03:00
ba - > actionType = action ;
ba - > destinationTile = tile ;
ba - > stackNumber = stack ;
2008-08-09 02:02:32 +03:00
ba - > additionalInfo = additional ;
2008-08-04 18:56:36 +03:00
givenCommand - > setn ( ba ) ;
myTurn = false ;
2008-08-06 20:49:47 +03:00
activeStack = - 1 ;
2008-08-04 18:56:36 +03:00
}
2008-03-24 21:04:30 +02:00
void CBattleInterface : : hexLclicked ( int whichOne )
{
2008-04-15 19:52:31 +03:00
if ( ( whichOne % 17 ) ! = 0 & & ( whichOne % 17 ) ! = 16 ) //if player is trying to attack enemey unit or move creature stack
2008-04-07 20:51:46 +03:00
{
2008-08-02 18:08:03 +03:00
if ( ! myTurn )
return ; //we are not permit to do anything
2008-08-10 07:46:16 +03:00
CStack * dest = LOCPLINT - > cb - > battleGetStackByPos ( whichOne ) ; //creature at destination tile; -1 if there is no one
if ( ! dest | | ! dest - > alive ) //no creature at that tile
2008-05-27 16:16:35 +03:00
{
2008-08-06 20:49:47 +03:00
if ( std : : find ( shadedHexes . begin ( ) , shadedHexes . end ( ) , whichOne ) ! = shadedHexes . end ( ) ) // and it's in our range
giveCommand ( 2 , whichOne , activeStack ) ;
2008-05-27 16:16:35 +03:00
}
2008-08-10 07:46:16 +03:00
else if ( dest - > owner ! = attackingHeroInstance - > tempOwner
2008-08-02 18:08:03 +03:00
& & LOCPLINT - > cb - > battleCanShoot ( activeStack , whichOne ) ) //shooting
{
2008-08-04 18:56:36 +03:00
giveCommand ( 7 , whichOne , activeStack ) ;
2008-08-02 18:08:03 +03:00
}
2008-08-10 07:46:16 +03:00
else if ( dest - > owner ! = attackingHeroInstance - > tempOwner ) //attacking
2008-05-27 16:16:35 +03:00
{
2008-08-09 02:02:32 +03:00
std : : vector < int > n = BattleInfo : : neighbouringTiles ( whichOne ) ;
for ( int i = 0 ; i < n . size ( ) ; i + + )
{
//TODO: now we are using first available tile, but in the future we should add possibility of choosing from which tile we want to attack
if ( vstd : : contains ( shadedHexes , n [ i ] ) )
{
giveCommand ( 6 , n [ i ] , activeStack , whichOne ) ;
return ;
}
}
2008-05-27 16:16:35 +03:00
}
2008-03-29 12:59:18 +02:00
}
2008-03-24 21:04:30 +02:00
}
2008-08-02 18:08:03 +03:00
void CBattleInterface : : stackIsShooting ( int ID , int dest )
{
if ( attackingInfo ! = NULL )
{
return ; //something went wrong
}
//projectile
float projectileAngle ; //in radians; if positive, projectiles goes up
float straightAngle = 0.2f ; //maximal angle in radians between straight horizontal line and shooting line for which shot is considered to be straight (absoulte value)
int fromHex = LOCPLINT - > cb - > battleGetPos ( ID ) ;
projectileAngle = atan2 ( float ( abs ( dest - fromHex ) / 17 ) , float ( abs ( dest - fromHex ) % 17 ) ) ;
if ( fromHex < dest )
projectileAngle = - projectileAngle ;
SProjectileInfo spi ;
spi . creID = LOCPLINT - > cb - > battleGetStackByID ( ID ) - > creature - > idNumber ;
spi . step = 0 ;
spi . frameNum = 0 ;
spi . spin = CGI - > creh - > idToProjectileSpin [ spi . creID ] ;
std : : pair < int , int > xycoord = CBattleHex : : getXYUnitAnim ( LOCPLINT - > cb - > battleGetPos ( ID ) , true , & LOCPLINT - > cb - > battleGetCreature ( ID ) ) ;
std : : pair < int , int > destcoord = CBattleHex : : getXYUnitAnim ( dest , false , & LOCPLINT - > cb - > battleGetCreature ( ID ) ) ;
destcoord . first + = 250 ; destcoord . second + = 210 ; //TODO: find a better place to shoot
if ( projectileAngle > straightAngle ) //upper shot
{
spi . x = xycoord . first + 200 + LOCPLINT - > cb - > battleGetCreature ( ID ) . upperRightMissleOffsetX ;
spi . y = xycoord . second + 150 - LOCPLINT - > cb - > battleGetCreature ( ID ) . upperRightMissleOffsetY ;
}
else if ( projectileAngle < - straightAngle ) //lower shot
{
spi . x = xycoord . first + 200 + LOCPLINT - > cb - > battleGetCreature ( ID ) . lowerRightMissleOffsetX ;
spi . y = xycoord . second + 150 - LOCPLINT - > cb - > battleGetCreature ( ID ) . lowerRightMissleOffsetY ;
}
else //straight shot
{
spi . x = xycoord . first + 200 + LOCPLINT - > cb - > battleGetCreature ( ID ) . rightMissleOffsetX ;
spi . y = xycoord . second + 150 - LOCPLINT - > cb - > battleGetCreature ( ID ) . rightMissleOffsetY ;
}
spi . lastStep = sqrt ( ( float ) ( ( destcoord . first - spi . x ) * ( destcoord . first - spi . x ) + ( destcoord . second - spi . y ) * ( destcoord . second - spi . y ) ) ) / 40 ;
spi . dx = ( destcoord . first - spi . x ) / spi . lastStep ;
spi . dy = ( destcoord . second - spi . y ) / spi . lastStep ;
//set starting frame
if ( spi . spin )
{
spi . frameNum = 0 ;
}
else
{
spi . frameNum = ( ( M_PI / 2.0f - projectileAngle ) / ( 2.0f * M_PI ) + 1 / ( ( float ) ( 2 * ( idToProjectile [ spi . creID ] - > ourImages . size ( ) - 1 ) ) ) ) * ( idToProjectile [ spi . creID ] - > ourImages . size ( ) - 1 ) ;
}
//set delay
spi . animStartDelay = CGI - > creh - > creatures [ spi . creID ] . attackClimaxFrame ;
projectiles . push_back ( spi ) ;
//attack aniamtion
attackingInfo = new CAttHelper ;
attackingInfo - > dest = dest ;
attackingInfo - > frame = 0 ;
attackingInfo - > ID = ID ;
attackingInfo - > reversing = false ;
attackingInfo - > shooting = true ;
if ( projectileAngle > straightAngle ) //upper shot
attackingInfo - > shootingGroup = 14 ;
else if ( projectileAngle < - straightAngle ) //lower shot
attackingInfo - > shootingGroup = 15 ;
else //straight shot
attackingInfo - > shootingGroup = 16 ;
attackingInfo - > maxframe = creAnims [ ID ] - > framesInGroup ( attackingInfo - > shootingGroup ) ;
}
2008-03-29 12:59:18 +02:00
void CBattleInterface : : showRange ( SDL_Surface * to , int ID )
2008-03-23 19:25:38 +02:00
{
2008-08-31 20:23:40 +03:00
/*for(int i=0; i<shadedHexes.size(); ++i)
2008-03-23 19:25:38 +02:00
{
2008-03-29 12:59:18 +02:00
CSDL_Ext : : blit8bppAlphaTo24bpp ( CBattleInterface : : cellShade , NULL , to , & bfield [ shadedHexes [ i ] ] . pos ) ;
2008-08-31 20:23:40 +03:00
} */
CSDL_Ext : : blit8bppAlphaTo24bpp ( shadedHexesGraphic , NULL , to , NULL ) ;
2008-03-23 19:25:38 +02:00
}
2008-06-11 04:58:18 +03:00
void CBattleInterface : : attackingShowHelper ( )
{
if ( attackingInfo & & ! attackingInfo - > reversing )
{
if ( attackingInfo - > frame = = 0 )
{
2008-07-02 11:39:56 +03:00
CStack aStack = * LOCPLINT - > cb - > battleGetStackByID ( attackingInfo - > ID ) ; //attacking stack
2008-08-02 18:08:03 +03:00
if ( attackingInfo - > shooting )
2008-06-11 04:58:18 +03:00
{
2008-08-02 18:08:03 +03:00
creAnims [ attackingInfo - > ID ] - > setType ( attackingInfo - > shootingGroup ) ;
2008-06-11 04:58:18 +03:00
}
2008-08-02 18:08:03 +03:00
else
2008-06-11 04:58:18 +03:00
{
2008-08-02 18:08:03 +03:00
if ( aStack . creature - > isDoubleWide ( ) )
2008-06-11 04:58:18 +03:00
{
2008-08-06 20:49:47 +03:00
switch ( BattleInfo : : mutualPosition ( aStack . position , attackingInfo - > dest ) ) //attack direction
2008-08-02 18:08:03 +03:00
{
case 0 :
creAnims [ attackingInfo - > ID ] - > setType ( 10 ) ;
break ;
case 1 :
creAnims [ attackingInfo - > ID ] - > setType ( 10 ) ;
break ;
case 2 :
creAnims [ attackingInfo - > ID ] - > setType ( 11 ) ;
break ;
case 3 :
creAnims [ attackingInfo - > ID ] - > setType ( 12 ) ;
break ;
case 4 :
creAnims [ attackingInfo - > ID ] - > setType ( 12 ) ;
break ;
case 5 :
creAnims [ attackingInfo - > ID ] - > setType ( 11 ) ;
break ;
}
}
else //else for if(aStack.creature->isDoubleWide())
{
2008-08-06 20:49:47 +03:00
switch ( BattleInfo : : mutualPosition ( aStack . position , attackingInfo - > dest ) ) //attack direction
2008-08-02 18:08:03 +03:00
{
case 0 :
creAnims [ attackingInfo - > ID ] - > setType ( 10 ) ;
break ;
case 1 :
creAnims [ attackingInfo - > ID ] - > setType ( 10 ) ;
break ;
case 2 :
creAnims [ attackingInfo - > ID ] - > setType ( 11 ) ;
break ;
case 3 :
creAnims [ attackingInfo - > ID ] - > setType ( 12 ) ;
break ;
case 4 :
creAnims [ attackingInfo - > ID ] - > setType ( 12 ) ;
break ;
case 5 :
creAnims [ attackingInfo - > ID ] - > setType ( 11 ) ;
break ;
}
2008-06-11 04:58:18 +03:00
}
}
}
else if ( attackingInfo - > frame = = ( attackingInfo - > maxframe - 1 ) )
{
attackingInfo - > reversing = true ;
2008-07-02 11:39:56 +03:00
CStack aStack = * LOCPLINT - > cb - > battleGetStackByID ( attackingInfo - > ID ) ; //attacking stack
2008-06-11 04:58:18 +03:00
if ( aStack . creature - > isDoubleWide ( ) )
{
2008-08-06 20:49:47 +03:00
switch ( BattleInfo : : mutualPosition ( aStack . position , attackingInfo - > dest ) ) //attack direction
2008-06-11 04:58:18 +03:00
{
case 0 :
//reverseCreature(ID, aStack.position, true);
break ;
case 1 :
break ;
case 2 :
break ;
case 3 :
break ;
case 4 :
//reverseCreature(ID, aStack.position, true);
break ;
case 5 :
reverseCreature ( attackingInfo - > ID , aStack . position , true ) ;
break ;
}
}
else //else for if(aStack.creature->isDoubleWide())
{
2008-08-06 20:49:47 +03:00
switch ( BattleInfo : : mutualPosition ( aStack . position , attackingInfo - > dest ) ) //attack direction
2008-06-11 04:58:18 +03:00
{
case 0 :
reverseCreature ( attackingInfo - > ID , aStack . position , true ) ;
break ;
case 1 :
break ;
case 2 :
break ;
case 3 :
break ;
case 4 :
reverseCreature ( attackingInfo - > ID , aStack . position , true ) ;
break ;
case 5 :
reverseCreature ( attackingInfo - > ID , aStack . position , true ) ;
break ;
}
}
attackingInfo - > reversing = false ;
creAnims [ attackingInfo - > ID ] - > setType ( 2 ) ;
delete attackingInfo ;
attackingInfo = NULL ;
}
if ( attackingInfo )
{
attackingInfo - > frame + + ;
}
}
}
void CBattleInterface : : printConsoleAttacked ( int ID , int dmg , int killed , int IDby )
{
char tabh [ 200 ] ;
2008-07-02 11:39:56 +03:00
CStack attacker = * LOCPLINT - > cb - > battleGetStackByID ( IDby ) ;
CStack defender = * LOCPLINT - > cb - > battleGetStackByID ( ID ) ;
2008-06-11 04:58:18 +03:00
int end = sprintf ( tabh , CGI - > generaltexth - > allTexts [ attacker . amount > 1 ? 377 : 376 ] . c_str ( ) ,
( attacker . amount > 1 ? attacker . creature - > namePl . c_str ( ) : attacker . creature - > nameSing . c_str ( ) ) ,
dmg ) ;
if ( killed > 0 )
{
if ( killed > 1 )
{
sprintf ( tabh + end , CGI - > generaltexth - > allTexts [ 379 ] . c_str ( ) , killed , defender . creature - > namePl . c_str ( ) ) ;
}
else //killed == 1
{
sprintf ( tabh + end , CGI - > generaltexth - > allTexts [ 378 ] . c_str ( ) , defender . creature - > nameSing . c_str ( ) ) ;
}
}
console - > addText ( std : : string ( tabh ) ) ;
}
2008-08-02 18:08:03 +03:00
void CBattleInterface : : projectileShowHelper ( SDL_Surface * to )
{
if ( to = = NULL )
to = screen ;
std : : list < std : : list < SProjectileInfo > : : iterator > toBeDeleted ;
for ( std : : list < SProjectileInfo > : : iterator it = projectiles . begin ( ) ; it ! = projectiles . end ( ) ; + + it )
{
if ( it - > animStartDelay > 0 )
{
- - ( it - > animStartDelay ) ;
continue ;
}
SDL_Rect dst ;
dst . h = idToProjectile [ it - > creID ] - > ourImages [ it - > frameNum ] . bitmap - > h ;
dst . w = idToProjectile [ it - > creID ] - > ourImages [ it - > frameNum ] . bitmap - > w ;
dst . x = it - > x ;
dst . y = it - > y ;
CSDL_Ext : : blit8bppAlphaTo24bpp ( idToProjectile [ it - > creID ] - > ourImages [ it - > frameNum ] . bitmap , NULL , to , & dst ) ;
//actualizing projectile
+ + it - > step ;
if ( it - > step = = it - > lastStep )
{
toBeDeleted . insert ( toBeDeleted . end ( ) , it ) ;
}
else
{
it - > x + = it - > dx ;
it - > y + = it - > dy ;
if ( it - > spin )
{
+ + ( it - > frameNum ) ;
it - > frameNum % = idToProjectile [ it - > creID ] - > ourImages . size ( ) ;
}
}
}
for ( std : : list < std : : list < SProjectileInfo > : : iterator > : : iterator it = toBeDeleted . begin ( ) ; it ! = toBeDeleted . end ( ) ; + + it )
{
projectiles . erase ( * it ) ;
}
}
2008-03-03 21:41:10 +02:00
void CBattleHero : : show ( SDL_Surface * to )
{
2008-04-14 21:24:46 +03:00
//animation of flag
if ( flip )
{
CSDL_Ext : : blit8bppAlphaTo24bpp ( flag - > ourImages [ flagAnim ] . bitmap , NULL , screen , & genRect ( flag - > ourImages [ flagAnim ] . bitmap - > h , flag - > ourImages [ flagAnim ] . bitmap - > w , 752 , 39 ) ) ;
}
else
{
CSDL_Ext : : blit8bppAlphaTo24bpp ( flag - > ourImages [ flagAnim ] . bitmap , NULL , screen , & genRect ( flag - > ourImages [ flagAnim ] . bitmap - > h , flag - > ourImages [ flagAnim ] . bitmap - > w , 31 , 39 ) ) ;
}
{
+ + flagAnim ;
flagAnim % = flag - > ourImages . size ( ) ;
}
//animation of hero
2008-03-03 21:41:10 +02:00
int tick = - 1 ;
for ( int i = 0 ; i < dh - > ourImages . size ( ) ; + + i )
{
if ( dh - > ourImages [ i ] . groupNumber = = phase )
+ + tick ;
if ( tick = = image )
{
2008-03-04 19:25:58 +02:00
SDL_Rect posb = pos ;
CSDL_Ext : : blit8bppAlphaTo24bpp ( dh - > ourImages [ i ] . bitmap , NULL , to , & posb ) ;
2008-03-03 21:41:10 +02:00
+ + image ;
if ( dh - > ourImages [ i + 1 ] . groupNumber ! = phase ) //back to appropriate frame
{
image = 0 ;
}
break ;
}
}
2008-03-04 19:25:58 +02:00
}
CBattleHero : : CBattleHero ( std : : string defName , int phaseG , int imageG , bool flipG , unsigned char player ) : phase ( phaseG ) , image ( imageG ) , flip ( flipG ) , flagAnim ( 0 )
{
2008-06-12 09:45:51 +03:00
dh = CDefHandler : : giveDef ( defName ) ;
2008-03-04 19:25:58 +02:00
for ( int i = 0 ; i < dh - > ourImages . size ( ) ; + + i ) //transforming images
{
if ( flip )
2008-04-20 18:56:03 +03:00
{
SDL_Surface * hlp = CSDL_Ext : : rotate01 ( dh - > ourImages [ i ] . bitmap ) ;
2008-08-02 18:08:03 +03:00
SDL_FreeSurface ( dh - > ourImages [ i ] . bitmap ) ;
2008-04-20 18:56:03 +03:00
dh - > ourImages [ i ] . bitmap = hlp ;
}
2008-03-04 19:25:58 +02:00
dh - > ourImages [ i ] . bitmap = CSDL_Ext : : alphaTransform ( dh - > ourImages [ i ] . bitmap ) ;
}
dh - > alphaTransformed = true ;
if ( flip )
2008-06-12 09:45:51 +03:00
flag = CDefHandler : : giveDef ( " CMFLAGR.DEF " ) ;
2008-03-04 19:25:58 +02:00
else
2008-06-12 09:45:51 +03:00
flag = CDefHandler : : giveDef ( " CMFLAGL.DEF " ) ;
2008-03-04 19:25:58 +02:00
2008-03-10 22:19:41 +02:00
//coloring flag and adding transparency
2008-03-04 19:25:58 +02:00
for ( int i = 0 ; i < flag - > ourImages . size ( ) ; + + i )
{
flag - > ourImages [ i ] . bitmap = CSDL_Ext : : alphaTransform ( flag - > ourImages [ i ] . bitmap ) ;
2008-06-30 03:06:41 +03:00
graphics - > blueToPlayersAdv ( flag - > ourImages [ i ] . bitmap , player ) ;
2008-03-04 19:25:58 +02:00
}
2008-03-03 21:41:10 +02:00
}
CBattleHero : : ~ CBattleHero ( )
{
delete dh ;
2008-03-04 19:25:58 +02:00
delete flag ;
2008-03-03 21:41:10 +02:00
}
2008-03-10 22:19:41 +02:00
2008-04-14 21:24:46 +03:00
std : : pair < int , int > CBattleHex : : getXYUnitAnim ( int hexNum , bool attacker , CCreature * creature )
2008-03-10 22:19:41 +02:00
{
std : : pair < int , int > ret = std : : make_pair ( - 500 , - 500 ) ; //returned value
ret . second = - 139 + 42 * ( hexNum / 17 ) ; //counting y
//counting x
if ( attacker )
{
ret . first = - 160 + 22 * ( ( ( hexNum / 17 ) + 1 ) % 2 ) + 44 * ( hexNum % 17 ) ;
}
else
{
ret . first = - 219 + 22 * ( ( ( hexNum / 17 ) + 1 ) % 2 ) + 44 * ( hexNum % 17 ) ;
}
2008-04-14 21:24:46 +03:00
//shifting position for double - hex creatures
if ( creature - > isDoubleWide ( ) )
{
if ( attacker )
{
ret . first - = 42 ;
}
else
{
ret . first + = 42 ;
}
}
2008-03-10 22:19:41 +02:00
//returning
return ret ;
}
void CBattleHex : : activate ( )
{
Hoverable : : activate ( ) ;
2008-03-15 19:48:05 +02:00
MotionInterested : : activate ( ) ;
2008-03-24 15:25:11 +02:00
ClickableL : : activate ( ) ;
2008-05-27 16:16:35 +03:00
ClickableR : : activate ( ) ;
2008-03-10 22:19:41 +02:00
}
void CBattleHex : : deactivate ( )
{
2008-03-15 19:48:05 +02:00
Hoverable : : deactivate ( ) ;
MotionInterested : : deactivate ( ) ;
2008-03-24 15:25:11 +02:00
ClickableL : : deactivate ( ) ;
2008-05-27 16:16:35 +03:00
ClickableR : : deactivate ( ) ;
2008-03-10 22:19:41 +02:00
}
void CBattleHex : : hover ( bool on )
{
hovered = on ;
Hoverable : : hover ( on ) ;
2008-06-11 04:58:18 +03:00
if ( ! on & & setAlterText )
{
myInterface - > console - > alterTxt = std : : string ( ) ;
setAlterText = false ;
}
2008-03-10 22:19:41 +02:00
}
2008-06-11 04:58:18 +03:00
CBattleHex : : CBattleHex ( ) : myNumber ( - 1 ) , accesible ( true ) , hovered ( false ) , strictHovered ( false ) , myInterface ( NULL ) , setAlterText ( false )
2008-03-10 22:19:41 +02:00
{
}
2008-03-15 19:48:05 +02:00
void CBattleHex : : mouseMoved ( SDL_MouseMotionEvent & sEvent )
{
if ( CBattleInterface : : cellShade )
{
if ( CSDL_Ext : : SDL_GetPixel ( CBattleInterface : : cellShade , sEvent . x - pos . x , sEvent . y - pos . y ) = = 0 ) //hovered pixel is outside hex
{
strictHovered = false ;
}
else //hovered pixel is inside hex
{
strictHovered = true ;
2008-08-07 03:38:44 +03:00
if ( myInterface - > activeStack > = 0 )
{
if ( std : : find ( myInterface - > shadedHexes . begin ( ) , myInterface - > shadedHexes . end ( ) , myNumber ) = = myInterface - > shadedHexes . end ( ) )
{
2008-08-09 02:02:32 +03:00
CStack * shere = LOCPLINT - > cb - > battleGetStackByPos ( myNumber ) ;
if ( shere )
{
if ( shere - > owner = = LOCPLINT - > playerID ) //our stack
CGI - > curh - > changeGraphic ( 1 , 5 ) ;
else if ( LOCPLINT - > cb - > battleGetStackByID ( myInterface - > activeStack ) - > creature - > isShooting ( ) ) //we can shoot enemy
CGI - > curh - > changeGraphic ( 1 , 3 ) ;
else //unavailable enemy
CGI - > curh - > changeGraphic ( 1 , 0 ) ;
}
else //empty unavailable tile
CGI - > curh - > changeGraphic ( 1 , 0 ) ;
2008-08-07 03:38:44 +03:00
}
2008-08-09 02:02:32 +03:00
else //available tile
2008-08-07 03:38:44 +03:00
{
if ( LOCPLINT - > cb - > battleGetStackByID ( myInterface - > activeStack ) - > creature - > isFlying ( ) )
CGI - > curh - > changeGraphic ( 1 , 2 ) ;
else
CGI - > curh - > changeGraphic ( 1 , 1 ) ;
}
}
2008-03-15 19:48:05 +02:00
}
}
2008-06-11 04:58:18 +03:00
if ( hovered & & strictHovered ) //print attacked creature to console
{
if ( myInterface - > console - > alterTxt . size ( ) = = 0 & & LOCPLINT - > cb - > battleGetStack ( myNumber ) ! = - 1 & &
2008-07-02 11:39:56 +03:00
LOCPLINT - > cb - > battleGetStackByPos ( myNumber ) - > owner ! = LOCPLINT - > playerID & &
LOCPLINT - > cb - > battleGetStackByPos ( myNumber ) - > alive )
2008-06-11 04:58:18 +03:00
{
char tabh [ 160 ] ;
2008-07-02 11:39:56 +03:00
CStack attackedStack = * LOCPLINT - > cb - > battleGetStackByPos ( myNumber ) ;
2008-06-11 04:58:18 +03:00
std : : string attackedName = attackedStack . amount = = 1 ? attackedStack . creature - > nameSing : attackedStack . creature - > namePl ;
sprintf ( tabh , CGI - > generaltexth - > allTexts [ 220 ] . c_str ( ) , attackedName . c_str ( ) ) ;
myInterface - > console - > alterTxt = std : : string ( tabh ) ;
setAlterText = true ;
}
}
else if ( setAlterText )
{
myInterface - > console - > alterTxt = std : : string ( ) ;
setAlterText = false ;
}
2008-03-15 19:48:05 +02:00
}
2008-03-24 15:25:11 +02:00
void CBattleHex : : clickLeft ( boost : : logic : : tribool down )
{
2008-03-24 21:04:30 +02:00
if ( ! down & & hovered & & strictHovered ) //we've been really clicked!
{
myInterface - > hexLclicked ( myNumber ) ;
}
2008-03-24 15:25:11 +02:00
}
2008-04-16 20:21:02 +03:00
2008-05-27 16:16:35 +03:00
void CBattleHex : : clickRight ( boost : : logic : : tribool down )
{
int stID = LOCPLINT - > cb - > battleGetStack ( myNumber ) ; //id of stack being on this tile
if ( hovered & & strictHovered & & stID ! = - 1 )
{
2008-07-02 11:39:56 +03:00
CStack myst = * LOCPLINT - > cb - > battleGetStackByID ( stID ) ; //stack info
2008-08-09 02:02:32 +03:00
if ( ! myst . alive ) return ;
2008-05-27 16:16:35 +03:00
StackState * pom = NULL ;
if ( down )
{
pom = new StackState ( ) ;
const CGHeroInstance * h = myst . owner = = myInterface - > attackingHeroInstance - > tempOwner ? myInterface - > attackingHeroInstance : myInterface - > defendingHeroInstance ;
2008-06-04 16:00:56 +03:00
if ( h )
{
pom - > attackBonus = h - > primSkills [ 0 ] ;
pom - > defenseBonus = h - > primSkills [ 1 ] ;
pom - > luck = h - > getCurrentLuck ( ) ;
pom - > morale = h - > getCurrentMorale ( ) ;
2008-08-09 02:02:32 +03:00
pom - > currentHealth = myst . firstHPleft ;
2008-06-04 16:00:56 +03:00
}
2008-08-16 11:47:41 +03:00
( new CCreInfoWindow ( myst . creature - > idNumber , 0 , myst . amount , pom , boost : : function < void ( ) > ( ) , boost : : function < void ( ) > ( ) , NULL ) )
2008-05-27 16:16:35 +03:00
- > activate ( ) ;
}
delete pom ;
}
}
2008-06-11 04:58:18 +03:00
CBattleConsole : : CBattleConsole ( ) : lastShown ( - 1 ) , alterTxt ( " " )
2008-04-16 20:21:02 +03:00
{
}
CBattleConsole : : ~ CBattleConsole ( )
{
texts . clear ( ) ;
}
void CBattleConsole : : show ( SDL_Surface * to )
{
2008-06-11 04:58:18 +03:00
if ( alterTxt . size ( ) )
{
CSDL_Ext : : printAtMiddleWB ( alterTxt , pos . x + pos . w / 2 , pos . y + 10 , GEOR13 , 80 , zwykly , to ) ;
}
else if ( texts . size ( ) )
2008-04-16 20:21:02 +03:00
{
if ( texts . size ( ) = = 1 )
{
CSDL_Ext : : printAtMiddleWB ( texts [ 0 ] , pos . x + pos . w / 2 , pos . y + 10 , GEOR13 , 80 , zwykly , to ) ;
}
else
{
CSDL_Ext : : printAtMiddleWB ( texts [ lastShown - 1 ] , pos . x + pos . w / 2 , pos . y + 10 , GEOR13 , 80 , zwykly , to ) ;
CSDL_Ext : : printAtMiddleWB ( texts [ lastShown ] , pos . x + pos . w / 2 , pos . y + 26 , GEOR13 , 80 , zwykly , to ) ;
}
}
}
bool CBattleConsole : : addText ( std : : string text )
{
if ( text . size ( ) > 70 )
return false ; //text too long!
2008-06-11 04:58:18 +03:00
int firstInToken = 0 ;
for ( int i = 0 ; i < text . size ( ) ; + + i ) //tokenize
{
if ( text [ i ] = = 10 )
{
texts . push_back ( text . substr ( firstInToken , i - firstInToken ) ) ;
firstInToken = i + 1 ;
}
}
texts . push_back ( text . substr ( firstInToken , text . size ( ) ) ) ;
2008-06-21 16:27:52 +03:00
lastShown = texts . size ( ) - 1 ;
2008-04-16 20:21:02 +03:00
return true ;
}
void CBattleConsole : : eraseText ( unsigned int pos )
{
if ( pos < texts . size ( ) )
{
texts . erase ( texts . begin ( ) + pos ) ;
if ( lastShown = = texts . size ( ) )
- - lastShown ;
}
}
void CBattleConsole : : changeTextAt ( std : : string text , unsigned int pos )
{
if ( pos > = texts . size ( ) ) //no such pos
return ;
texts [ pos ] = text ;
}
void CBattleConsole : : scrollUp ( unsigned int by )
{
if ( lastShown > by )
lastShown - = by ;
}
void CBattleConsole : : scrollDown ( unsigned int by )
{
if ( lastShown + by < texts . size ( ) )
lastShown + = by ;
}