will/SleepIsDeath
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
701d667408
SleepIsDeath/gameSource/GameStateDisplay.cpp

1538 lines
43 KiB
C++
Raw Normal View History

Exported latest revision from sourceforge cvs, discarding history.
2017-10-11 20:16:19 +00:00
#include "GameStateDisplay.h"
#include "common.h"
#include "SpriteResource.h"
#include "GameStateEditor.h"
#include "minorGems/graphics/openGL/gui/TextGL.h"
#include "minorGems/util/stringUtils.h"
extern TextGL *largeText;
GameStateDisplay::GameStateDisplay( int inAnchorX, int inAnchorY,
char inShowObjectToolTips )
: GUIComponentGL( inAnchorX, inAnchorY,
G * P, G * P ),
mHasAnySpeechBeenAutoFlipped( false ),
mManualBubblePositioningLive( false ),
mLastPixelClickX( 0 ), mLastPixelClickY( 0 ),
mLastGridClickX( 0 ), mLastGridClickY( 0 ),
mLastActionRelease( false ),
mLastActionPress( false ),
mLastActionKeyPress( false ),
mLastMouseoverObjectIndex( -1 ),
mMouseHover( false ),
mLastHoverGridX( 0 ), mLastHoverGridY( 0 ),
mEditingSpeech( false ),
mEditingAction( false ),
mHighlightEditedBubble( false ),
mShowObjectToolTips( inShowObjectToolTips ),
mEditor( NULL ),
mFocused( false ),
mShowGrid( true ),
mHintMode( false ),
mState( NULL ),
mLastSelected( -1 ),
mBlinkCycle( 0 ) {
for( int y=0; y<G; y++ ) {
for( int x=0; x<G; x++ ) {
mSprites[y][x] = NULL;
}
}
mBubbleTopSprite = new Sprite( "bubbleTop.tga", true );
mBubbleMiddleSprite = new Sprite( "bubbleMiddle.tga", true );
mBubbleMiddleExtraSprite = new Sprite( "bubbleMiddleExtra.tga", true );
mBubbleMiddleExtraThinSprite = new Sprite( "bubbleMiddleExtraThin.tga",
true );
mBubbleBottomSprite = new Sprite( "bubbleBottom.tga", true );
mBubbleBottomSpriteFlip = new Sprite( "bubbleBottomFlip.tga", true );
mBubbleBottomNoTailSprite = new Sprite( "bubbleBottomNoTail.tga", true );
mBubbleMiddleTailSprite = new Sprite( "bubbleMiddleTail.tga", true );
mBubbleMiddleTailFlipSprite =
new Sprite( "bubbleMiddleTailFlip.tga", true );
mSpeechBoxTopSprite = new Sprite( "speechBoxTop.tga", true );
mSpeechBoxBottomSprite = new Sprite( "speechBoxBottom.tga", true );
mActionBoxStartSprite = new Sprite( "actionBoxStart.tga", true );
mActionBoxMiddleSprite = new Sprite( "actionBoxMiddle.tga", true );
mActionBoxMiddleExtraSprite =
new Sprite( "actionBoxMiddleExtra.tga", true );
mActionBoxEndSprite = new Sprite( "actionBoxEnd.tga", true );
mActionBoxEndFlipSprite = new Sprite( "actionBoxEndFlip.tga", true );
mActionBoxStartTallSprite = new Sprite( "actionBoxStartTall.tga", true );
mActionBoxMiddleTallSprite = new Sprite( "actionBoxMiddleTall.tga", true );
mActionBoxMiddleExtraTallSprite =
new Sprite( "actionBoxMiddleExtraTall.tga", true );
mActionBoxEndTallSprite = new Sprite( "actionBoxEndTall.tga", true );
mActionBoxEndFlipTallSprite = new Sprite( "actionBoxEndFlipTall.tga", true );
}
GameStateDisplay::~GameStateDisplay() {
for( int y=0; y<G; y++ ) {
for( int x=0; x<G; x++ ) {
if( mSprites[y][x] != NULL ) {
delete mSprites[y][x];
}
}
}
int numSprites = mObjectSprites.size();
for( int s=0; s<numSprites; s++ ) {
delete *( mObjectSprites.getElement( s ) );
}
if( mState != NULL ) {
delete mState;
}
delete mBubbleTopSprite;
delete mBubbleMiddleSprite;
delete mBubbleMiddleExtraSprite;
delete mBubbleMiddleExtraThinSprite;
delete mBubbleBottomSprite;
delete mBubbleBottomSpriteFlip;
delete mBubbleBottomNoTailSprite;
delete mBubbleMiddleTailSprite;
delete mBubbleMiddleTailFlipSprite;
delete mSpeechBoxTopSprite;
delete mSpeechBoxBottomSprite;
delete mActionBoxStartSprite;
delete mActionBoxMiddleSprite;
delete mActionBoxMiddleExtraSprite;
delete mActionBoxEndSprite;
delete mActionBoxEndFlipSprite;
delete mActionBoxStartTallSprite;
delete mActionBoxMiddleTallSprite;
delete mActionBoxMiddleExtraTallSprite;
delete mActionBoxEndTallSprite;
delete mActionBoxEndFlipTallSprite;
}
void GameStateDisplay::setEditor( void *inEditor ) {
mEditor = inEditor;
}
void GameStateDisplay::setState( GameState *inState ) {
//printf( "Before updating state, %d sprites\n", mObjectSprites.size() );
/*
char newRoom = false;
if( !equal( inState.mRoom.getID(), mState.mRoom.getID() ) {
newRoom = true;
}
*/
if( mState != NULL ) {
delete mState;
}
mState = inState;
for( int y=0; y<G; y++ ) {
for( int x=0; x<G; x++ ) {
if( mSprites[y][x] != NULL ) {
delete mSprites[y][x];
}
Tile t( mState->mRoom.getTile( x, y ) );
mSprites[y][x] = t.getSprite();
}
}
// clear old
int numSprites = mObjectSprites.size();
int i;
for( i=0; i<numSprites; i++ ) {
delete *( mObjectSprites.getElement( i ) );
}
mObjectSprites.deleteAll();
mObjectSpritePositions.deleteAll();
mObjectSpriteOwners.deleteAll();
mObjectSpriteTrans.deleteAll();
mObjectSpriteGlows.deleteAll();
mObjectSpriteDepth.deleteAll();
mObjectSpriteLocked.deleteAll();
mSpeechOffTop.deleteAll();
// add new
int numObjects = mState->mObjects.size();
// flag for 0
mSpeechOffTop.push_back( false );
// add 0 (player object) last so it's always on top
for( i=1; i<numObjects; i++ ) {
mSpeechOffTop.push_back( false );
addSpritesFromStateInstance( i );
}
// now do 0
addSpritesFromStateInstance( 0 );
//printf( "After updating state, %d sprites\n", mObjectSprites.size() );
recomputeDrawOrderMap();
}
void GameStateDisplay::addSpritesFromStateInstance( int inIndex ) {
int i = inIndex;
StateObjectInstance *o = *( mState->mObjects.getElement( i ) );
int numSprites = o->mObject.getNumLayers();
intPair anchorPos = o->mAnchorPosition;
int depth = G - (anchorPos.y / P) - 1;
for( int s=0; s<numSprites; s++ ) {
SpriteResource resource( o->mObject.getLayerSprite( s ) );
mObjectSprites.push_back( resource.getSprite() );
intPair p = o->mObject.getLayerOffset( s );
p = ::add( p, anchorPos );
mObjectSpritePositions.push_back( p );
// no owner flags for non-anchors
mObjectSpriteOwners.push_back( -1 );
float trans =
( o->mObjectTrans / 255.0f ) *
( o->mObject.getLayerTrans( s ) / 255.0f );
mObjectSpriteTrans.push_back( trans );
mObjectSpriteGlows.push_back( o->mObject.getLayerGlow( s ) );
mObjectSpriteDepth.push_back( depth );
mObjectSpriteLocked.push_back( o->mLocked );
}
// last, add anchor sprite for this object, on top
if( i==0 ) {
// special anchor for player
mObjectSprites.push_back( new Sprite( "playerAnchor.tga", true ) );
}
else {
mObjectSprites.push_back( new Sprite( "anchor.tga", true ) );
}
mObjectSpritePositions.push_back( o->mAnchorPosition );
// only "own" the anchors
mObjectSpriteOwners.push_back( i );
// anchors ignore trans and glow
mObjectSpriteTrans.push_back( 1.0 );
mObjectSpriteGlows.push_back( false );
// anchors are all on top
mObjectSpriteDepth.push_back( G );
mObjectSpriteLocked.push_back( o->mLocked );
}
int GameStateDisplay::updatePositionFromStateInstance( int inIndex,
int inSpriteIndex ) {
int i = inIndex;
StateObjectInstance *o = *( mState->mObjects.getElement( i ) );
int numSprites = o->mObject.getNumLayers();
intPair anchorPos = o->mAnchorPosition;
int depth = G - (anchorPos.y / P) - 1;
for( int s=0; s<numSprites; s++ ) {
intPair p = o->mObject.getLayerOffset( s );
p = ::add( p, anchorPos );
*( mObjectSpritePositions.getElement( inSpriteIndex ) ) = p;
float trans =
( o->mObjectTrans / 255.0f ) *
( o->mObject.getLayerTrans( s ) / 255.0f );
*( mObjectSpriteTrans.getElement( inSpriteIndex ) ) = trans;
*( mObjectSpriteGlows.getElement( inSpriteIndex ) ) =
o->mObject.getLayerGlow( s );
*( mObjectSpriteDepth.getElement( inSpriteIndex ) ) = depth;
*( mObjectSpriteLocked.getElement( inSpriteIndex ) ) = o->mLocked;
inSpriteIndex++;
}
*( mObjectSpritePositions.getElement( inSpriteIndex ) ) =
o->mAnchorPosition;
*( mObjectSpriteTrans.getElement( inSpriteIndex ) ) = 1.0;
*( mObjectSpriteGlows.getElement( inSpriteIndex ) ) = false;
*( mObjectSpriteLocked.getElement( inSpriteIndex ) ) = o->mLocked;
inSpriteIndex++;
return inSpriteIndex;
}
void GameStateDisplay::updateSpritePositions( GameState *inState ) {
if( mState != NULL ) {
delete mState;
}
mState = inState;
int numObjects = mState->mObjects.size();
int spriteIndex = 0;
// 0 last (player object on top)
for( int i=1; i<numObjects; i++ ) {
spriteIndex = updatePositionFromStateInstance( i, spriteIndex );
}
// now 0
spriteIndex = updatePositionFromStateInstance( 0, spriteIndex );
recomputeDrawOrderMap();
}
void GameStateDisplay::recomputeDrawOrderMap() {
mDrawOrderMap.deleteAll();
// G+1 bins
SimpleVector<int> depthBins[ G + 1 ];
int numSprites = mObjectSprites.size();
// put locked ones in first (behind) for each depth
for( int i=0; i<numSprites; i++ ) {
if( *( mObjectSpriteLocked.getElement( i ) ) ) {
int depth = *( mObjectSpriteDepth.getElement( i ) );
depthBins[depth].push_back( i );
}
}
// now unlocked ones in front at each depth
for( int i=0; i<numSprites; i++ ) {
if( ! *( mObjectSpriteLocked.getElement( i ) ) ) {
int depth = *( mObjectSpriteDepth.getElement( i ) );
depthBins[depth].push_back( i );
}
}
// dump bins in, in order
for( int b=0; b<=G; b++ ) {
int binSize = depthBins[b].size();
for( int i=0; i<binSize; i++ ) {
mDrawOrderMap.push_back( *( depthBins[b].getElement( i ) ) );
}
}
}
void GameStateDisplay::showGrid( char inShow ) {
mShowGrid = inShow;
}
void GameStateDisplay::setHintMode( char inHintsOnly ) {
mHintMode = inHintsOnly;
}
void GameStateDisplay::copySpeechCoordinates( GameState *inDestinationState ) {
int numObjects = mState->mObjects.size();
for( int i=0; i<numObjects; i++ ) {
StateObjectInstance *o = *( mState->mObjects.getElement( i ) );
StateObjectInstance *oDest =
*( inDestinationState->mObjects.getElement( i ) );
oDest->mSpeechFlip = o->mSpeechFlip;
oDest->mSpeechOffset = o->mSpeechOffset;
}
}
char GameStateDisplay::getSpeechOffTop( int inObject ) {
return *( mSpeechOffTop.getElement( inObject ) );
}
void GameStateDisplay::drawSpeech( int inIndex ) {
int i = inIndex;
int selected = mState->getSelectedObject();
Color *bubbleColor = NULL;
StateObjectInstance *o = *( mState->mObjects.getElement( i ) );
// skip any blank messages
// UNLESS we are editing text of selected
if( strlen( o->mSpokenMessage ) > 0
||
( i == selected && mEditingSpeech ) ) {
if( i == selected && isFocused() && mHighlightEditedBubble ) {
bubbleColor = new Color( 1.0f, 1.0f, 0.5f, 1.0f );
}
intPair pos = ::add( o->mSpeechOffset, o->mAnchorPosition );
double height = 8;
double width = strlen( o->mSpokenMessage ) * height;
double trueStringHeight = height *
largeText->measureTextHeight( o->mSpokenMessage );
char bubbleHasHighLines = false;
char bubbleHasReallyHighLines = false;
if( trueStringHeight > 8 ) {
// make room for high characters
bubbleHasHighLines = true;
}
if( trueStringHeight > 9 ) {
bubbleHasReallyHighLines = true;
}
int bubbleWidth = 64 - 8;
SimpleVector<char*> lines;
// new code: split into words first, ingore player's spacing.
// 1 space between words, two spaces after a period
SimpleVector<char*> *words = tokenizeString( o->mSpokenMessage );
int wordIndex = 0;
int numWords = words->size();
while( wordIndex < numWords ) {
// a word left
char *nextWord = *( words->getElement( wordIndex ) );
double nextWordWidth =
largeText->measureTextWidth( nextWord ) * height;
char *currentLine = NULL;
double currentWidth = 0;
int numLines = lines.size();
if( numLines > 0 ) {
currentLine = *( lines.getElement( numLines - 1 ) );
currentWidth =
largeText->measureTextWidth( currentLine ) * height;
}
char *spaceNeeded = (char *)" ";
int lastCharIndex = -1;
if( currentLine != NULL ) {
lastCharIndex = strlen( currentLine ) - 1;
}
if( currentLine != NULL &&
( currentLine[ lastCharIndex ] == '.' ||
currentLine[ lastCharIndex ] == '?' ||
currentLine[ lastCharIndex ] == '!' ) ) {
// line so far ends with period (or other sentence ender),
// extra space before next word in line
spaceNeeded = (char *)" ";
}
double spaceWidth =
largeText->measureTextWidth( spaceNeeded ) * height;
if( currentLine != NULL &&
currentWidth + spaceWidth + nextWordWidth
< bubbleWidth ) {
// good! we can add it
char *newLine = autoSprintf( "%s%s%s", currentLine,
spaceNeeded, nextWord );
delete [] currentLine;
*( lines.getElement( numLines - 1 ) ) = newLine;
delete [] nextWord;
}
else {
// not enough room on this line, or no line yet
// start a new one with just this word
if( nextWordWidth < bubbleWidth ) {
lines.push_back( nextWord );
}
else {
// problem! really long word
// split it into parts... make sure second part has at
// least 3 chars
char *partialWord = stringDuplicate( nextWord );
double hypenWidth = largeText->measureTextWidth( "-" );
while( ( hypenWidth +
largeText->measureTextWidth( partialWord ) )
* height
>= bubbleWidth ) {
// truncate
partialWord[ strlen( partialWord ) - 1 ] = '\0';
}
int partialLength = strlen( partialWord );
int nextWordLength = strlen( nextWord );
int extraLength = nextWordLength - partialLength;
while( extraLength < 3 ) {
// trim more off partial
partialWord[ partialLength - 1 ] = '\0';
partialLength -= 1;
extraLength ++;
}
// add hyphen
partialWord[ partialLength ] = '-';
partialWord[ partialLength + 1 ] = '\0';
lines.push_back( partialWord );
char *extraChars = stringDuplicate(
&( nextWord[ partialLength ] ) );
*( words->getElement( wordIndex ) ) = extraChars;
delete [] nextWord;
// part of the word still there, back up and look
// at it again
wordIndex --;
}
}
wordIndex ++;
}
delete words;
// start at bottom line and draw up
double bubbleFade = 0.63;
int flipSign = 1;
if( o->mSpeechFlip ) {
flipSign = -1;
}
// draw bottom w/ tip at anchor
Vector3D bubblePos( mAnchorX + pos.x + flipSign * 32,
mAnchorY + pos.y + 7,
0 );
if( o->mSpeechBox ) {
bubblePos.mY -= 8;
}
int numLines = lines.size();
int bubbleHeight = 7 + 9 * numLines + 7;
if( bubbleHasHighLines ) {
if( bubbleHasReallyHighLines ) {
// use extended mode
bubbleHeight = 7 + 12 * numLines + 7;
}
else {
// thin extended mode
bubbleHeight = 7 + 10 * numLines + 7;
}
}
char offTop = false;
if( bubblePos.mY + bubbleHeight > mHeight + mAnchorY ) {
offTop = true;
}
char oldOffTop = *( mSpeechOffTop.getElement( i ) );
*( mSpeechOffTop.getElement( i ) ) = offTop;
if( offTop != oldOffTop ) {
// a change in off-top status. Tell editor about it
mHasAnySpeechBeenAutoFlipped = true;
}
// auto-flip if off the side of screen
char flipThisBubble = o->mSpeechFlip;
int bubbleHalfWidth = 32;
int bubbleFullWidth = 64;
// off-top boxes are no wider
if( ! o->mSpeechBox &&
offTop && numLines > 0 ) {
bubbleHalfWidth += 10;
}
// apply flipping heuristic positioning
int autoFlipExtraOffset = mState->getAutoOffsetOnFlip( i );
if( mManualBubblePositioningLive ) {
// don't mess with the mouse, drop heuristic and go with
// mouse position
autoFlipExtraOffset = 0;
}
if( o->mSpeechFlip && bubblePos.mX - bubbleHalfWidth < mAnchorX ) {
// unflip
flipThisBubble = false;
bubblePos.mX += bubbleFullWidth;
bubblePos.mX += autoFlipExtraOffset;
// auto-flip this bubble for the future, too, so that mouse-based
// positioning
// works correctly, etc
o->mSpeechFlip = false;
o->mSpeechOffset.x += autoFlipExtraOffset;
// thus, we WON'T have to auto-flip next time we draw this same
// frame
mHasAnySpeechBeenAutoFlipped = true;
}
else if( ! o->mSpeechFlip && bubblePos.mX + bubbleHalfWidth >
mWidth + mAnchorX ) {
// force a flip
flipThisBubble = true;
bubblePos.mX -= bubbleFullWidth;
bubblePos.mX += autoFlipExtraOffset;
// again, permanently re-flip
o->mSpeechFlip = true;
o->mSpeechOffset.x += autoFlipExtraOffset;
mHasAnySpeechBeenAutoFlipped = true;
}
if( o->mSpeechFlip ) {
bubblePos.mX += 1;
}
Sprite *bottomSprite = mBubbleBottomSprite;
Sprite *middleTailSprite = mBubbleMiddleTailSprite;
if( flipThisBubble ) {
bottomSprite = mBubbleBottomSpriteFlip;
middleTailSprite = mBubbleMiddleTailFlipSprite;
}
if( o->mSpeechBox ) {
bottomSprite = mSpeechBoxBottomSprite;
// no middle tails
middleTailSprite = mBubbleMiddleSprite;
}
int lineWithTail = 0;
if( offTop ) {
if( !o->mSpeechBox ) {
if( numLines > 0 ) {
bottomSprite = mBubbleBottomNoTailSprite;
// scoot over to make room for horizontal tail
if( flipThisBubble ) {
bubblePos.mX -= 10;
}
else {
bubblePos.mX += 10;
}
// scoot the whole thing down by some number of lines
int linesToScoot = numLines;
//lineWithTail = numLines - 1;
while( bubblePos.mY + bubbleHeight > mHeight + mAnchorY
&&
linesToScoot > 0 ) {
bubblePos.mY -= 9;
if( linesToScoot == numLines ) {
// anchor pos for bubble is above bottom tail, now
// up aligned with a line instead.
bubblePos.mY -= 10;
}
linesToScoot --;
}
//bubblePos.mY -= 10;
// how many lines left?
lineWithTail = linesToScoot;
}
}
else {
// simply flush boxes with top... no tail to align!
bubblePos.mY -=
(bubblePos.mY + bubbleHeight)
- (mHeight + mAnchorY);
}
}
bottomSprite->draw( 0, 0, &bubblePos, 1,
bubbleFade,
bubbleColor );
bubblePos.mY += 4;
// draw lines of text last, to ensure they're on top of bubble parts
double *lineY = new double[numLines];
for( int i=numLines-1; i>=0; i-- ) {
bubblePos.mY += 8;
if( i < numLines - 1 ) {
// extra space for all but bottom line
bubblePos.mY += 1;
}
if( bubbleHasHighLines ) {
// extended line height mode
if( i < numLines - 1 ) {
// extra space for all but bottom line
bubblePos.mY += 1;
if( bubbleHasReallyHighLines ) {
bubblePos.mY += 2;
}
}
// padding above all but top line
if( i > 0 ) {
if( bubbleHasReallyHighLines ) {
mBubbleMiddleExtraSprite->draw( 0, 0, &bubblePos, 1,
bubbleFade,
bubbleColor );
}
else {
mBubbleMiddleExtraThinSprite->draw(
0, 0, &bubblePos, 1,
bubbleFade,
bubbleColor );
}
}
}
if( offTop && lineWithTail == i ) {
// normal line
middleTailSprite->draw( 0, 0, &bubblePos, 1,
bubbleFade,
bubbleColor );
}
else {
// normal line
mBubbleMiddleSprite->draw( 0, 0, &bubblePos, 1,
bubbleFade,
bubbleColor );
}
lineY[i] = bubblePos.mY - 4;
/*
char *line = *( lines.getElement( i ) );
width = strlen( line ) * height;
glColor4f( 0, 0, 0, 1 );
largeText->drawText( line,
bubblePos.mX - 32 + 4,
bubblePos.mY - 4,
width, height );
delete [] line;
*/
}
bubblePos.mY += 7;
if( numLines > 0 ) {
// extra space before top
bubblePos.mY += 1;
}
if( o->mSpeechBox ) {
// flip, because this one is upside down in file (so lower
// corner can have transparency)
mSpeechBoxTopSprite->draw( 0, 0, &bubblePos, -1, bubbleFade,
bubbleColor );
}
else {
mBubbleTopSprite->draw( 0, 0, &bubblePos, 1, bubbleFade,
bubbleColor );
}
// lines last
for( int i=numLines-1; i>=0; i-- ) {
char *line = *( lines.getElement( i ) );
width = strlen( line ) * height;
glColor4f( 0, 0, 0, 1 );
largeText->drawText( line,
bubblePos.mX - 32 + 4,
lineY[i],
width, height );
delete [] line;
}
delete []lineY;
}
if( bubbleColor != NULL ) {
delete bubbleColor;
}
}
// defined in ScreenGL_SDL.cpp
// we draw object hint mode differently depending on this
extern char screenGLStencilBufferSupported;
void GameStateDisplay::fireRedraw() {
// invisible if disabled
if( !mEnabled ) {
return;
}
if( ! mHintMode ) {
double roomTrans = mState->mRoomTrans / 255.0;
for( int y=0; y<G; y++ ) {
for( int x=0; x<G; x++ ) {
if( mSprites[y][x] != NULL ) {
Vector3D pos( mAnchorX + x * P + P/2,
mAnchorY + mHeight - (y * P + P/2), 0 );
mSprites[y][x]->draw( 0, 0, &pos, 1, roomTrans );
}
}
}
}
if( mHintMode && screenGLStencilBufferSupported ) {
// use stenciling to draw *shadows* of sprites only
// don't update color
glColorMask( GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE );
// skip fully-transparent areas
glEnable( GL_ALPHA_TEST );
glAlphaFunc( GL_GREATER, 0 );
// Draw 1 into the stencil buffer wherever a sprite is
glEnable( GL_STENCIL_TEST );
glStencilOp( GL_REPLACE, GL_REPLACE, GL_REPLACE );
glStencilFunc( GL_ALWAYS, 1, 0xffffffff );
}
// now draw all sprites
int numSprites = mObjectSprites.size();
int selected = mState->getSelectedObject();
if( mLastSelected != selected || ! mShowGrid ) {
// reset
mBlinkCycle = 0;
mLastSelected = selected;
}
else {
mBlinkCycle ++;
}
double blinkFadeFactor = 0.35 * sin( mBlinkCycle / 3.0 ) + 0.65;
//printf( "Drawing %d sprites, %d selected\n", numSprites, selected );
for( int i=0; i<numSprites; i++ ) {
// map index to sort by depth
int s = *( mDrawOrderMap.getElement( i ) );
Sprite *sprite = *( mObjectSprites.getElement( s ) );
intPair pixelPos = *( mObjectSpritePositions.getElement( s ) );
int owner = *( mObjectSpriteOwners.getElement( s ) );
Vector3D pos( mAnchorX + pixelPos.x + P/2,
mAnchorY + pixelPos.y + P/2, 0 );
char drawIt = true;
Color c( 1, 1, 1, 1 );
double fadeFactor = *( mObjectSpriteTrans.getElement( s ) );
if( owner != -1 ) {
// an anchor, override fade
fadeFactor = 0.5;
if( owner == selected ) {
fadeFactor *= blinkFadeFactor;
if( owner != 0 ) {
// green
c.r = 0;
c.b = 0;
}
else if( owner == 0 ) {
// player's object selected in red
c.g = 0;
c.b = 0;
}
}
if( !mShowGrid || mHintMode ) {
// hide anchors
drawIt = false;
}
else if( mState->mLocksOn ) {
// anchors on... but for this object?
StateObjectInstance *o =
*( mState->mObjects.getElement( owner ) );
if( o->mLocked ) {
drawIt = false;
}
}
}
if( drawIt ) {
char glow = *( mObjectSpriteGlows.getElement( s ) );
if( glow ) {
// brighten only
glBlendFunc( GL_SRC_ALPHA, GL_ONE );
}
if( mHintMode ) {
// override fade
fadeFactor = 0.25;
// black color
c.r = 0;
c.g = 0;
c.b = 0;
}
sprite->draw( 0, 0, &pos, 1, fadeFactor, &c );
if( glow ) {
// back to normal blend
glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
}
}
}
if( mHintMode && screenGLStencilBufferSupported ) {
// stencil buffer has 1 wherever sprite is
// Re-enable update of color
glColorMask( GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE );
glDisable( GL_ALPHA_TEST );
// Now, only render where stencil is set to 1.
glStencilFunc( GL_EQUAL, 1, 0xffffffff ); // draw if == 1
glStencilOp( GL_KEEP, GL_KEEP, GL_KEEP );
// draw a big dark rectangle, cut out by stenciled areas
glColor4f( 0, 0, 0, 0.25f );
glBegin( GL_QUADS ); {
glVertex2d( mAnchorX, mAnchorY );
glVertex2d( mAnchorX, mAnchorY + mHeight );
glVertex2d( mAnchorX + mWidth, mAnchorY + mHeight );
glVertex2d( mAnchorX + mWidth, mAnchorY );
}
glEnd();
// draw diagonal yellow hash lines cut out by stenciled areas
glColor4f( 1, 1, 1, 0.25f );
glBegin( GL_LINES ); {
for( int x=0; x<mWidth; x+=3 ) {
glVertex2d( mAnchorX + x, mAnchorY );
glVertex2d( mAnchorX, mAnchorY + x );
glVertex2d( mAnchorX + x + 2, mAnchorY + mHeight );
glVertex2d( mAnchorX + mWidth + 2, mAnchorY + x );
}
}
glEnd();
// back to unstenciled drawing
glDisable( GL_STENCIL_TEST );
glClear( GL_STENCIL_BUFFER_BIT );
}
Color *oldFontColor = largeText->getFontColor()->copy();
largeText->setFontColor( new Color( 0, 0, 0, 1 ) );
if( ! mHintMode ) {
// draw speech for each object
int numObjects = mState->mObjects.size();
// put 0's speech on top
for( int i=1; i<numObjects; i++ ) {
drawSpeech( i );
}
drawSpeech( 0 );
}
// draw any action text for object 0
StateObjectInstance *o = *( mState->mObjects.getElement( 0 ) );
if( ! mHintMode &&
( strlen( o->mAction ) > 0
||
( 0 == selected && mEditingAction ) ) ) {
intPair pos = ::add( o->mActionOffset, o->mAnchorPosition );
double height = 8;
double width = strlen( o->mAction ) * height;
double trueLength = largeText->measureTextWidth( o->mAction ) * height;
int totalArrowLength = (int)trueLength + 10;
double trueStringHeight = height *
largeText->measureTextHeight( o->mAction );
char actionTall = false;
if( trueStringHeight > 9 ) {
// make room for high characters
actionTall = true;
}
// flip anchor if on left side of player
int flip = 1;
Sprite *endSprite = mActionBoxEndSprite;
if( o->mActionOffset.x < P/2 ) {
flip = -1;
endSprite = mActionBoxEndFlipSprite;
}
if( flip == 1 && pos.x - totalArrowLength < 0 ) {
// off left, force flip
flip = -1;
endSprite = mActionBoxEndFlipSprite;
}
else if( flip == -1 && pos.x + totalArrowLength > P * G - 1 ) {
// off right, force flip
flip = 1;
endSprite = mActionBoxEndSprite;
}
if( actionTall ) {
if( endSprite == mActionBoxEndSprite ) {
endSprite = mActionBoxEndTallSprite;
}
else {
endSprite = mActionBoxEndFlipTallSprite;
}
}
Vector3D boxPos( mAnchorX + pos.x - flip * 4,
mAnchorY + pos.y + 1,
0 );
if( flip == -1 ) {
// nudge
boxPos.mX += 1;
}
double boxFade = 0.63;
Vector3D boxStartPos = boxPos;
endSprite->draw( 0, 0, &boxPos, 1,
boxFade );
int trueLengthLeft = (int)trueLength;
// start can contain... 5 pixels?
//trueLengthLeft -= 7;
// go a slight bit over to leave extra space at end if it's tight
// end cap adds to it as well
while( trueLengthLeft > 14 ) {
boxPos.mX -= flip * 8;
if( actionTall ) {
mActionBoxMiddleTallSprite->draw( 0, 0, &boxPos, 1,
boxFade );
}
else {
mActionBoxMiddleSprite->draw( 0, 0, &boxPos, 1,
boxFade );
}
trueLengthLeft -= 8;
}
// now fill in rest, which is less that 8 pixels, with
// smaller lines
// sprite is 2 columns wide, but one column is transparent
// (drawing 1-column-wide sprites, using centered-based drawing,
// causes round-off errors)
// adjust a bit, since tall versions are lopsided
if( actionTall && flip < 0 ) {
boxPos.mY += 2;
}
char firstExtraLine = true;
while( trueLengthLeft > 6 ) {
boxPos.mX -= flip * 1;
if( firstExtraLine ) {
// extra offset from center of last full middle segment
boxPos.mX -= flip * 4;
firstExtraLine = false;
}
if( actionTall ) {
mActionBoxMiddleExtraTallSprite->draw( 0, 0, &boxPos, flip,
boxFade );
}
else {
mActionBoxMiddleExtraSprite->draw( 0, 0, &boxPos, flip,
boxFade );
}
trueLengthLeft -= 1;
}
// cap with end
if( !firstExtraLine ) {
// used at least one extra line
boxPos.mX -= flip * 4;
}
else {
// used no extra lines, offst from last full middle segment
boxPos.mX -= flip * 8;
}
if( actionTall ) {
mActionBoxStartTallSprite->draw( 0, 0, &boxPos, flip,
boxFade );
}
else {
mActionBoxStartSprite->draw( 0, 0, &boxPos, flip,
boxFade );
}
if( flip == 1 ) {
boxStartPos = boxPos;
}
else {
// use real start pos, but adjust
boxStartPos.mX += 7;
}
// make lower to increase chances of it fitting in box
char *lowerAction = stringToLowerCase( o->mAction );
largeText->drawText( lowerAction,
boxStartPos.mX - 4 + 1,
boxStartPos.mY - 4,
width, height );
delete [] lowerAction;
}
// restore
largeText->setFontColor( oldFontColor );
if( mShowGrid && ! mHintMode ) {
//grid lines
glColor4f( 1, 1, 1, 0.25f );
glBegin( GL_LINES ); {
for( int x=0; x<G+1; x++ ) {
glVertex2d( mAnchorX + x * P, mAnchorY );
glVertex2d( mAnchorX + x * P, mAnchorY + mHeight );
}
for( int y=0; y<G+1; y++ ) {
glVertex2d( mAnchorX, mAnchorY + y * P );
glVertex2d( mAnchorX + mWidth, mAnchorY + y * P );
}
}
glEnd();
}
/*
// thin white border, partly transparent
glColor4f( 1, 1, 1, 0.25f );
glBegin( GL_LINE_LOOP ); {
glVertex2d( mAnchorX, mAnchorY );
glVertex2d( mAnchorX + mWidth, mAnchorY );
glVertex2d( mAnchorX + mWidth, mAnchorY + mHeight );
glVertex2d( mAnchorX, mAnchorY + mHeight );
}
glEnd();
*/
if( mEditor != NULL ) {
GameStateEditor *editor = (GameStateEditor *)mEditor;
editor->displayRedrawed();
}
}
void GameStateDisplay::setLastMouse( double inX, double inY ) {
mLastPixelClickX = (int)( inX - mAnchorX );
mLastPixelClickY = (int)( inY - mAnchorY );
mLastGridClickX = (int)( mLastPixelClickX / P );
mLastGridClickY = (int)( mLastPixelClickY / P );
mLastHoverGridX = mLastGridClickX;
mLastHoverGridY = mLastGridClickY;
}
void GameStateDisplay::mouseDragged( double inX, double inY ) {
if( mHintMode ) return;
mLastActionRelease = false;
mLastActionPress = false;
mLastActionKeyPress = false;
if( isEnabled() && isInside( inX, inY ) ) {
setLastMouse( inX, inY );
fireActionPerformed( this );
}
}
void GameStateDisplay::mousePressed( double inX, double inY ) {
if( mHintMode ) return;
mLastActionRelease = false;
mLastActionPress = true;
mLastActionKeyPress = false;
if( isEnabled() && isInside( inX, inY ) ) {
setLastMouse( inX, inY );
fireActionPerformed( this );
// selected object may have changed... update tool tip
mLastMouseoverObjectIndex = -1;
if( mShowObjectToolTips ) {
redoToolTip( mLastGridClickX, mLastGridClickY );
}
}
}
void GameStateDisplay::mouseReleased( double inX, double inY ) {
if( mHintMode ) return;
mLastActionRelease = true;
mLastActionPress = false;
mLastActionKeyPress = false;
// done dragging with mouse
mManualBubblePositioningLive = false;
if( isEnabled() && isInside( inX, inY ) ) {
setLastMouse( inX, inY );
fireActionPerformed( this );
}
}
#include "ToolTipManager.h"
#include "minorGems/util/TranslationManager.h"
void GameStateDisplay::redoToolTip( int inGridX, int inGridY ) {
int objIndex = mState->getHitObject( inGridX, inGridY );
if( objIndex != -1 ) {
if( objIndex != mLastMouseoverObjectIndex ) {
StateObjectInstance *objInstance =
*( mState->mObjects.getElement( objIndex ) );
char *objName =
objInstance->mObject.getStateObjectName();
char *tipString;
int selected = mState->getSelectedObject();
char *selectedString = (char *)"";
if( selected == objIndex ) {
selectedString =
(char*)
TranslationManager::translate( "tip_anchor_selected" );
}
char *transKey;
if( objIndex == 0 ) {
transKey = (char*)"tip_player_anchor";
}
else {
transKey = (char*)"tip_object_anchor";
}
tipString = autoSprintf(
"%s (%s) %s",
TranslationManager::translate( transKey ),
objName,
selectedString );
delete [] objName;
ToolTipManager::setTip( tipString );
delete [] tipString;
}
}
else {
ToolTipManager::setTip( NULL );
}
mLastMouseoverObjectIndex = objIndex;
}
void GameStateDisplay::mouseMoved( double inX, double inY ) {
if( mHintMode ) return;
if( isEnabled() && isInside( inX, inY ) ) {
int pixelX = (int)( inX - mAnchorX );
int pixelY = (int)( inY - mAnchorY );
int gridX = (int)( pixelX / P );
int gridY = (int)( pixelY / P );
if( mShowObjectToolTips ) {
redoToolTip( gridX, gridY );
}
mMouseHover = true;
setLastMouse( inX, inY );
}
else {
mMouseHover = false;
}
}
void GameStateDisplay::setFocus( char inFocus ) {
mFocused = inFocus;
}
char GameStateDisplay::isFocused() {
return mFocused;
}
void GameStateDisplay::keyPressed( unsigned char inKey,
double inX, double inY ) {
if( mHintMode ) return;
mLastActionKeyPress = true;
mLastKeyPressed = inKey;
if( isEnabled() ) {
fireActionPerformed( this );
}
}
Reference in New Issue Copy Permalink