Well,
My Game base on Ogre 1.4.5, CEGUI 0.4.1 with TianLongBaBu's widgets
I make a class with name is FalagardSceneMap. This class will show a map of scene in Rectangle (in mode normall map) or Circle (in mode mini map).
FalagardSceneMap.hCode: Select all
#pragma once
#include "falmodule.h"
#include "ceguiwindowfactory.h"
#include "ceguiPropertyHelper.h"
namespace CEGUI
{
namespace FalagardSceneMapProperties
{
class AutoReset: public Property
{
public:
AutoReset() : Property(
"AutoReset",
"",
"")
{}
String get(const PropertyReceiver* receiver) const;
void set(PropertyReceiver* receiver, const String& value);
};
/////////////////////////////////////////////////////////////////////////////////////////////
class ChildItem: public Property
{
public:
ChildItem() : Property(
"ChildItem",
"",
"")
{}
String get(const PropertyReceiver* receiver) const;
void set(PropertyReceiver* receiver, const String& value);
};
/////////////////////////////////////////////////////////////////////////////////////////////
class RoundEnabled: public Property
{
public:
RoundEnabled() : Property(
"RoundEnabled",
"",
"")
{}
String get(const PropertyReceiver* receiver) const;
void set(PropertyReceiver* receiver, const String& value);
};
/////////////////////////////////////////////////////////////////////////////////////////////
class IconImage: public Property
{
public:
IconImage() : Property(
"IconImage",
"",
"")
{}
String get(const PropertyReceiver* receiver) const;
void set(PropertyReceiver* receiver, const String& value);
};
/////////////////////////////////////////////////////////////////////////////////////////////
class AnimateImage: public Property
{
public:
AnimateImage() : Property(
"AnimateImage",
"",
"")
{}
String get(const PropertyReceiver* receiver) const;
void set(PropertyReceiver* receiver, const String& value);
};
/////////////////////////////////////////////////////////////////////////////////////////////
class FlashAnimateImage: public Property
{
public:
FlashAnimateImage() : Property(
"FlashAnimateImage",
"",
"")
{}
String get(const PropertyReceiver* receiver) const;
void set(PropertyReceiver* receiver, const String& value);
};
};
enum
{
SCENEMAP_DISPLAY_MODE_FULLSCREEN = 0,
SCENEMAP_DISPLAY_MODE_ABSOLTE,
};
class FALAGARDBASE_API FalagardSceneMap : public Window
{
public:
static const utf8 WidgetTypeName[];
static const String EventNamespace;
static const String MouseRButtonDownCtrl;
static FalagardSceneMapProperties::AutoReset d_AutoResetProperty;
static FalagardSceneMapProperties::ChildItem d_ChildItemProperty;
static FalagardSceneMapProperties::RoundEnabled d_RoundEnabledProperty;
static FalagardSceneMapProperties::IconImage d_IconImageProperty;
static FalagardSceneMapProperties::AnimateImage d_AnimateImageProperty;
static FalagardSceneMapProperties::FlashAnimateImage d_FlashAnimateImageProperty;
void Close();
virtual void onMouseMove( MouseEventArgs &e );
virtual void onMouseButtonDown( MouseEventArgs &e );
virtual void onMouseButtonUp( MouseEventArgs &e );
virtual void onMouseLeaves( MouseEventArgs& e );
virtual void updateSelf(float elapsed);
virtual void onMouseEnters(MouseEventArgs& e);
virtual const Point GetMouseScenePos() const { return d_MouseScenePos; };
virtual void setMyselfDir( const int nDirect );
virtual void setMyselfPos( const Point& pos );
virtual void addPlayerPos( const Point& pos, const String& name );
virtual void Clear();
virtual void SetSceneSize( Size size ) { d_SceneSize = size ; };
virtual void SetSceneFileName( const String& str, const int nUserSharp );
virtual void setMAXJuLi( const float Maxjuli ){d_MAXJuLi = Maxjuli;}
virtual void SetZoomMode( int nMode );// { m_nDisplayMode = nMode; };
virtual void setMinimapData( int nType, float fX, float fY, String& szName ){};
bool getAutoReset() const {return AutoReset;};
void setAutoReset(bool value) {AutoReset=value;};
String getChildItem() const {return ChildItem;};
void setChildItem(String value) {ChildItem=value;};
bool getRoundEnabled() const {return RoundEnabled;};
void setRoundEnabled(bool value) {RoundEnabled=value;};
const Image* getIconImage() const {return d_PlayerImage;};
void setIconImage(const Image* value) {d_PlayerImage=value;};
String getAnimateImage() const {return d_MyselfAnimate;};
void setAnimateImage(const String& value) {d_MyselfAnimate=value;};
String getFlashAnimateImage() const {return FlashAnimateImage;};
void setFlashAnimateImage(const String& value) {FlashAnimateImage=value;};
virtual void DoScroll(int );
virtual void setSceneMapCenter();
protected:
const Image* d_PlayerImage;
bool AutoReset,RoundEnabled;
String ChildItem,d_MyselfAnimate,FlashAnimateImage;
virtual void onParentSized(WindowEventArgs& e);
void createBackground( const String& strFileName, const int nUserSharp );
const Image* getImageByName( const String& str,Rect rect );
void SetViewByCenter( const Point& pos );
Rect GetCurrentViewRect();
Point GetCurrentCenter();
protected:
struct SCENEMAP_FLAG_DATA
{
Point pos;
String name;
};
typedef std::list< SCENEMAP_FLAG_DATA > RENDER_POS;
RENDER_POS m_aPlayerPos;
int d_PlayerDirect;
Point d_MyseflPos;
bool d_fresh;
float d_MAXJuLi;
Window* m_pFriendWindow[ 5 ];
Window* m_pMySelfWindow;
Window* m_pLTWindow;
Window* m_pRBWindow;
Window* m_pBackground;
int m_nXCount;
int m_nYCount;
Point d_MouseScenePos;
Point m_PlayerPos;
Point m_WindowZero;
Size d_SceneSize;
// ´´½¨³¡¾°µØͼ
virtual void CreateSceneMap( const String& strFileName, const int nUserSharp );
void ResetPlayerWindow( int nIndex, SCENEMAP_FLAG_DATA& data );
Point ScenePosToWindowPos( const Point& pos ); // ³¡¾°×ø±êתµ½´°¿Ú×ø±ê
Point ScreenPosToScenePos( const Point& pos ); // ÆÁÄ»×ø±êת»»µ½³¡¾°×ø±êf
Point ScreenPosToScenePosRelative( const Point& pos ); // ÆÁÄ»×ø±êת»»µ½³¡¾°×ø±ê
Point ScreenPosToWindowPosRelative( const Point& pos ); // ÆÁÄ»×ø±êת»»µ½³¡¾°×ø±ê
Point ScreenPosToPicPos( const Point& pos ); // ÆÁÄ»×ø±êת»»µ½Í¼Æ¬×ø±ê
void ResetMyself();
void UpdateAllWindow();
void UpdateBackgroundItem();
float m_fZoomValueX;
float m_fZoomValueY;
bool m_bDraping;
Point m_ptDrapOffset;
int m_nDisplayMode;
public:
FalagardSceneMap( const String& type, const String& name );
~FalagardSceneMap();
};
class FALAGARDBASE_API FalagardScenemapFactory : public WindowFactory
{
public:
FalagardScenemapFactory(void) : WindowFactory(FalagardSceneMap::WidgetTypeName) { }
~FalagardScenemapFactory(void){}
Window* createWindow(const String& name);
void destroyWindow(Window* window);
};
};
Code: Select all
#include "falagardscenemap.h"
#include "ceguiimagesetmanager.h"
#include "ceguiimageset.h"
#include "ceguianimatemanager.h"
#include "ceguiwindowmanager.h"
#include "windows.h"
#include "elements\ceguistaticimage.h"
#include "falagard/CEGUIFalWidgetLookManager.h"
#include "falagard/CEGUIFalWidgetLookFeel.h"
namespace CEGUI
{
const String FalagardSceneMap::EventNamespace("FalagardSceneMap");
const utf8 FalagardSceneMap::WidgetTypeName[] = "Falagard/SceneMap";
FalagardSceneMapProperties::AutoReset FalagardSceneMap::d_AutoResetProperty; // ¶ÓÓÑÓõÃͼ±ê
FalagardSceneMapProperties::ChildItem FalagardSceneMap::d_ChildItemProperty; // ¶ÓÓÑÓõÃͼ±ê
FalagardSceneMapProperties::RoundEnabled FalagardSceneMap::d_RoundEnabledProperty; // ¶ÓÓÑÓõÃͼ±ê
FalagardSceneMapProperties::IconImage FalagardSceneMap::d_IconImageProperty; // ¶ÓÓÑÓõÃͼ±ê
FalagardSceneMapProperties::AnimateImage FalagardSceneMap::d_AnimateImageProperty; // ¶ÓÓÑÓõÃͼ±ê
FalagardSceneMapProperties::FlashAnimateImage FalagardSceneMap::d_FlashAnimateImageProperty; // ¶ÓÓÑÓõÃͼ±ê
const String FalagardSceneMap::MouseRButtonDownCtrl("MouseRButtonDownCtrl");
const int SCENE_MAP_PER_PIC = 64; // ÿһ¿éµØͼƬ¶ÔÓ¦¶à´óµÄµØͼÇøÓò
const int SCENE_MAP_ZOOMSCALE = 4;
FalagardSceneMap::FalagardSceneMap(const String& type, const String& name)
: Window(type, name)
{
d_fresh = false;
d_PlayerDirect = 0;
m_pMySelfWindow = NULL;
m_pLTWindow = NULL;
m_pRBWindow = NULL;
m_nXCount = 0;
m_nYCount = 0;
d_MouseScenePos = Point( 0, 0 );
d_SceneSize = Size( 128, 128 );
for( int i = 0; i < 5; i ++ )
m_pFriendWindow[ i ] = NULL;
m_pBackground = NULL;
m_WindowZero = Point( 0, 0 );
m_aPlayerPos.clear();
m_fZoomValueX = 1; // ĬÈÏΪһƹȫ¶¼ÏÔʾ
m_fZoomValueY = 1; // ĬÈÏΪһƹȫ¶¼ÏÔʾ
m_bDraping = false;
m_nDisplayMode = SCENEMAP_DISPLAY_MODE_ABSOLTE;
setMouseHollow( true );
CEGUI_START_ADD_STATICPROPERTY( FalagardSceneMap )
CEGUI_ADD_STATICPROPERTY( &d_AutoResetProperty );
CEGUI_ADD_STATICPROPERTY( &d_ChildItemProperty );
CEGUI_ADD_STATICPROPERTY( &d_RoundEnabledProperty );
CEGUI_ADD_STATICPROPERTY( &d_IconImageProperty );
CEGUI_ADD_STATICPROPERTY( &d_AnimateImageProperty );
CEGUI_ADD_STATICPROPERTY( &d_FlashAnimateImageProperty );
CEGUI_END_ADD_STATICPROPERTY
}
FalagardSceneMap::~FalagardSceneMap()
{
}
void FalagardSceneMap::Close()
{
Clear();
UINT i,child_count = getChildCount();
for ( i = 0; i < child_count; ++i)
d_children[i]->hide();
//WindowManager::getSingleton().destroyWindow( "SceneMapWindow_background" );
if( m_pMySelfWindow )
m_pMySelfWindow = NULL;
for( i = 0; i < 5; i ++ )
m_pFriendWindow[ i ] = NULL;
m_pLTWindow = NULL;
m_pRBWindow = NULL;
}
void FalagardSceneMap::addPlayerPos( const Point& pos, const String& name )
{
SCENEMAP_FLAG_DATA data;
data.pos = pos;
data.name = name;
m_aPlayerPos.push_back( data );
d_fresh = true;
}
void FalagardSceneMap::onMouseButtonDown( MouseEventArgs &e )
{
m_ptDrapOffset = ScreenPosToScenePosRelative( e.position );
if( e.button == RightButton )
{
if( e.sysKeys & Control )
return;
m_bDraping = true;
e.handled = true;
captureInput();
}
Window::onMouseButtonDown( e );
}
void FalagardSceneMap::onMouseEnters(MouseEventArgs& e)
{
d_MouseScenePos = ScreenPosToScenePos( e.position );
d_MouseScenePos.d_x /= m_fZoomValueX;
d_MouseScenePos.d_y /= m_fZoomValueY;
if( d_MouseScenePos.d_x < 0 || d_MouseScenePos.d_x > d_SceneSize.d_width ||
d_MouseScenePos.d_y < 0 || d_MouseScenePos.d_y > d_SceneSize.d_height )
{
d_MouseScenePos.d_x = 0;
d_MouseScenePos.d_y = 0;
}
Window::onMouseEnters( e );
}
void FalagardSceneMap::onMouseButtonUp( MouseEventArgs &e )
{
if( e.button == RightButton && ( e.sysKeys & Control ) )
{
WindowEventArgs args(this);
fireEvent(MouseRButtonDownCtrl, args, EventNamespace);
return;
}
m_bDraping = false;
releaseInput();
Window::onMouseButtonUp( e );
}
void FalagardSceneMap::onMouseLeaves( MouseEventArgs& e )
{
m_bDraping = false;
d_MouseScenePos = m_PlayerPos;
Window::onMouseLeaves( e );
}
void FalagardSceneMap::onMouseMove( MouseEventArgs &e )
{
if( m_bDraping ) // ÕýÔÚÍж¯
{
Point tmp = ScreenPosToWindowPosRelative( e.position );
m_WindowZero.d_x = tmp.d_x - m_ptDrapOffset.d_x;
m_WindowZero.d_y = tmp.d_y - m_ptDrapOffset.d_y;
UpdateAllWindow();
}
else
{
d_MouseScenePos = ScreenPosToScenePos( e.position );
d_MouseScenePos.d_x /= m_fZoomValueX;
d_MouseScenePos.d_y /= m_fZoomValueY;
if( d_MouseScenePos.d_x < 0 || d_MouseScenePos.d_x > d_SceneSize.d_width ||
d_MouseScenePos.d_y < 0 || d_MouseScenePos.d_y > d_SceneSize.d_height )
return;
}
Window::onMouseMove( e );
}
void FalagardSceneMap::DoScroll(int )
{
}
void FalagardSceneMap::updateSelf(float elapsed)
{
if( d_fresh && isVisible() )
{
int i,j;
// ¸üÐÂ×Ô¼ºµÃͼƬ
ResetMyself();
// ¸üжÓÓѵÃλÖúÍÐÅÏ¢
for( i = 0; i < 5; i ++ )
m_pFriendWindow[ i ]->hide();
RENDER_POS::iterator it;
String strTooltip[ 5 ]; //5¸öÈ˵Ãtooltip
for( i = 0, it = m_aPlayerPos.begin(); it != m_aPlayerPos.end(); it ++, i ++ )
ResetPlayerWindow( i, ( *it ) );
// ¸üÐÂtooltip
for( i = 0; i < 5; i ++ )
{
if( !m_pFriendWindow[ i ]->isVisible() ) // Èç¹û¿É¼û²Å¼ÆËã
break;
strTooltip[ i ] = m_pFriendWindow[ i ]->getTooltipText();
for( j = 0; j < 5; j ++ )
{
if( j == i )
continue;
if( !m_pFriendWindow[ j ]->isVisible() )
break;
if( Rect( 0, 0, 0, 0 ) != m_pFriendWindow[ i ]->getRect().getIntersection( m_pFriendWindow[ j ]->getRect() ) )
{
if( strTooltip[ i ].size() )
strTooltip[ i ] += "\r\n";
strTooltip[ i ] += m_pFriendWindow[ j ]->getTooltipText();
}
}
}
for( i = 0; i < 5; i ++ )
{
if( !m_pFriendWindow[ i ]->isVisible() ) // Èç¹û¿É¼û²Å¼ÆËã
break;
m_pFriendWindow[ i ]->setTooltipText( strTooltip[ i ] );
}
d_fresh = false;
requestRedraw();
}
}
void FalagardSceneMap::Clear()
{
m_aPlayerPos.clear();
}
void FalagardSceneMap::SetViewByCenter( const Point& pos )
{
if( m_pBackground )
{
float fWidthWindowPerBackground = getAbsoluteWidth() / m_pBackground->getAbsoluteWidth();
float fHeightWindowPerBackground = getAbsoluteHeight() / m_pBackground->getAbsoluteHeight();
m_WindowZero.d_x = -( pos.d_x - fWidthWindowPerBackground / 2 ) / fWidthWindowPerBackground;
m_WindowZero.d_y = -( pos.d_y - fHeightWindowPerBackground / 2 ) / fHeightWindowPerBackground;
UpdateAllWindow();
}
}
void FalagardSceneMap::setMyselfDir( const int nDirect )
{
d_PlayerDirect = ( nDirect ) % 360;
if( d_PlayerDirect < 0 )
d_PlayerDirect += 360;
d_fresh = true;
}
void FalagardSceneMap::setMyselfPos( const Point& pos )
{
m_PlayerPos = pos;
d_MyseflPos = ScenePosToWindowPos( pos );
d_fresh = true;
}
void FalagardSceneMap::SetSceneFileName( const String& str, const int nUserSharp )
{
CreateSceneMap( str.c_str(), nUserSharp );
}
void FalagardSceneMap::onParentSized( WindowEventArgs &e )
{
Window::onParentSized( e );
UpdateAllWindow();
}
// µÃµ½µ±Ç°ÊÓ¿ÚÖÐÐÄÔÚ±³¾°ÉϵÄλÖÃ
Point FalagardSceneMap::GetCurrentCenter()
{
Point pos;
float fWidthWindowPerBackground = getAbsoluteWidth() / m_pBackground->getAbsoluteWidth();
float fHeightWindowPerBackground = getAbsoluteHeight() / m_pBackground->getAbsoluteHeight();
pos.d_x = -m_WindowZero.d_x * fWidthWindowPerBackground + fWidthWindowPerBackground / 2;
pos.d_y = -m_WindowZero.d_y * fHeightWindowPerBackground + fHeightWindowPerBackground / 2 ;
return pos;
}
// µÃµ½µ±Ç°ÊÓ¿ÚÔÚ±³¾°ÉϵĿɼû·¶Î§
Rect FalagardSceneMap::GetCurrentViewRect()
{
Rect rect;
float fWidthWindowPerBackground = getAbsoluteWidth() / m_pBackground->getAbsoluteWidth();
float fHeightWindowPerBackground = getAbsoluteHeight() / m_pBackground->getAbsoluteHeight();
rect.d_left = -m_WindowZero.d_x * fWidthWindowPerBackground;
rect.d_top = -m_WindowZero.d_y * fHeightWindowPerBackground;
rect.d_right = rect.d_left + fWidthWindowPerBackground;
rect.d_bottom = rect.d_top + fHeightWindowPerBackground;
return rect;
}
void FalagardSceneMap::UpdateAllWindow()
{
if( m_pBackground == NULL )
return;
// ¸ù¾ÝËõ·Å±ÈÀý·ÅÖõØͼ
// Èç¹ûÊÇ1:1±ÈÀý£¬ÕýºÃÈ«ÆÁ
float fMax = ( d_SceneSize.d_width > d_SceneSize.d_height ) ? d_SceneSize.d_width : d_SceneSize.d_height;
if( m_nDisplayMode == SCENEMAP_DISPLAY_MODE_FULLSCREEN )
{
float fScale = getAbsoluteHeight() / getAbsoluteWidth();
m_fZoomValueX = fScale * d_SceneSize.d_width / fMax ;
m_fZoomValueY = d_SceneSize.d_height / fMax;
}
else
{
m_fZoomValueX = d_SceneSize.d_width * SCENE_MAP_ZOOMSCALE / getAbsoluteWidth();
m_fZoomValueY = d_SceneSize.d_height * SCENE_MAP_ZOOMSCALE / getAbsoluteHeight();
}
Rect winRect;
winRect = Rect( 0, 0, m_fZoomValueX, m_fZoomValueY );
if( m_fZoomValueX < 1 ) // ˵Ã÷¿í¶È²»¹»,¾ÍµÃ¾ÓÖÐÏÔʾÁË
{
winRect.d_left = ( 1 - m_fZoomValueX ) / 2;
winRect.d_right = winRect.d_left + m_fZoomValueX;
m_WindowZero.d_x = winRect.d_left;
}
else
{
if( m_WindowZero.d_x < 1 - m_fZoomValueX )
m_WindowZero.d_x = 1 - m_fZoomValueX;
if( m_WindowZero.d_x > 0 )
m_WindowZero.d_x = 0;
}
if( m_fZoomValueY < 1 )
{
winRect.d_top = ( 1 - m_fZoomValueY ) / 2;
winRect.d_bottom = winRect.d_top + m_fZoomValueY;
m_WindowZero.d_y = winRect.d_top;
}
else
{
if( m_WindowZero.d_y < 1 - m_fZoomValueY )
m_WindowZero.d_y = 1 - m_fZoomValueY;
if( m_WindowZero.d_y > 0 )
m_WindowZero.d_y = 0;
}
m_pBackground->setRect( Relative, winRect );
m_pBackground->setSize( Relative, winRect.getSize() );
m_pBackground->setPosition( Relative, m_WindowZero );
m_pBackground->show();
UpdateBackgroundItem();
requestRedraw();
d_fresh = true;
}
void FalagardSceneMap::UpdateBackgroundItem()
{
int i,j;
Size size;
char szWindowName[ 128 ];
float fOffsetX, fOffsetY; // ÕâÊǸö±ÈÀýÖµ
float fPicSizeX = 256, fPicSizeY = 256;
fOffsetX = float( ( int( d_SceneSize.d_width ) % SCENE_MAP_PER_PIC ) / float( SCENE_MAP_PER_PIC ) );
fOffsetY = float( ( int( d_SceneSize.d_height ) % SCENE_MAP_PER_PIC ) / float( SCENE_MAP_PER_PIC ) );
m_nXCount = int( d_SceneSize.d_width ) / SCENE_MAP_PER_PIC;
m_nYCount = int( d_SceneSize.d_height ) / SCENE_MAP_PER_PIC;
if( fOffsetX ) // Èç¹ûÓжàÓà¾Í¶à¼ÓÒ»¿é
m_nXCount += 1;
else
fOffsetX = 1;
if( fOffsetY )
m_nYCount += 1;
else
fOffsetY = 1;
if( m_nDisplayMode == SCENEMAP_DISPLAY_MODE_FULLSCREEN )
{
float fMax = ( d_SceneSize.d_width > d_SceneSize.d_height ) ? d_SceneSize.d_width : d_SceneSize.d_height;
float fScale = getAbsoluteHeight() / getAbsoluteWidth();
fPicSizeX *= fScale * getAbsoluteWidth() / ( fMax * SCENE_MAP_ZOOMSCALE );
fPicSizeY *= getAbsoluteHeight() / ( fMax * SCENE_MAP_ZOOMSCALE );
}
Point pos( 0, 0);
for( i = 0; i < m_nXCount; i ++ )
{
if( i == m_nXCount - 1 && fOffsetX != 1 ) // Èç¹ûÊÇx×îºóÒ»¸ö,²¢ÇÒͼÓжàÓàµÃ
size.d_width = float( fOffsetX * fPicSizeX );
else
size.d_width = fPicSizeX;
for( j = 0; j < m_nYCount; j ++ ) // ´´½¨ËùÓеÃͼƬ£¬´´½¨ÏìÓ¦µÃ´°¿Ú
{
if( j == m_nYCount - 1 && fOffsetY != 1 )
size.d_height = float( fOffsetY * fPicSizeY);
else
size.d_height = fPicSizeY;
sprintf( szWindowName, "%s_map_%d_%d", getName().c_str(),i, j );
Window* pWindow = WindowManager::getSingleton().getWindow( szWindowName );
if( pWindow )
{
pWindow->setPosition( Absolute, pos );
// pWindow->setSize( Absolute, size );
}
pos.d_y += size.d_height;
}
pos.d_x += size.d_width;
pos.d_y = 0;
}
}
void FalagardSceneMap::SetZoomMode( int nMode )
{
m_nDisplayMode = nMode;
UpdateAllWindow();
};
const Image* FalagardSceneMap::getImageByName( const String& str,Rect rect )
{
const String imagename = "Scenemap_view";
Point offset( 0, 0 );
char szFullFileName[ 128 ];
sprintf( szFullFileName, "jpg_%s.dds", str.c_str());
if( !ImagesetManager::getSingleton().isImagesetPresent( str ) )
ImagesetManager::getSingleton().createImagesetFromImageFile( str.c_str(), szFullFileName, "General" );
Imageset* pSet = ImagesetManager::getSingleton().getImageset( str );
if( pSet )
{
if( !pSet->isImageDefined( imagename ) )
pSet->defineImage( imagename, rect, offset );
return &pSet->getImage( imagename );
}
return NULL;
}
void FalagardSceneMap::createBackground( const String& strFileName, const int nUserSharp )
{
int i,j;
char szWindowName[ 128 ], szImagesetName[ 128 ];
sprintf( szWindowName, "%s_auto_background", getName().c_str() );
if( WindowManager::getSingleton().isWindowPresent( szWindowName ) )
WindowManager::getSingleton().destroyWindow( szWindowName );
WindowManager::getSingleton().createWindow( "DefaultWindow", szWindowName );
m_pBackground = WindowManager::getSingleton().getWindow( szWindowName );
addChildWindow( m_pBackground );
m_pBackground->setUserSharp(LookLikeRound);
m_pBackground->setMouseHollow( true );
m_pBackground->setMouseMoveHollow( true );
m_pBackground->setMouseLButtonHollow( true );
m_pBackground->setMouseRButtonHollow( true );
m_pBackground->setMaximumSize( Size( 100, 100 ) );
float fOffsetX, fOffsetY;
float fPicSizeX = 256, fPicSizeY = 256;
fOffsetX = float( ( int( d_SceneSize.d_width ) % SCENE_MAP_PER_PIC ) / float( SCENE_MAP_PER_PIC ) );
fOffsetY = float( ( int( d_SceneSize.d_height ) % SCENE_MAP_PER_PIC ) / float( SCENE_MAP_PER_PIC ) );
m_nXCount = int( d_SceneSize.d_width ) / SCENE_MAP_PER_PIC;
m_nYCount = int( d_SceneSize.d_height ) / SCENE_MAP_PER_PIC;
if( fOffsetX )
m_nXCount += 1;
else
fOffsetX = 1;
if( fOffsetY )
m_nYCount += 1;
else
fOffsetY = 1;
float fWidthPerItem = 1 / d_SceneSize.d_width;
float fHeightPerItem = 1 / d_SceneSize.d_height;
for( i = 0; i < m_nXCount; i ++ )
{
for( j = 0; j < m_nYCount; j ++ )
{
sprintf( szImagesetName, "%s_%d_%d", strFileName.c_str(),i,j );
Rect winRect( 0, 0, float( fPicSizeX ), float( fPicSizeY ) );
if( i == m_nXCount - 1 && fOffsetX != 1 )
winRect.d_right = float( fOffsetX * fPicSizeX );
if( j == m_nYCount - 1 && fOffsetY != 1 )
winRect.d_bottom = float( fOffsetY * fPicSizeY);
sprintf( szWindowName, "%s_map_%d_%d", getName().c_str(),i, j );
Window* pWindow = NULL;
if (WindowManager::getSingleton().isWindowPresent( szWindowName ) )
pWindow = WindowManager::getSingleton().getWindow( szWindowName );
else
pWindow = WindowManager::getSingleton().createWindow( "TLBB_StaticImageNULL", szWindowName );
pWindow->setMouseHollow( true );
pWindow->setMouseMoveHollow( true );
pWindow->setMouseLButtonHollow( true );
pWindow->setMouseRButtonHollow( true );
pWindow->setMaximumSize( Size( 100, 100 ) );
m_pBackground->addChildWindow( pWindow );
((StaticImage*)pWindow)->setImage(getImageByName(szImagesetName,winRect));
winRect.d_left= i * SCENE_MAP_PER_PIC / d_SceneSize.d_width;
winRect.d_top = j * SCENE_MAP_PER_PIC / d_SceneSize.d_height;
winRect.d_right = winRect.d_left + ( fOffsetX * SCENE_MAP_PER_PIC) / d_SceneSize.d_width;
winRect.d_bottom = winRect.d_top + ( fOffsetY * SCENE_MAP_PER_PIC) / d_SceneSize.d_height;
pWindow->setRect( Relative, winRect );
}
}
}
void FalagardSceneMap::CreateSceneMap( const String& strFileName, const int nUserSharp )
{
int i;
char szWindowName[ 128 ];
createBackground( strFileName, nUserSharp );
for( i = 0; i < 5; i ++ )
{
sprintf( szWindowName, "Scenemap_Player_%d", i );
if( !WindowManager::getSingleton().isWindowPresent( szWindowName ) )
WindowManager::getSingleton().createWindow( "TLBB_StaticImageNULL", szWindowName );
m_pFriendWindow[ i ] = (StaticImage*)WindowManager::getSingleton().getWindow( szWindowName );
((StaticImage*)m_pFriendWindow[ i ])->setImage( d_PlayerImage );
m_pBackground->addChildWindow( m_pFriendWindow[ i ] );
m_pFriendWindow[ i ]->hide();
}
sprintf( szWindowName, "%s_Auto_MyselfWindow", getName().c_str() );
if( !WindowManager::getSingleton().isWindowPresent( szWindowName ) )
WindowManager::getSingleton().createWindow( "TLBB_StaticImageNULL", szWindowName );
m_pMySelfWindow = (StaticImage*)WindowManager::getSingleton().getWindow( szWindowName );
m_pMySelfWindow->setAlwaysOnTop( true );
m_pBackground->addChildWindow( m_pMySelfWindow );
UpdateAllWindow();
}
void FalagardSceneMap::setSceneMapCenter()
{
SetViewByCenter( d_MyseflPos );
}
void FalagardSceneMap::ResetMyself()
{
Animate* pAnimate = ( Animate*)AnimateManager::getSingleton().getAnimate(d_MyselfAnimate);
if( pAnimate && m_pBackground && m_pMySelfWindow )
{
int nCurFrame = ( d_PlayerDirect * pAnimate->getFrameNumber() ) / 360;
Image* pPlayerImage = (Image*)( pAnimate->getFrame( nCurFrame ) );
Rect rect;
Point curPos = d_MyseflPos;
float fWidth = ( pPlayerImage->getWidth() / m_pBackground->getAbsoluteWidth() ) / 2;
float fHeight = ( pPlayerImage->getHeight() / m_pBackground->getAbsoluteHeight() ) / 2;
rect.d_left = curPos.d_x - fWidth;
rect.d_right = curPos.d_x + fWidth;
rect.d_top = curPos.d_y - fHeight;
rect.d_bottom = curPos.d_y + fHeight;
(( StaticImage* )m_pMySelfWindow)->setImage( pPlayerImage ) ;
m_pMySelfWindow->setRect( Relative, rect );
m_pMySelfWindow->setSize( Relative, rect.getSize() );
}
}
// ÖØмÆËãÍæ¼Ò´°¿ÚµÃλÖÃ
void FalagardSceneMap::ResetPlayerWindow( int nIndex, SCENEMAP_FLAG_DATA& data )
{
Rect rect;
Point curPos = ScenePosToWindowPos( data.pos );
float fWidth = ( d_PlayerImage->getSourceTextureArea().getWidth() / m_pBackground->getAbsoluteWidth() ) / 2;
float fHeight = ( d_PlayerImage->getSourceTextureArea().getHeight() / m_pBackground->getAbsoluteHeight() ) / 2;
rect.d_left = curPos.d_x - fWidth / 2;
rect.d_right = curPos.d_x + fWidth / 2;
rect.d_top = curPos.d_y - fHeight / 2;
rect.d_bottom = curPos.d_y + fHeight / 2;
m_pFriendWindow[ nIndex ]->show();
m_pFriendWindow[ nIndex ]->setRect( Relative, rect );
m_pFriendWindow[ nIndex ]->setSize( Relative, rect.getSize() );
m_pFriendWindow[ nIndex ]->setTooltipText( data.name );
}
Point FalagardSceneMap::ScreenPosToScenePos( const Point& pos ) // ÆÁÄ»×ø±êת»»µ½³¡¾°×ø±ê
{
Point tmp;
float fMapScreenWidth = getPixelRect().getWidth();
float fMapScreenHeight = getPixelRect().getHeight();
// ÏԵõ½Ïà¶ÔÓÚ×óÉϽǵÃÆÁĻƫÒÆÁ¿,±ÈÀýÖµ
tmp.d_x = ( pos.d_x - getPixelRect().d_left ) / fMapScreenWidth - m_WindowZero.d_x;
tmp.d_y = ( pos.d_y - getPixelRect().d_top ) / fMapScreenHeight - m_WindowZero.d_y;
tmp.d_x *= d_SceneSize.d_width;
tmp.d_y *= d_SceneSize.d_height;
return tmp;
}
Point FalagardSceneMap::ScreenPosToWindowPosRelative( const Point& pos ) // ÆÁÄ»×ø±êת»»µ½³¡¾°×ø±êf
{
Point tmp;
float fMapScreenWidth = getPixelRect().getWidth();
float fMapScreenHeight = getPixelRect().getHeight();
// ÏԵõ½Ïà¶ÔÓÚ×óÉϽǵÃÆÁĻƫÒÆÁ¿,±ÈÀýÖµ
tmp.d_x = ( pos.d_x - getPixelRect().d_left ) / fMapScreenWidth;
tmp.d_y = ( pos.d_y - getPixelRect().d_top ) / fMapScreenHeight;
return tmp;
}
Point FalagardSceneMap::ScreenPosToScenePosRelative( const Point& pos ) // ÆÁÄ»×ø±êת»»µ½³¡¾°×ø±ê
{
Point tmp;
float fMapScreenWidth = getPixelRect().getWidth();
float fMapScreenHeight = getPixelRect().getHeight();
// ÏԵõ½Ïà¶ÔÓÚ×óÉϽǵÃÆÁĻƫÒÆÁ¿,±ÈÀýÖµ
tmp.d_x = ( pos.d_x - getPixelRect().d_left ) / fMapScreenWidth - m_WindowZero.d_x;
tmp.d_y = ( pos.d_y - getPixelRect().d_top ) / fMapScreenHeight - m_WindowZero.d_y;
return tmp;
}
Point FalagardSceneMap::ScenePosToWindowPos( const Point& pos )
{
Point tmp;
tmp.d_x = pos.d_x / d_SceneSize.d_width;
tmp.d_y = pos.d_y / d_SceneSize.d_height;
return tmp;
}
namespace FalagardSceneMapProperties
{
String AutoReset::get(const PropertyReceiver* receiver) const
{
return PropertyHelper::boolToString(static_cast<const FalagardSceneMap*>(receiver)->getAutoReset());
}
void AutoReset::set(PropertyReceiver* receiver, const String& value)
{
static_cast<FalagardSceneMap*>(receiver)->setAutoReset(PropertyHelper::stringToBool(value));
}
//////////////////////////////////////////////////////////////////////////
String ChildItem::get(const PropertyReceiver* receiver) const
{
return static_cast<const FalagardSceneMap*>(receiver)->getChildItem();
}
void ChildItem::set(PropertyReceiver* receiver, const String& value)
{
char imageType[128] = {0};
char imageName[128] = {0};
sscanf(value.c_str(), "key:%127s name:%127s",imageType, imageName);
static_cast<FalagardSceneMap*>(receiver)->setChildItem(imageName);
}
//////////////////////////////////////////////////////////////////////////
String RoundEnabled::get(const PropertyReceiver* receiver) const
{
return PropertyHelper::boolToString(static_cast<const FalagardSceneMap*>(receiver)->getRoundEnabled());
}
void RoundEnabled::set(PropertyReceiver* receiver, const String& value)
{
static_cast<FalagardSceneMap*>(receiver)->setRoundEnabled(PropertyHelper::stringToBool(value));
}
//////////////////////////////////////////////////////////////////////////
String IconImage::get(const PropertyReceiver* receiver) const
{
return PropertyHelper::imageToString(static_cast<const FalagardSceneMap*>(receiver)->getIconImage());
}
void IconImage::set(PropertyReceiver* receiver, const String& value)
{
char imageType[128] = {0};
char imageSet[128] = {0};
char imageName[128] = {0};
sscanf(value.c_str(), "type:%127s set:%127s image:%127s",imageType, imageSet, imageName);
if(ImagesetManager::getSingleton().isImagesetPresent((utf8*)imageSet))
static_cast<FalagardSceneMap*>(receiver)->setIconImage(&ImagesetManager::getSingleton().getImageset((utf8*)imageSet)->getImage((utf8*)imageName));
}
//////////////////////////////////////////////////////////////////////////
String AnimateImage::get(const PropertyReceiver* receiver) const
{
return static_cast<const FalagardSceneMap*>(receiver)->getAnimateImage();
}
void AnimateImage::set(PropertyReceiver* receiver, const String& value)
{
char imageType[128] = {0};
char imageName[128] = {0};
sscanf(value.c_str(), "type:%127s animate:%127s",imageType, imageName);
if (AnimateManager::getSingleton().isAnimatePresent(imageName))
static_cast<FalagardSceneMap*>(receiver)->setAnimateImage(imageName);
}
//////////////////////////////////////////////////////////////////////////
String FlashAnimateImage::get(const PropertyReceiver* receiver) const
{
return static_cast<const FalagardSceneMap*>(receiver)->getFlashAnimateImage();
}
void FlashAnimateImage::set(PropertyReceiver* receiver, const String& value)
{
static_cast<FalagardSceneMap*>(receiver)->setFlashAnimateImage(value);
}
};
//////////////////////////////////////////////////////////////////////////
Window* FalagardScenemapFactory::createWindow(const String& name)
{
return new FalagardSceneMap(d_type, name);
}
void FalagardScenemapFactory::destroyWindow(Window* window)
{
delete window;
}
};
When layout loaded, it will execute
CreateSceneMap with scene'name and user's shape. In
CreateBackground, called from CreateSceneMap, we make a Window (its type is DefaultWindow) and a large image (it created by small image with 128x128 size). In normal mode, Window is square. In minimap mode, Window is Circle.
In TianLongBaBu, this codes will show a circle image in a radar on top-right corner
In my game, this codes wil show a square image. Help me
