From a514d37b1d6cfeca53ca040a696c9e87a5f0ea03 Mon Sep 17 00:00:00 2001 From: spartanj Date: Thu, 9 Jun 2011 03:37:26 -0300 Subject: [PATCH] Keep it working on the map editor, maps can now be saved, i'll implement the loading next. Changed a little bit how to load from memory packs. Fixed some minor bugs on the UI. And many things that i can't remember, i forgot to make a commit yesterday. --- src/audio/csoundbuffer.cpp | 11 +- src/gaming/cgameobject.cpp | 25 ++ src/gaming/cgameobject.hpp | 13 +- src/gaming/cgameobjectshape.cpp | 34 +- src/gaming/cgameobjectshape.hpp | 6 + src/gaming/cgameobjectshapeex.cpp | 7 + src/gaming/cgameobjectshapeex.hpp | 2 + src/gaming/cgameobjectsprite.cpp | 40 ++- src/gaming/cgameobjectsprite.hpp | 8 + src/gaming/cgameobjectvirtual.cpp | 96 ++++++ src/gaming/cgameobjectvirtual.hpp | 50 +++ src/gaming/clayer.cpp | 20 ++ src/gaming/clayer.hpp | 13 + src/gaming/cmap.cpp | 464 ++++++++++++++++++++++++++- src/gaming/cmap.hpp | 52 ++- src/gaming/cobjectlayer.cpp | 37 +++ src/gaming/cobjectlayer.hpp | 12 +- src/gaming/ctilelayer.cpp | 10 +- src/gaming/ctilelayer.hpp | 6 +- src/gaming/mapeditor/cmapeditor.cpp | 245 ++++++++++++-- src/gaming/mapeditor/cmapeditor.hpp | 21 ++ src/gaming/maphelper.hpp | 13 +- src/graphics/cshader.cpp | 10 +- src/graphics/cshape.cpp | 10 +- src/graphics/cshape.hpp | 14 +- src/graphics/cshapegroup.cpp | 8 + src/graphics/cshapegroup.hpp | 5 + src/graphics/cshapegroupmanager.cpp | 21 ++ src/graphics/cshapegroupmanager.hpp | 2 + src/graphics/csprite.cpp | 28 +- src/graphics/csprite.hpp | 14 +- src/graphics/ctexturefont.cpp | 11 +- src/graphics/ctexturegrouploader.cpp | 15 +- src/graphics/ctextureloader.cpp | 10 +- src/graphics/ctexturepackertex.hpp | 54 +++- src/graphics/cttffont.cpp | 11 +- src/system/cpack.hpp | 9 +- src/system/cpak.cpp | 8 +- src/system/cpak.hpp | 2 +- src/system/czip.cpp | 8 +- src/system/czip.hpp | 2 +- src/test/eetest.cpp | 16 +- src/ui/cuidropdownlist.cpp | 17 +- src/ui/cuiwindow.cpp | 1 + src/utils/utils.cpp | 22 +- src/utils/utils.hpp | 3 - 46 files changed, 1287 insertions(+), 199 deletions(-) create mode 100644 src/gaming/cgameobjectvirtual.cpp create mode 100644 src/gaming/cgameobjectvirtual.hpp diff --git a/src/audio/csoundbuffer.cpp b/src/audio/csoundbuffer.cpp index 43cc5826f..e9bc10ef7 100755 --- a/src/audio/csoundbuffer.cpp +++ b/src/audio/csoundbuffer.cpp @@ -59,12 +59,15 @@ bool cSoundBuffer::LoadFromFile(const std::string& Filename) { } bool cSoundBuffer::LoadFromPack( cPack* Pack, const std::string& FilePackPath ) { - std::vector TmpData; + bool Ret = false; + cPack::PointerData PData; - if ( Pack->IsOpen() && Pack->ExtractFileToMemory( FilePackPath, TmpData ) ) - return LoadFromMemory( reinterpret_cast ( &TmpData[0] ), TmpData.size() ); + if ( Pack->IsOpen() && Pack->ExtractFileToMemory( FilePackPath, PData ) ) + Ret = LoadFromMemory( reinterpret_cast ( PData.Data ), PData.DataSize ); - return false; + eeSAFE_DELETE( PData.Data ); + + return Ret; } bool cSoundBuffer::LoadFromMemory( const char* Data, std::size_t SizeInBytes ) { diff --git a/src/gaming/cgameobject.cpp b/src/gaming/cgameobject.cpp index f585122fb..df4e8efd4 100644 --- a/src/gaming/cgameobject.cpp +++ b/src/gaming/cgameobject.cpp @@ -60,8 +60,33 @@ eeVector2f cGameObject::Pos() const { void cGameObject::Pos( eeVector2f pos ) { } +eeSize cGameObject::Size() { + return eeSize(); +} + Uint32 cGameObject::Type() const { return GAMEOBJECT_TYPE_BASE; } +Uint32 cGameObject::DataId() { + return 0; +} + +void cGameObject::DataId( Uint32 Id ){ +} + +EE_RENDERTYPE cGameObject::RenderTypeFromFlags() { + EE_RENDERTYPE Render = RN_NORMAL; + + if ( ( mFlags & GObjFlags::GAMEOBJECT_MIRRORED ) && ( mFlags & GObjFlags::GAMEOBJECT_FLIPED ) ) { + Render = RN_FLIPMIRROR; + } else if ( mFlags & GObjFlags::GAMEOBJECT_MIRRORED ) { + Render = RN_MIRROR; + } else if ( mFlags & GObjFlags::GAMEOBJECT_FLIPED ) { + Render = RN_FLIP; + } + + return Render; +} + }} diff --git a/src/gaming/cgameobject.hpp b/src/gaming/cgameobject.hpp index f3d58ce80..29e17c68c 100644 --- a/src/gaming/cgameobject.hpp +++ b/src/gaming/cgameobject.hpp @@ -3,6 +3,9 @@ #include "base.hpp" #include "maphelper.hpp" +#include "../graphics/renders.hpp" + +using namespace EE::Graphics; namespace EE { namespace Gaming { @@ -20,6 +23,8 @@ class cGameObject { virtual void Pos( eeVector2f pos ); + virtual eeSize Size(); + virtual Uint32 Type() const; bool IsType( const Uint32& type ); @@ -32,13 +37,19 @@ class cGameObject { Uint32 FlagGet( const Uint32& Flag ); - void FlagSet( const Uint32& Flag ); + virtual void FlagSet( const Uint32& Flag ); void FlagClear( const Uint32& Flag ); Uint32 IsBlocked() const; + + virtual Uint32 DataId(); + + virtual void DataId( Uint32 Id ); protected: Uint32 mFlags; + + virtual EE_RENDERTYPE RenderTypeFromFlags(); }; }} diff --git a/src/gaming/cgameobjectshape.cpp b/src/gaming/cgameobjectshape.cpp index 3ba75591a..990cfeb37 100644 --- a/src/gaming/cgameobjectshape.cpp +++ b/src/gaming/cgameobjectshape.cpp @@ -1,4 +1,5 @@ #include "cgameobjectshape.hpp" +#include "../graphics/cshapegroupmanager.hpp" namespace EE { namespace Gaming { @@ -18,23 +19,7 @@ Uint32 cGameObjectShape::Type() const { void cGameObjectShape::Draw() { if ( NULL != mShape ) { - Uint8 Both = 0; - EE_RENDERTYPE Render = RN_NORMAL; - - if ( mFlags & GObjFlags::GAMEOBJECT_MIRRORED ) { - Render = RN_MIRROR; - Both |= 1 << RN_MIRROR; - } - - if ( mFlags & GObjFlags::GAMEOBJECT_FLIPED ) { - Render = RN_FLIP; - Both |= 1 << RN_FLIP; - } - - if ( ( Both & RN_MIRROR ) && ( Both & RN_FLIP ) ) - Render = RN_FLIPMIRROR; - - mShape->Draw( mPos.x, mPos.y, eeColorA(), 0.f, 1.f, ALPHA_NORMAL, Render ); + mShape->Draw( mPos.x, mPos.y, eeColorA(), 0.f, 1.f, ALPHA_NORMAL, RenderTypeFromFlags() ); } } @@ -45,6 +30,13 @@ eeVector2f cGameObjectShape::Pos() const { return mPos; } +eeSize cGameObjectShape::Size() { + if ( NULL != mShape ) + return mShape->RealSize(); + + return eeSize(); +} + void cGameObjectShape::Pos( eeVector2f pos ) { mPos = pos; } @@ -57,4 +49,12 @@ void cGameObjectShape::Shape( cShape * shape ) { mShape = shape; } +Uint32 cGameObjectShape::DataId() { + return mShape->Id(); +} + +void cGameObjectShape::DataId( Uint32 Id ) { + Shape( cShapeGroupManager::instance()->GetShapeById( Id ) ); +} + }} diff --git a/src/gaming/cgameobjectshape.hpp b/src/gaming/cgameobjectshape.hpp index 152d15c7b..2cda550d8 100644 --- a/src/gaming/cgameobjectshape.hpp +++ b/src/gaming/cgameobjectshape.hpp @@ -21,6 +21,8 @@ class cGameObjectShape : public cGameObject { virtual eeVector2f Pos() const; + virtual eeSize Size(); + virtual void Pos( eeVector2f pos ); cShape * Shape() const; @@ -28,6 +30,10 @@ class cGameObjectShape : public cGameObject { void Shape( cShape * shape ); virtual Uint32 Type() const; + + virtual Uint32 DataId(); + + virtual void DataId( Uint32 Id ); protected: cShape * mShape; eeVector2f mPos; diff --git a/src/gaming/cgameobjectshapeex.cpp b/src/gaming/cgameobjectshapeex.cpp index a311830ea..bfda3d26b 100644 --- a/src/gaming/cgameobjectshapeex.cpp +++ b/src/gaming/cgameobjectshapeex.cpp @@ -11,6 +11,7 @@ cGameObjectShapeEx::cGameObjectShapeEx( const Uint32& Flags, cShape * Shape, con mColor( Color ), mVertexColors( NULL ) { + mRender = RenderTypeFromFlags(); } cGameObjectShapeEx::~cGameObjectShapeEx() @@ -30,4 +31,10 @@ void cGameObjectShapeEx::Draw() { } } +void cGameObjectShapeEx::FlagSet( const Uint32& Flag ) { + mRender = RenderTypeFromFlags(); + + cGameObject::FlagSet( Flag ); +} + }} diff --git a/src/gaming/cgameobjectshapeex.hpp b/src/gaming/cgameobjectshapeex.hpp index ff553b806..141123643 100644 --- a/src/gaming/cgameobjectshapeex.hpp +++ b/src/gaming/cgameobjectshapeex.hpp @@ -15,6 +15,8 @@ class cGameObjectShapeEx : public cGameObjectShape { virtual void Draw(); virtual Uint32 Type() const; + + virtual void FlagSet( const Uint32& Flag ); protected: EE_PRE_BLEND_FUNC mBlend; EE_RENDERTYPE mRender; diff --git a/src/gaming/cgameobjectsprite.cpp b/src/gaming/cgameobjectsprite.cpp index 4d68b11a5..38028fc0d 100644 --- a/src/gaming/cgameobjectsprite.cpp +++ b/src/gaming/cgameobjectsprite.cpp @@ -1,4 +1,5 @@ #include "cgameobjectsprite.hpp" +#include "../graphics/cshapegroupmanager.hpp" namespace EE { namespace Gaming { @@ -6,6 +7,8 @@ cGameObjectSprite::cGameObjectSprite( const Uint32& Flags, cSprite * Sprite ) : cGameObject( Flags ), mSprite( Sprite ) { + if ( NULL != mSprite ) + mSprite->SetRenderType( RenderTypeFromFlags() ); } cGameObjectSprite::~cGameObjectSprite() { @@ -26,15 +29,22 @@ void cGameObjectSprite::Update() { } eeVector2f cGameObjectSprite::Pos() const { - eeASSERT( NULL != mSprite ) + if ( NULL != mSprite ) + return mSprite->Position(); - return mSprite->Position(); + return eeVector2f(); } void cGameObjectSprite::Pos( eeVector2f pos ) { - eeASSERT( NULL != mSprite ); + if ( NULL != mSprite ) + mSprite->Position( pos ); +} - mSprite->Position( pos ); +eeSize cGameObjectSprite::Size() { + if ( NULL != mSprite ) + return mSprite->GetShape(0)->RealSize(); + + return eeSize(); } cSprite * cGameObjectSprite::Sprite() const { @@ -42,7 +52,29 @@ cSprite * cGameObjectSprite::Sprite() const { } void cGameObjectSprite::Sprite( cSprite * sprite ) { + eeSAFE_DELETE( mSprite ); mSprite = sprite; } +void cGameObjectSprite::FlagSet( const Uint32& Flag ) { + if ( NULL != mSprite ) + mSprite->SetRenderType( RenderTypeFromFlags() ); + + cGameObject::FlagSet( Flag ); +} + +Uint32 cGameObjectSprite::DataId() { + return mSprite->GetShape(0)->Id(); +} + +void cGameObjectSprite::DataId( Uint32 Id ) { + std::vector tShapeVec = cShapeGroupManager::instance()->GetShapesByPatternId( Id ); + + if ( tShapeVec.size() ) { + cSprite * tSprite = eeNew( cSprite, () ); + tSprite->CreateAnimation(); + tSprite->AddFrames( tShapeVec ); + } +} + }} diff --git a/src/gaming/cgameobjectsprite.hpp b/src/gaming/cgameobjectsprite.hpp index 9ede96d74..5c0da6b32 100644 --- a/src/gaming/cgameobjectsprite.hpp +++ b/src/gaming/cgameobjectsprite.hpp @@ -23,11 +23,19 @@ class cGameObjectSprite : public cGameObject { virtual void Pos( eeVector2f pos ); + virtual eeSize Size(); + cSprite * Sprite() const; void Sprite( cSprite * sprite ); virtual Uint32 Type() const; + + virtual void FlagSet( const Uint32& Flag ); + + virtual Uint32 DataId(); + + virtual void DataId( Uint32 Id ); private: cSprite * mSprite; }; diff --git a/src/gaming/cgameobjectvirtual.cpp b/src/gaming/cgameobjectvirtual.cpp new file mode 100644 index 000000000..56214b202 --- /dev/null +++ b/src/gaming/cgameobjectvirtual.cpp @@ -0,0 +1,96 @@ +#include "cgameobjectvirtual.hpp" + +#include "cmap.hpp" +#include "clayer.hpp" +#include "../graphics/cprimitives.hpp" +using namespace EE::Graphics; + +namespace EE { namespace Gaming { + +cGameObjectVirtual::cGameObjectVirtual( Uint32 DataId, const Uint32& Flags, Uint32 Type, const eeVector2f& Pos ) : + cGameObject( Flags ), + mType( Type ), + mDataId( DataId ), + mPos( Pos ), + mLayer( NULL ), + mShape( NULL ) +{ +} + +cGameObjectVirtual::cGameObjectVirtual( cShape * Shape, const Uint32& Flags, Uint32 Type, const eeVector2f& Pos ) : + cGameObject( Flags ), + mType( Type ), + mDataId( 0 ), + mPos( Pos ), + mLayer( NULL ), + mShape( Shape ) +{ + if ( NULL != Shape ) + mDataId = Shape->Id(); +} + +cGameObjectVirtual::~cGameObjectVirtual() { +} + +Uint32 cGameObjectVirtual::Type() const { + return GAMEOBJECT_TYPE_VIRTUAL; +} + +Uint32 cGameObjectVirtual::RealType() const { + return mType; +} + +eeSize cGameObjectVirtual::Size() { + if ( NULL != mShape ) + return mShape->RealSize(); + + if ( NULL != mLayer ) + return mLayer->Map()->TileSize(); + + return eeSize( 32, 32 ); +} + +void cGameObjectVirtual::Draw() { + if ( NULL != mShape ) { + mShape->Draw( mPos.x, mPos.y, eeColorA(), 0.f, 1.f, ALPHA_NORMAL, RenderTypeFromFlags() ); + } else { + cPrimitives P; + + eeColorA C( mDataId ); + C.Alpha = 255; + + P.SetColor( C ); + + if ( NULL != mLayer ) { + eeSize ts = mLayer->Map()->TileSize(); + P.DrawRectangle( mPos.x, mPos.y, ts.x ,ts.y, 0, 1 ); + } else { + P.DrawRectangle( mPos.x, mPos.y, 32 ,32, 0, 1 ); + } + } +} + +void cGameObjectVirtual::Update() { +} + +eeVector2f cGameObjectVirtual::Pos() const { + return mPos; +} + +void cGameObjectVirtual::Pos( eeVector2f pos ) { + mPos = pos; +} + +Uint32 cGameObjectVirtual::DataId() { + return mDataId; +} + +void cGameObjectVirtual::DataId( Uint32 Id ) { + mDataId = Id; +} + +void cGameObjectVirtual::SetLayer( cLayer * Layer ) { + mLayer = Layer; +} + +}} diff --git a/src/gaming/cgameobjectvirtual.hpp b/src/gaming/cgameobjectvirtual.hpp new file mode 100644 index 000000000..b19733407 --- /dev/null +++ b/src/gaming/cgameobjectvirtual.hpp @@ -0,0 +1,50 @@ +#ifndef EE_GAMINGCGAMEOBJECTVIRTUAL_HPP +#define EE_GAMINGCGAMEOBJECTVIRTUAL_HPP + +#include "base.hpp" +#include "cgameobject.hpp" +#include "../graphics/cshape.hpp" +using namespace EE::Graphics; + +namespace EE { namespace Gaming { + +class cLayer; + +class cGameObjectVirtual : public cGameObject { + public: + cGameObjectVirtual( Uint32 DataId, const Uint32& Flags = GObjFlags::GAMEOBJECT_STATIC, Uint32 RealType = GAMEOBJECT_TYPE_VIRTUAL, const eeVector2f& Pos = eeVector2f() ); + + cGameObjectVirtual( cShape * Shape, const Uint32& Flags = GObjFlags::GAMEOBJECT_STATIC, Uint32 RealType = GAMEOBJECT_TYPE_VIRTUAL, const eeVector2f& Pos = eeVector2f() ); + + virtual ~cGameObjectVirtual(); + + virtual void Draw(); + + virtual void Update(); + + virtual eeVector2f Pos() const; + + virtual eeSize Size(); + + virtual void Pos( eeVector2f pos ); + + virtual Uint32 Type() const; + + virtual Uint32 RealType() const; + + virtual Uint32 DataId(); + + virtual void DataId( Uint32 Id ); + + void SetLayer( cLayer * Layer ); + protected: + Uint32 mType; + Uint32 mDataId; + eeVector2f mPos; + cLayer * mLayer; + cShape * mShape; +}; + +}} + +#endif diff --git a/src/gaming/clayer.cpp b/src/gaming/clayer.cpp index ef87f1f03..d24ba9658 100644 --- a/src/gaming/clayer.cpp +++ b/src/gaming/clayer.cpp @@ -61,5 +61,25 @@ const Uint32& cLayer::Id() const { return mNameHash; } +void cLayer::ClearProperties() { + mProperties.clear(); +} + +void cLayer::AddProperty( std::string Text, std::string Value ) { + mProperties[ Text ] = Value; +} + +void cLayer::EditProperty( std::string Text, std::string Value ) { + mProperties[ Text ] = Value; +} + +void cLayer::RemoveProperty( std::string Text ) { + mProperties.erase( Text ); +} + +cLayer::PropertiesMap& cLayer::GetProperties() { + return mProperties; +} + }} diff --git a/src/gaming/clayer.hpp b/src/gaming/clayer.hpp index 1b9ca028d..2e088f3e3 100644 --- a/src/gaming/clayer.hpp +++ b/src/gaming/clayer.hpp @@ -9,6 +9,8 @@ class cMap; class cLayer { public: + typedef std::map PropertiesMap; + virtual ~cLayer(); virtual void Draw( const eeVector2f& Offset = eeVector2f(0,0) ) = 0; @@ -34,6 +36,16 @@ class cLayer { const std::string& Name() const; const Uint32& Id() const; + + void AddProperty( std::string Text, std::string Value ); + + void EditProperty( std::string Text, std::string Value ); + + void RemoveProperty( std::string Text ); + + void ClearProperties(); + + PropertiesMap& GetProperties(); protected: friend class cMap; @@ -43,6 +55,7 @@ class cLayer { eeVector2f mOffset; Uint32 mNameHash; std::string mName; + PropertiesMap mProperties; cLayer( cMap * map, Uint32 type, Uint32 flags, std::string name = "", eeVector2f offset = eeVector2f(0,0) ); }; diff --git a/src/gaming/cmap.cpp b/src/gaming/cmap.cpp index fb9301be9..68e24a728 100644 --- a/src/gaming/cmap.cpp +++ b/src/gaming/cmap.cpp @@ -1,4 +1,5 @@ #include "cmap.hpp" +#include "cgameobjectvirtual.hpp" #include "cgameobjectshape.hpp" #include "cgameobjectshapeex.hpp" #include "cgameobjectsprite.hpp" @@ -6,6 +7,8 @@ #include "cobjectlayer.hpp" #include "../graphics/cprimitives.hpp" +#include "../graphics/cshapegroupmanager.hpp" +#include "../ui/cuithememanager.hpp" using namespace EE::Graphics; namespace EE { namespace Gaming { @@ -56,6 +59,7 @@ void cMap::Create( eeSize Size, Uint32 MaxLayers, eeSize TileSize, Uint32 Flags, mMaxLayers = MaxLayers; mSize = Size; mTileSize = TileSize; + mPixelSize = Size * TileSize; mLayers = eeNewArray( cLayer*, mMaxLayers ); for ( Uint32 i = 0; i < mMaxLayers; i++ ) @@ -100,6 +104,17 @@ cLayer* cMap::GetLayerByHash( Uint32 hash ) { return NULL; } +Uint32 cMap::GetLayerIndex( cLayer * Layer ) { + if ( NULL != Layer ) { + for ( Uint32 i = 0; i < mLayerCount; i++ ) { + if ( mLayers[i] == Layer ) + return i; + } + } + + return MAP_LAYER_UNKNOWN; +} + cLayer* cMap::GetLayer( const std::string& name ) { return GetLayerByHash( MakeHash( name ) ); } @@ -111,40 +126,51 @@ void cMap::Draw() { mWindow->ClipEnable( mScreenPos.x, mScreenPos.y, mViewSize.x, mViewSize.y ); } - eeVector2f offsetFixed = eeVector2f( (eeFloat)mScreenPos.x, (eeFloat)mScreenPos.y ) + FixOffset(); + mOffsetFixed = eeVector2f( (eeFloat)mScreenPos.x, (eeFloat)mScreenPos.y ) + FixOffset(); GetMouseOverTile(); GridDraw(); for ( Uint32 i = 0; i < mLayerCount; i++ ) { - mLayers[i]->Draw( offsetFixed ); + mLayers[i]->Draw( mOffsetFixed ); } + MouseOverDraw(); + if ( ClipedArea() ) { mWindow->ClipDisable(); } } -void cMap::GridDraw() { - if ( !DrawGrid() ) +void cMap::MouseOverDraw() { + if ( !DrawTileOver() ) return; cPrimitives P; + P.SetColor( eeColorA( 255, 0, 0, 255 ) ); + + P.DrawRectangle( mOffsetFixed.x + mMouseOverTileFinal.x * mTileSize.x, mOffsetFixed.y + mMouseOverTileFinal.y * mTileSize.y, mTileSize.x, mTileSize.y, 0.f, 1.f, EE_DRAW_LINE ); +} + +void cMap::GridDraw() { + cPrimitives P; P.SetColor( eeColorA( 0, 0, 0, 50 ) ); P.DrawRectangle( mScreenPos.x, mScreenPos.y, mViewSize.x, mViewSize.y, 0.f, 1.f ); P.SetColor( eeColorA( 255, 255, 255, 255 ) ); + if ( !DrawGrid() ) + return; + if ( 0 == mSize.x || 0 == mSize.y ) return; cGlobalBatchRenderer::instance()->Draw(); - eeVector2f offsetFixed = eeVector2f( (eeFloat)mScreenPos.x, (eeFloat)mScreenPos.y ) + FixOffset(); GLi->LoadIdentity(); GLi->PushMatrix(); - GLi->Translatef( offsetFixed.x, offsetFixed.y, 0.0f ); + GLi->Translatef( mOffsetFixed.x, mOffsetFixed.y, 0.0f ); eeVector2i start = StartTile(); eeVector2i end = EndTile(); @@ -155,14 +181,30 @@ void cMap::GridDraw() { } } + P.DrawBatch(); + GLi->PopMatrix(); } void cMap::GetMouseOverTile() { eeVector2i mouse = mWindow->GetInput()->GetMousePos(); - mMouseOverTile.x = ( mouse.x - mScreenPos.x - mOffset.x ) / mTileSize.Width(); - mMouseOverTile.y = ( mouse.y - mScreenPos.y - mOffset.y ) / mTileSize.Height(); + eeVector2i MapPos( mouse.x - mScreenPos.x - mOffset.x, mouse.y - mScreenPos.y - mOffset.y ); + + if ( MapPos.x < 0 ) + MapPos.x = 0; + + if ( MapPos.y < 0 ) + MapPos.y = 0; + + if ( MapPos.x > mPixelSize.x ) + MapPos.x = mPixelSize.x; + + if ( MapPos.y > mPixelSize.y ) + MapPos.y = mPixelSize.y; + + mMouseOverTile.x = MapPos.x / mTileSize.Width(); + mMouseOverTile.y = MapPos.y / mTileSize.Height(); if ( mMouseOverTile.x < 0 ) mMouseOverTile.x = 0; @@ -177,7 +219,8 @@ void cMap::GetMouseOverTile() { mMouseOverTile.y = mSize.Height() - 1; // Clamped pos - mMouseOverTileFinal = eeVector2u( mMouseOverTile.x, mMouseOverTile.y ); + mMouseOverTileFinal = eeVector2i( mMouseOverTile.x, mMouseOverTile.y ); + mMouseMapPos = eeVector2i( MapPos.x, MapPos.y ); } void cMap::Update() { @@ -189,10 +232,14 @@ const eeSize& cMap::ViewSize() const { return mViewSize; } -const eeVector2u& cMap::GetMouseTilePos() const { +const eeVector2i& cMap::GetMouseTilePos() const { return mMouseOverTileFinal; } +const eeVector2i& cMap::GetMouseMapPos() const { + return mMouseMapPos; +} + void cMap::ViewSize( const eeSize& viewSize ) { mViewSize = viewSize; @@ -294,6 +341,14 @@ Uint32 cMap::ClampBorders() const { return mFlags & MAP_FLAG_CLAMP_BODERS; } +Uint32 cMap::DrawTileOver() const { + return mFlags & MAP_FLAG_DRAW_TILE_OVER; +} + +void cMap::DrawTileOver( const bool& draw ) { + SetFlagValue( &mFlags, MAP_FLAG_DRAW_TILE_OVER, draw ? 1 : 0 ); +} + eeVector2f cMap::FixOffset() { return eeVector2f( (eeFloat)static_cast( mOffset.x ), (eeFloat)static_cast( mOffset.y ) ); } @@ -319,6 +374,10 @@ cGameObject * cMap::CreateGameObject( const Uint32& Type, const Uint32& Flags ) return NULL; } +const eeSize& cMap::TotalSize() const { + return mPixelSize; +} + const eeSize& cMap::TileSize() const { return mTileSize; } @@ -335,12 +394,395 @@ const Uint32& cMap::MaxLayers() const { return mMaxLayers; } +bool cMap::MoveLayerUp( cLayer * Layer ) { + Uint32 Lindex = GetLayerIndex( Layer ); + + if ( Lindex != MAP_LAYER_UNKNOWN && mLayerCount > 1 && ( Lindex < mLayerCount - 1 ) && ( Lindex + 1 < mLayerCount ) ) { + cLayer * tLayer = mLayers[ Lindex + 1 ]; + + mLayers[ Lindex ] = tLayer; + mLayers[ Lindex + 1 ] = Layer; + + return true; + } + + return false; +} + +bool cMap::MoveLayerDown( cLayer * Layer ) { + Uint32 Lindex = GetLayerIndex( Layer ); + + if ( Lindex != MAP_LAYER_UNKNOWN && mLayerCount > 1 && Lindex >= 1 ) { + cLayer * tLayer = mLayers[ Lindex - 1 ]; + + mLayers[ Lindex ] = tLayer; + mLayers[ Lindex - 1 ] = Layer; + + return true; + } + + return false; +} + +bool cMap::RemoveLayer( cLayer * Layer ) { + Uint32 Lindex = GetLayerIndex( Layer ); + + if ( Lindex != MAP_LAYER_UNKNOWN ) { + eeSAFE_DELETE( mLayers[ Lindex ] ); + + cLayer * LastLayer = NULL; + + // Reorder layers, to clean empty layers in between layers. + for ( Uint32 i = 0; i < mLayerCount; i++ ) { + if ( i > 0 && NULL != mLayers[i] && NULL == LastLayer ) { + mLayers[ i - 1 ] = mLayers[ i ]; + mLayers[ i ] = NULL; + } + + LastLayer = mLayers[i]; + } + + mLayerCount--; + + return true; + } + + return false; +} + +void cMap::ClearProperties() { + mProperties.clear(); +} + +void cMap::AddProperty( std::string Text, std::string Value ) { + mProperties[ Text ] = Value; +} + +void cMap::EditProperty( std::string Text, std::string Value ) { + mProperties[ Text ] = Value; +} + +void cMap::RemoveProperty( std::string Text ) { + mProperties.erase( Text ); +} + +cMap::PropertiesMap& cMap::GetProperties() { + return mProperties; +} + +void cMap::AddVirtualObjectType( const std::string& name ) { + mObjTypes.push_back( name ); + mObjTypes.unique(); +} + +void cMap::RemoveVirtualObjectType( const std::string& name ) { + mObjTypes.remove( name ); +} + +void cMap::ClearVirtualObjectTypes() { + mObjTypes.clear(); +} + +cMap::GOTypesList& cMap::GetVirtualObjectTypes() { + return mObjTypes; +} + +#define MAP_PROPERTY_SIZE (64) +#define LAYER_NAME_SIZE (64) +#define MAP_SHAPEGROUP_PATH_SIZE (128) + +typedef struct sPropertyHdrS { + char Name[ MAP_PROPERTY_SIZE ]; + char Value[ MAP_PROPERTY_SIZE ]; +} sPropertyHdr; + +typedef struct sMapShapeGroupS { + char Path[ MAP_SHAPEGROUP_PATH_SIZE ]; +} sMapShapeGroup; + +typedef struct sVirtualObjS { + char Name[ MAP_PROPERTY_SIZE ]; +} sVirtualObj; + +typedef struct sMapHdrS { + Uint32 Magic; + Uint32 SizeX; + Uint32 SizeY; + Uint32 MaxLayers; + Uint32 LayerCount; + Uint32 Flags; + Uint32 PropertyCount; + Uint32 ShapeGroupCount; + Uint32 VirtualObjectTypesCount; +} sMapHdr; + +typedef struct sLayerHdrS { + char Name[ LAYER_NAME_SIZE ]; + Uint32 Type; + Uint32 Flags; + Int32 OffsetX; + Int32 OffsetY; + Uint32 PropertyCount; + Uint32 ObjectCount; //! Only used by the Object Layer +} sLayerHdr; + +typedef struct sMapTileGOHdrS { + Uint32 Type; + Uint32 Id; + Uint32 Flags; +} sMapTileGOHdr; + +typedef struct sMapObjGOHdrS { + Uint32 Type; + Uint32 Id; + Uint32 Flags; + Int32 PosX; + Int32 PosY; +} sMapObjGOHdr; + void cMap::Load( const std::string& path ) { } -void cMap::Save( const std::string& path ) { +std::vector cMap::GetShapeGroups() { + cShapeGroupManager * SGM = cShapeGroupManager::instance(); + std::list& Res = SGM->GetResources(); + std::vector items; + + //! Ugly ugly ugly, but i don't see another way + Uint32 Restricted1 = MakeHash( std::string( "global" ) ); + Uint32 Restricted2 = MakeHash( UI::cUIThemeManager::instance()->DefaultTheme()->ShapeGroup()->Name() ); + + for ( std::list::iterator it = Res.begin(); it != Res.end(); it++ ) { + if ( (*it)->Id() != Restricted1 && (*it)->Id() != Restricted2 ) + items.push_back( (*it)->Path() ); + } + + return items; +} + +void cMap::Save( const std::string& path ) { + Uint32 i; + sMapHdr MapHdr; + cLayer * tLayer; + + std::vector ShapeGroups = GetShapeGroups(); + + MapHdr.Magic = ( ( 'E' << 0 ) | ( 'E' << 8 ) | ( 'M' << 16 ) | ( 'P' << 24 ) ); + MapHdr.Flags = mFlags; + MapHdr.MaxLayers = mMaxLayers; + MapHdr.SizeX = mSize.Width(); + MapHdr.SizeY = mSize.Height(); + MapHdr.LayerCount = mLayerCount; + MapHdr.PropertyCount = mProperties.size(); + MapHdr.ShapeGroupCount = ShapeGroups.size(); + MapHdr.VirtualObjectTypesCount = mObjTypes.size(); //! This is only usefull for the Map Editor, to auto add on the load the virtual object types that where used to create the map. + + std::fstream fs ( path.c_str() , std::ios::out | std::ios::binary ); + + if ( fs.is_open() ) { + //! Writes the map header + fs.write( reinterpret_cast ( &MapHdr ), sizeof(sMapHdr) ); + + //! Writes the layers type order ( because the object layers will be saved separately + for ( i = 0; i < mLayerCount; i++ ) { + if ( NULL != mLayers[i] ) { + fs.write( reinterpret_cast ( &mLayers[i]->Type() ), sizeof(Uint32) ); + } + } + + //! Writes the properties of the map + for ( cMap::PropertiesMap::iterator it = mProperties.begin(); it != mProperties.end(); it++ ) { + sPropertyHdr tProp; + + memset( tProp.Name, 0, MAP_PROPERTY_SIZE ); + memset( tProp.Value, 0, MAP_PROPERTY_SIZE ); + + StrCopy( tProp.Name, (*it).first.c_str(), MAP_PROPERTY_SIZE ); + StrCopy( tProp.Value, (*it).second.c_str(), MAP_PROPERTY_SIZE ); + + fs.write( reinterpret_cast ( &tProp ), sizeof(sPropertyHdr) ); + } + + //! Writes the shape groups that the map will need and load + for ( i = 0; i < ShapeGroups.size(); i++ ) { + sMapShapeGroup tSG; + + memset( tSG.Path, 0, MAP_SHAPEGROUP_PATH_SIZE ); + + StrCopy( tSG.Path, ShapeGroups[i].c_str(), MAP_SHAPEGROUP_PATH_SIZE ); + + fs.write( reinterpret_cast ( &tSG ), sizeof(sMapShapeGroup) ); + } + + //! Writes the names of the virtual object types created in the map editor + for ( GOTypesList::iterator votit = mObjTypes.begin(); votit != mObjTypes.end(); votit++ ) { + sVirtualObj tVObjH; + + memset( tVObjH.Name, 0, MAP_PROPERTY_SIZE ); + + StrCopy( tVObjH.Name, (*votit).c_str(), MAP_PROPERTY_SIZE ); + + fs.write( reinterpret_cast ( &tVObjH ), sizeof(sVirtualObj) ); + } + + //! Writes every layer header + for ( i = 0; i < mLayerCount; i++ ) { + tLayer = mLayers[i]; + sLayerHdr tLayerH; + + memset( tLayerH.Name, 0, LAYER_NAME_SIZE ); + + StrCopy( tLayerH.Name, tLayer->Name().c_str(), LAYER_NAME_SIZE ); + + tLayerH.Type = tLayer->Type(); + tLayerH.Flags = tLayer->Flags(); + tLayerH.OffsetX = tLayer->Offset().x; + tLayerH.OffsetY = tLayer->Offset().y; + tLayerH.ObjectCount = 0; + + cLayer::PropertiesMap& tLayerProp = tLayer->GetProperties(); + + tLayerH.PropertyCount = tLayerProp.size(); + + //! Writes the layer header + fs.write( reinterpret_cast ( &tLayerH ), sizeof(sLayerHdr) ); + + //! Writes the properties of the current layer + for ( cLayer::PropertiesMap::iterator lit = tLayerProp.begin(); lit != tLayerProp.end(); lit++ ) { + sPropertyHdr tProp; + + memset( tProp.Name, 0, MAP_PROPERTY_SIZE ); + memset( tProp.Value, 0, MAP_PROPERTY_SIZE ); + + StrCopy( tProp.Name, (*lit).first.c_str(), MAP_PROPERTY_SIZE ); + StrCopy( tProp.Value, (*lit).second.c_str(), MAP_PROPERTY_SIZE ); + } + } + + //! This method is slow, but allows to save big maps with little space needed, i'll add an alternative save method ( just plain layer -> tile object saving ) + Int32 x, y; + Uint32 tReadFlag = 0, z; + cTileLayer * tTLayer; + cGameObject * tObj; + + cGameObject * tObjects[ mLayerCount ]; + + //! First we save the tiled layers. + for ( y = 0; y < mSize.y; y++ ) { + for ( x = 0; x < mSize.x; x++ ) { + //! Reset Layer Read Flags and temporal objects + tReadFlag = 0; + + for ( z = 0; z < mLayerCount; z++ ) + tObjects[z] = NULL; + + //! Look at every layer if it's some data on the current tile, in that case it will write a bit flag to + //! inform that it's an object on the current tile layer, and it will store a temporal reference to the + //! object to write layer the object header information + for ( i = 0; i < mLayerCount; i++ ) { + tLayer = mLayers[i]; + + if ( NULL != tLayer && tLayer->Type() == MAP_LAYER_TILED ) { + tTLayer = reinterpret_cast ( tLayer ); + + tObj = tTLayer->GetGameObject( eeVector2i( x, y ) ); + + if ( NULL != tObj ) { + tReadFlag |= 1 << i; + + tObjects[i] = tObj; + } + } + } + + //! Writes the current tile flags + fs.write( reinterpret_cast ( &tReadFlag ), sizeof(Uint32) ); + + //! Writes every game object header corresponding to this tile + for ( i = 0; i < mLayerCount; i++ ) { + if ( tReadFlag & ( 1 << i ) ) { + tObj = tObjects[i]; + + sMapTileGOHdr tTGOHdr; + + //! The DataId should be the Shape hash name ( at least in the cases of type Shape, ShapeEx and Sprite. + tTGOHdr.Id = tObj->DataId(); + + //! If the object type is virtual, means that the real type is stored elsewhere. + if ( tObj->Type() != GAMEOBJECT_TYPE_VIRTUAL ) { + tTGOHdr.Type = tObj->Type(); + } else { + cGameObjectVirtual * tObjV = reinterpret_cast ( tObj ); + + tTGOHdr.Type = tObjV->RealType(); + } + + tTGOHdr.Flags = tObj->Flags(); + + fs.write( reinterpret_cast ( &tTGOHdr ), sizeof(sMapTileGOHdr) ); + } + } + } + } + + //! Then we save the Object layers. + std::list mObjLayers; + cObjectLayer * tOLayer; + + for ( i = 0; i < mLayerCount; i++ ) { + tLayer = mLayers[i]; + + if ( NULL != tLayer && tLayer->Type() == MAP_LAYER_OBJECT ) { + mObjLayers.push_back( reinterpret_cast ( tLayer ) ); + } + } + + for ( std::list::iterator oit = mObjLayers.begin(); oit != mObjLayers.end(); oit++ ) { + tOLayer = (*oit); + + sLayerHdr tLayerH; + + memset( tLayerH.Name, 0, LAYER_NAME_SIZE ); + + StrCopy( tLayerH.Name, tOLayer->Name().c_str(), LAYER_NAME_SIZE ); + + tLayerH.Type = tOLayer->Type(); + tLayerH.Flags = tOLayer->Flags(); + tLayerH.OffsetX = tOLayer->Offset().x; + tLayerH.OffsetY = tOLayer->Offset().y; + tLayerH.ObjectCount = tOLayer->GetObjectCount(); + + fs.write( reinterpret_cast ( &tLayerH ), sizeof(sLayerHdr) ); + + cObjectLayer::ObjList ObjList = tOLayer->GetObjectList(); + + for ( cObjectLayer::ObjList::iterator MapObjIt = ObjList.begin(); MapObjIt != ObjList.end(); MapObjIt++ ) { + tObj = (*MapObjIt); + + sMapTileGOHdr tTGOHdr; + + //! The DataId should be the Shape hash name ( at least in the cases of type Shape, ShapeEx and Sprite. + tTGOHdr.Id = tObj->DataId(); + + //! If the object type is virtual, means that the real type is stored elsewhere. + if ( tObj->Type() != GAMEOBJECT_TYPE_VIRTUAL ) { + tTGOHdr.Type = tObj->Type(); + } else { + cGameObjectVirtual * tObjV = reinterpret_cast ( tObj ); + + tTGOHdr.Type = tObjV->RealType(); + } + + tTGOHdr.Flags = tObj->Flags(); + + fs.write( reinterpret_cast ( &tTGOHdr ), sizeof(sMapTileGOHdr) ); + } + } + + fs.close(); + } } }} diff --git a/src/gaming/cmap.hpp b/src/gaming/cmap.hpp index b7943ccaf..65e1e54a0 100644 --- a/src/gaming/cmap.hpp +++ b/src/gaming/cmap.hpp @@ -14,8 +14,13 @@ using namespace EE::Window; namespace EE { namespace Gaming { +#define MAP_LAYER_UNKNOWN 0xFFFFFFFF + class cMap { public: + typedef std::map PropertiesMap; + typedef std::list GOTypesList; //! Special object types used in this map + cMap(); virtual ~cMap(); @@ -26,6 +31,8 @@ class cMap { virtual cLayer * GetLayer( Uint32 index ); + virtual Uint32 GetLayerIndex( cLayer * Layer ); + virtual cLayer * GetLayerByHash( Uint32 hash ); virtual cLayer * GetLayer( const std::string& name ); @@ -76,9 +83,41 @@ class cMap { Uint32 DrawGrid() const; + Uint32 DrawTileOver() const; + + void DrawTileOver( const bool& draw ); + void Reset(); - const eeVector2u& GetMouseTilePos() const; + bool MoveLayerUp( cLayer * Layer ); + + bool MoveLayerDown( cLayer * Layer ); + + bool RemoveLayer( cLayer * Layer ); + + const eeVector2i& GetMouseTilePos() const; + + const eeVector2i& GetMouseMapPos() const; + + const eeSize& TotalSize() const; + + void AddProperty( std::string Text, std::string Value ); + + void EditProperty( std::string Text, std::string Value ); + + void RemoveProperty( std::string Text ); + + void ClearProperties(); + + PropertiesMap& GetProperties(); + + void AddVirtualObjectType( const std::string& name ); + + void RemoveVirtualObjectType( const std::string& name ); + + void ClearVirtualObjectTypes(); + + GOTypesList& GetVirtualObjectTypes(); protected: cWindow * mWindow; cLayer** mLayers; @@ -86,6 +125,7 @@ class cMap { Uint32 mMaxLayers; Uint32 mLayerCount; eeSize mSize; + eeSize mPixelSize; eeSize mTileSize; eeSize mViewSize; eeVector2f mOffset; @@ -93,7 +133,11 @@ class cMap { eeVector2i mStartTile; eeVector2i mEndTile; eeVector2i mMouseOverTile; - eeVector2u mMouseOverTileFinal; + eeVector2i mMouseOverTileFinal; + eeVector2i mMouseMapPos; + eeVector2f mOffsetFixed; + PropertiesMap mProperties; + GOTypesList mObjTypes; cGameObject * CreateGameObject( const Uint32& Type, const Uint32& Flags ); @@ -107,7 +151,11 @@ class cMap { void GridDraw(); + void MouseOverDraw(); + void DeleteLayers(); + + std::vector GetShapeGroups(); }; }} diff --git a/src/gaming/cobjectlayer.cpp b/src/gaming/cobjectlayer.cpp index ed62a7287..0c0c55dc9 100644 --- a/src/gaming/cobjectlayer.cpp +++ b/src/gaming/cobjectlayer.cpp @@ -13,6 +13,7 @@ cObjectLayer::cObjectLayer( cMap * map, Uint32 flags, std::string name, eeVector } cObjectLayer::~cObjectLayer() { + DeallocateLayer(); } void cObjectLayer::AllocateLayer() { @@ -47,12 +48,48 @@ void cObjectLayer::Update() { } } +Uint32 cObjectLayer::GetObjectCount() const { + return mObjects.size(); +} + void cObjectLayer::AddGameObject( cGameObject * obj ) { mObjects.push_back( obj ); } void cObjectLayer::RemoveGameObject( cGameObject * obj ) { mObjects.remove( obj ); + + eeSAFE_DELETE( obj ); +} + +void cObjectLayer::RemoveGameObject( const eeVector2i& pos ) { + cGameObject * tObj = GetObjectOver( pos ); + + if ( NULL != tObj ) { + RemoveGameObject( tObj ); + } +} + +cGameObject * cObjectLayer::GetObjectOver( const eeVector2i& pos ) { + cGameObject * tObj; + register eeVector2f tPos; + register eeSize tSize; + + for ( ObjList::reverse_iterator it = mObjects.rbegin(); it != mObjects.rend(); it++ ) { + tObj = (*it); + + tPos = tObj->Pos(); + tSize = tObj->Size(); + + if ( Contains( eeRecti( tPos.x, tPos.y, tPos.x + tSize.x, tPos.y + tSize.y ), pos ) ) + return tObj; + } + + return NULL; +} + +cObjectLayer::ObjList& cObjectLayer::GetObjectList() { + return mObjects; } }} diff --git a/src/gaming/cobjectlayer.hpp b/src/gaming/cobjectlayer.hpp index e9efc83ef..3686b30c0 100644 --- a/src/gaming/cobjectlayer.hpp +++ b/src/gaming/cobjectlayer.hpp @@ -10,6 +10,8 @@ class cMap; class cObjectLayer : public cLayer { public: + typedef std::list ObjList; + virtual ~cObjectLayer(); virtual void Draw( const eeVector2f &Offset = eeVector2f(0,0) ); @@ -19,11 +21,15 @@ class cObjectLayer : public cLayer { virtual void AddGameObject( cGameObject * obj ); virtual void RemoveGameObject( cGameObject * obj ); + + virtual void RemoveGameObject( const eeVector2i& pos ); + + virtual cGameObject * GetObjectOver( const eeVector2i& pos ); + + virtual Uint32 GetObjectCount() const; protected: friend class cMap; - typedef std::list ObjList; - ObjList mObjects; cObjectLayer( cMap * map, Uint32 flags, std::string name = "", eeVector2f offset = eeVector2f(0,0) ); @@ -31,6 +37,8 @@ class cObjectLayer : public cLayer { void AllocateLayer(); void DeallocateLayer(); + + ObjList& GetObjectList(); }; }} diff --git a/src/gaming/ctilelayer.cpp b/src/gaming/ctilelayer.cpp index 44b58f13d..61fea3e0a 100644 --- a/src/gaming/ctilelayer.cpp +++ b/src/gaming/ctilelayer.cpp @@ -76,7 +76,9 @@ void cTileLayer::DeallocateLayer() { eeSAFE_DELETE_ARRAY( mTiles ); } -void cTileLayer::AddGameObject( cGameObject * obj, const eeVector2u& TilePos ) { +void cTileLayer::AddGameObject( cGameObject * obj, const eeVector2i& TilePos ) { + eeASSERT( TilePos.x >= 0 && TilePos.y >= 0 ); + RemoveGameObject( TilePos ); mTiles[ TilePos.x ][ TilePos.y ] = obj; @@ -84,13 +86,15 @@ void cTileLayer::AddGameObject( cGameObject * obj, const eeVector2u& TilePos ) { obj->Pos( eeVector2f( TilePos.x * mMap->TileSize().x, TilePos.y * mMap->TileSize().y ) ); } -void cTileLayer::RemoveGameObject( const eeVector2u& TilePos ) { +void cTileLayer::RemoveGameObject( const eeVector2i& TilePos ) { + eeASSERT( TilePos.x >= 0 && TilePos.y >= 0 ); + if ( NULL != mTiles[ TilePos.x ][ TilePos.y ] ) { eeSAFE_DELETE( mTiles[ TilePos.x ][ TilePos.y ] ); } } -cGameObject * cTileLayer::GetGameObject( const eeVector2u& TilePos ) { +cGameObject * cTileLayer::GetGameObject( const eeVector2i& TilePos ) { return mTiles[ TilePos.x ][ TilePos.y ]; } diff --git a/src/gaming/ctilelayer.hpp b/src/gaming/ctilelayer.hpp index d10d47081..cc9a42073 100644 --- a/src/gaming/ctilelayer.hpp +++ b/src/gaming/ctilelayer.hpp @@ -14,11 +14,11 @@ class cTileLayer : public cLayer { virtual void Update(); - virtual void AddGameObject( cGameObject * obj, const eeVector2u& TilePos ); + virtual void AddGameObject( cGameObject * obj, const eeVector2i& TilePos ); - virtual void RemoveGameObject( const eeVector2u& TilePos ); + virtual void RemoveGameObject( const eeVector2i& TilePos ); - virtual cGameObject * GetGameObject( const eeVector2u& TilePos ); + virtual cGameObject * GetGameObject( const eeVector2i& TilePos ); protected: friend class cMap; diff --git a/src/gaming/mapeditor/cmapeditor.cpp b/src/gaming/mapeditor/cmapeditor.cpp index 7656bc50a..d2561a62c 100644 --- a/src/gaming/mapeditor/cmapeditor.cpp +++ b/src/gaming/mapeditor/cmapeditor.cpp @@ -4,6 +4,7 @@ #include "cuigotypenew.hpp" #include "../ctilelayer.hpp" #include "../cobjectlayer.hpp" +#include "../cgameobjectvirtual.hpp" #include "../cgameobjectshape.hpp" #include "../cgameobjectshapeex.hpp" #include "../cgameobjectsprite.hpp" @@ -92,11 +93,13 @@ void cMapEditor::CreateWinMenu() { reinterpret_cast ( PU3->GetItem( "Show Grid" ) )->Active( true ); + PU3->AddCheckBox( "Mark Tile Over" ); + PU3->AddEventListener( cUIEvent::EventOnItemClicked, cb::Make1( this, &cMapEditor::ViewMenuClick ) ); WinMenu->AddMenuButton( "View", PU3 ); cUIPopUpMenu * PU4 = mTheme->CreatePopUpMenu(); - PU4->Add( "Create New Texture Group..." ); + PU4->Add( "New Texture Group..." ); PU4->Add( "Add External Texture Group..." ); PU4->AddSeparator(); PU4->Add( "Map Properties..." ); @@ -108,6 +111,11 @@ void cMapEditor::CreateWinMenu() { PU5->Add( "Add Tile Layer..." ); PU5->Add( "Add Object Layer..." ); PU5->AddSeparator(); + PU5->Add( "Remove Layer" ); + PU5->AddSeparator(); + PU5->Add( "Move Layer Up" ); + PU5->Add( "Move Layer Down" ); + PU5->AddSeparator(); PU5->Add( "Layer Properties..." ); PU5->AddEventListener( cUIEvent::EventOnItemClicked, cb::Make1( this, &cMapEditor::LayerMenuClick ) ); @@ -124,27 +132,25 @@ void cMapEditor::CreateWinMenu() { } void cMapEditor::CreateETGMenu() { + cUITextBox * Txt; + Uint32 TxtFlags = UI_CONTROL_DEFAULT_ALIGN | UI_ANCHOR_RIGHT | UI_ANCHOR_TOP | UI_DRAW_SHADOW; + Int32 Width = 200; Int32 DistToBorder = 5; - Uint32 TxtFlags = UI_CONTROL_DEFAULT_ALIGN | UI_ANCHOR_RIGHT | UI_ANCHOR_TOP | UI_DRAW_SHADOW; + cUIComplexControl::CreateParams CParams; + CParams.Parent( mWinContainer ); + CParams.PosSet( eeVector2i( mWinContainer->Size().Width() - Width - DistToBorder, 0 ) ); + CParams.SizeSet( eeSize( Width + DistToBorder, mWinContainer->Size().Height() ) ); + CParams.Flags = UI_CONTROL_DEFAULT_ALIGN | UI_ANCHOR_RIGHT | UI_ANCHOR_TOP; + mRPCont = eeNew( cUIComplexControl, ( CParams ) ); + mRPCont->Enabled( true ); + mRPCont->Visible( true ); - cUITextBox * Txt = mTheme->CreateTextBox( mWinContainer, eeSize( Width, 16 ), eeVector2i( mWinContainer->Size().Width() - Width - DistToBorder, 4 ), TxtFlags ); - Txt->Text( "Shape Groups:" ); - - mShapeGroupsList = mTheme->CreateDropDownList( mWinContainer, eeSize( Width, 21 ), eeVector2i( mWinContainer->Size().Width() - Width - DistToBorder, Txt->Pos().y +Txt->Size().Height() + 4 ), UI_CONTROL_DEFAULT_ALIGN | UI_CLIP_ENABLE | UI_AUTO_PADDING | UI_ANCHOR_RIGHT | UI_ANCHOR_TOP ); - mShapeGroupsList->AddEventListener( cUIEvent::EventOnItemSelected, cb::Make1( this, &cMapEditor::OnShapeGroupChange ) ); - - mShapeList = mTheme->CreateListBox( mWinContainer, eeSize( Width, 156 ), eeVector2i( mWinContainer->Size().Width() - Width - DistToBorder, mShapeGroupsList->Pos().y + mShapeGroupsList->Size().Height() + 4 ), UI_CONTROL_DEFAULT_ALIGN | UI_CLIP_ENABLE | UI_AUTO_PADDING | UI_ANCHOR_RIGHT | UI_ANCHOR_TOP ); - mShapeList->AddEventListener( cUIEvent::EventOnItemSelected, cb::Make1( this, &cMapEditor::OnShapeChange ) ); - - mGfxPreview = mTheme->CreateGfx( NULL, mWinContainer, eeSize( Width, Width ), eeVector2i( mWinContainer->Size().Width() - Width - DistToBorder, mShapeList->Pos().y + mShapeList->Size().Height() + 4 ), UI_VALIGN_CENTER | UI_HALIGN_CENTER | UI_ANCHOR_RIGHT | UI_ANCHOR_TOP | UI_AUTO_FIT ); - mGfxPreview->Border( true ); - - Txt = mTheme->CreateTextBox( mWinContainer, eeSize( Width, 16 ), eeVector2i( mWinContainer->Size().Width() - Width - DistToBorder, mGfxPreview->Pos().y + mGfxPreview->Size().Height() + 4 ), TxtFlags ); + Txt = mTheme->CreateTextBox( mRPCont, eeSize( Width, 16 ), eeVector2i( 0, 4 ), TxtFlags ); Txt->Text( "Add Game Object as..." ); - mGOTypeList = mTheme->CreateDropDownList( mWinContainer, eeSize( Width - 26, 21 ), eeVector2i( mWinContainer->Size().Width() - Width - DistToBorder, Txt->Pos().y + Txt->Size().Height() + 4 ), UI_CONTROL_DEFAULT_ALIGN | UI_CLIP_ENABLE | UI_AUTO_PADDING | UI_ANCHOR_RIGHT | UI_ANCHOR_TOP ); + mGOTypeList = mTheme->CreateDropDownList( mRPCont, eeSize( Width - 26, 21 ), eeVector2i( 0, Txt->Pos().y + Txt->Size().Height() + 4 ), UI_CONTROL_DEFAULT_ALIGN | UI_CLIP_ENABLE | UI_AUTO_PADDING | UI_ANCHOR_RIGHT | UI_ANCHOR_TOP ); std::vector items; items.push_back( "Shape" ); items.push_back( "ShapeEx" ); @@ -153,42 +159,99 @@ void cMapEditor::CreateETGMenu() { mGOTypeList->AddEventListener( cUIEvent::EventOnItemSelected, cb::Make1( this, &cMapEditor::OnTypeChange ) ); mGOTypeList->ListBox()->SetSelected(0); - mBtnGOTypeAdd = mTheme->CreatePushButton( mWinContainer, eeSize( 24, 21 ), eeVector2i( mGOTypeList->Pos().x + mGOTypeList->Size().Width() + 2, mGOTypeList->Pos().y ), UI_CONTROL_DEFAULT_FLAGS_CENTERED | UI_AUTO_SIZE, mTheme->GetIconByName( "add" ) ); + mBtnGOTypeAdd = mTheme->CreatePushButton( mRPCont, eeSize( 24, 21 ), eeVector2i( mGOTypeList->Pos().x + mGOTypeList->Size().Width() + 2, mGOTypeList->Pos().y ), UI_CONTROL_ALIGN_CENTER | UI_AUTO_SIZE | UI_ANCHOR_RIGHT | UI_ANCHOR_TOP, mTheme->GetIconByName( "add" ) ); mBtnGOTypeAdd->AddEventListener( cUIEvent::EventMouseClick, cb::Make1( this, &cMapEditor::AddNewGOType ) ); if ( NULL == mBtnGOTypeAdd->Icon()->Shape() ) mBtnGOTypeAdd->Text( "..." ); - Txt = mTheme->CreateTextBox( mWinContainer, eeSize( Width, 16 ), eeVector2i( mWinContainer->Size().Width() - Width - DistToBorder, mGOTypeList->Pos().y + mGOTypeList->Size().Height() + 4 ), TxtFlags ); + Txt = mTheme->CreateTextBox( mRPCont, eeSize( Width, 16 ), eeVector2i( 0, mGOTypeList->Pos().y + mGOTypeList->Size().Height() + 4 ), TxtFlags ); Txt->Text( "Layers:" ); - mLayerList = mTheme->CreateDropDownList( mWinContainer, eeSize( Width, 21 ), eeVector2i( mWinContainer->Size().Width() - Width - DistToBorder, Txt->Pos().y + Txt->Size().Height() + 4 ), UI_CONTROL_DEFAULT_ALIGN | UI_CLIP_ENABLE | UI_AUTO_PADDING | UI_ANCHOR_RIGHT | UI_ANCHOR_TOP ); + mLayerList = mTheme->CreateDropDownList( mRPCont, eeSize( Width, 21 ), eeVector2i( 0, Txt->Pos().y + Txt->Size().Height() + 4 ), UI_CONTROL_DEFAULT_ALIGN | UI_CLIP_ENABLE | UI_AUTO_PADDING | UI_ANCHOR_RIGHT | UI_ANCHOR_TOP ); mLayerList->AddEventListener( cUIEvent::EventOnItemSelected, cb::Make1( this, &cMapEditor::OnLayerSelect ) ); - Txt = mTheme->CreateTextBox( mWinContainer, eeSize( Width, 16 ), eeVector2i( mWinContainer->Size().Width() - Width - DistToBorder, mLayerList->Pos().y + mLayerList->Size().Height() + 4 ), TxtFlags ); + Txt = mTheme->CreateTextBox( mRPCont, eeSize( Width, 16 ), eeVector2i( 0, mLayerList->Pos().y + mLayerList->Size().Height() + 4 ), TxtFlags ); Txt->Text( "Game Object Flags:" ); Uint32 ChkFlags = UI_CONTROL_DEFAULT_ALIGN | UI_AUTO_SIZE | UI_ANCHOR_RIGHT | UI_ANCHOR_TOP; - mChkMirrored = mTheme->CreateCheckBox( mWinContainer, eeSize(), eeVector2i( mWinContainer->Size().Width() - Width - DistToBorder, Txt->Pos().y + Txt->Size().Height() + 4 ), ChkFlags ); + mChkMirrored = mTheme->CreateCheckBox( mRPCont, eeSize(), eeVector2i( 0, Txt->Pos().y + Txt->Size().Height() + 4 ), ChkFlags ); mChkMirrored->Text( "Mirrored" ); mChkMirrored->AddEventListener( cUIEvent::EventMouseClick, cb::Make1( this, &cMapEditor::ChkClickMirrored ) ); - mChkFliped = mTheme->CreateCheckBox( mWinContainer, eeSize(), eeVector2i( mChkMirrored->Pos().x + mChkMirrored->Size().Width() + 32, mChkMirrored->Pos().y ), ChkFlags ); + mChkFliped = mTheme->CreateCheckBox( mRPCont, eeSize(), eeVector2i( mChkMirrored->Pos().x + mChkMirrored->Size().Width() + 32, mChkMirrored->Pos().y ), ChkFlags ); mChkFliped->Text( "Fliped" ); mChkFliped->AddEventListener( cUIEvent::EventMouseClick, cb::Make1( this, &cMapEditor::ChkClickFliped ) ); - mChkBlocked = mTheme->CreateCheckBox( mWinContainer, eeSize(), eeVector2i( mChkMirrored->Pos().x, mChkMirrored->Pos().y + mChkMirrored->Size().Height() + 4 ), ChkFlags ); + mChkBlocked = mTheme->CreateCheckBox( mRPCont, eeSize(), eeVector2i( mChkMirrored->Pos().x, mChkMirrored->Pos().y + mChkMirrored->Size().Height() + 4 ), ChkFlags ); mChkBlocked->Text( "Blocked" ); mChkBlocked->AddEventListener( cUIEvent::EventMouseClick, cb::Make1( this, &cMapEditor::ChkClickBlocked ) ); - mChkAnim = mTheme->CreateCheckBox( mWinContainer, eeSize(), eeVector2i( mChkFliped->Pos().x, mChkFliped->Pos().y + mChkFliped->Size().Height() + 4 ), ChkFlags ); + mChkAnim = mTheme->CreateCheckBox( mRPCont, eeSize(), eeVector2i( mChkFliped->Pos().x, mChkFliped->Pos().y + mChkFliped->Size().Height() + 4 ), ChkFlags ); mChkAnim->Text( "Animated" ); mChkAnim->AddEventListener( cUIEvent::EventMouseClick, cb::Make1( this, &cMapEditor::ChkClickAnimated ) ); + Txt = mTheme->CreateTextBox( mRPCont, eeSize( Width, 16 ), eeVector2i( 0, mChkBlocked->Pos().y + mChkBlocked->Size().Height() + 8 ), TxtFlags ); + Txt->Text( "Game Object Data:" ); + + mChkDI = mTheme->CreateCheckBox( mRPCont, eeSize(), eeVector2i( 0, Txt->Pos().y + Txt->Size().Height() + 4 ), ChkFlags ); + mChkDI->Text( "Add as DataId" ); + mChkDI->AddEventListener( cUIEvent::EventMouseClick, cb::Make1( this, &cMapEditor::ChkClickDI ) ); + + cUIComplexControl::CreateParams SGParams; + SGParams.Parent( mRPCont ); + SGParams.PosSet( eeVector2i( 0, mChkDI->Pos().y + mChkDI->Size().Height() + 8 ) ); + SGParams.SizeSet( eeSize( Width, 400 ) ); + SGParams.Flags = UI_CONTROL_DEFAULT_ALIGN | UI_ANCHOR_RIGHT | UI_ANCHOR_TOP; + mSGCont = eeNew( cUIComplexControl, ( SGParams ) ); + mSGCont->Enabled( true ); + mSGCont->Visible( true ); + + Txt = mTheme->CreateTextBox( mSGCont, eeSize( Width, 16 ), eeVector2i( 0, 0 ), TxtFlags ); + Txt->Text( "Shape Groups:" ); + + mShapeGroupsList = mTheme->CreateDropDownList( mSGCont, eeSize( Width, 21 ), eeVector2i( 0, Txt->Pos().y +Txt->Size().Height() + 4 ), UI_CONTROL_DEFAULT_ALIGN | UI_CLIP_ENABLE | UI_AUTO_PADDING | UI_ANCHOR_RIGHT | UI_ANCHOR_TOP ); + mShapeGroupsList->AddEventListener( cUIEvent::EventOnItemSelected, cb::Make1( this, &cMapEditor::OnShapeGroupChange ) ); + + mShapeList = mTheme->CreateListBox( mSGCont, eeSize( Width, 156 ), eeVector2i( 0, mShapeGroupsList->Pos().y + mShapeGroupsList->Size().Height() + 4 ), UI_CONTROL_DEFAULT_ALIGN | UI_CLIP_ENABLE | UI_AUTO_PADDING | UI_ANCHOR_RIGHT | UI_ANCHOR_TOP ); + mShapeList->Size( mShapeList->Size().Width(), mShapeList->RowHeight() * 9 + mShapeList->PaddingContainer().Top + mShapeList->PaddingContainer().Bottom ); + mShapeList->AddEventListener( cUIEvent::EventOnItemSelected, cb::Make1( this, &cMapEditor::OnShapeChange ) ); + + mGfxPreview = mTheme->CreateGfx( NULL, mSGCont, eeSize( Width, Width ), eeVector2i( 0, mShapeList->Pos().y + mShapeList->Size().Height() + 4 ), UI_VALIGN_CENTER | UI_HALIGN_CENTER | UI_ANCHOR_RIGHT | UI_ANCHOR_TOP | UI_AUTO_FIT ); + mGfxPreview->Border( true ); + + cUIComplexControl::CreateParams DIParams; + DIParams.Parent( mRPCont ); + DIParams.PosSet( SGParams.Pos ); + DIParams.SizeSet( eeSize( Width, 400 ) ); + DIParams.Flags = UI_CONTROL_DEFAULT_ALIGN | UI_ANCHOR_RIGHT | UI_ANCHOR_TOP; + mDICont = eeNew( cUIComplexControl, ( DIParams ) ); + mDICont->Enabled( false ); + mDICont->Visible( false ); + + Txt = mTheme->CreateTextBox( mDICont, eeSize( Width, 16 ), eeVector2i( 0, 0 ), TxtFlags ); + Txt->Text( "DataId String:" ); + + mDataIdInput = mTheme->CreateTextInput( mDICont, eeSize( Width / 4 * 3, 21 ), eeVector2i( 8, Txt->Pos().y + Txt->Size().Height() + 8 ), UI_CONTROL_DEFAULT_ALIGN | UI_CLIP_ENABLE | UI_AUTO_PADDING | UI_AUTO_SIZE ); + FillSGCombo(); } +void cMapEditor::ChkClickDI( const cUIEvent * Event ) { + if ( mChkDI->Active() ) { + mSGCont->Enabled( false ); + mSGCont->Visible( false ); + mDICont->Enabled( true ); + mDICont->Visible( true ); + } else { + mSGCont->Enabled( true ); + mSGCont->Visible( true ); + mDICont->Enabled( false ); + mDICont->Visible( false ); + } +} + void cMapEditor::UpdateGfx() { if ( mChkMirrored->Active() && mChkFliped->Active() ) mGfxPreview->RenderType( RN_FLIPMIRROR ); @@ -224,10 +287,13 @@ void cMapEditor::OnTypeChange( const cUIEvent * Event ) { else if ( mGOTypeList->Text() == "Sprite" ) mCurGOType = GAMEOBJECT_TYPE_SPRITE; else - mCurGOType = MakeHash( mGOTypeList->Text() ); + mCurGOType = MakeHash( mGOTypeList->Text().ToUtf8() ); - if ( NULL != mChkAnim && NULL != mGOTypeList && mChkAnim->Active() && mGOTypeList->Text() != "Sprite" ) - mChkAnim->Active( false ); + if ( NULL != mChkAnim && NULL != mGOTypeList && mChkAnim->Active() && mGOTypeList->Text() != "Sprite" ) { + if ( mGOTypeList->Text() == "Shape" || mGOTypeList->Text() == "ShapeEx" ) { + mChkAnim->Active( false ); + } + } } void cMapEditor::ChkClickMirrored( const cUIEvent * Event ) { @@ -247,7 +313,7 @@ void cMapEditor::ChkClickBlocked( const cUIEvent * Event ) { void cMapEditor::ChkClickAnimated( const cUIEvent * Event ) { UpdateFlags(); - if ( mChkAnim->Active() ) { + if ( mChkAnim->Active() && ( mGOTypeList->Text() == "Shape" || mGOTypeList->Text() == "ShapeEx" ) ) { mGOTypeList->ListBox()->SetSelected( "Sprite" ); } } @@ -257,8 +323,17 @@ void cMapEditor::AddNewGOType( const cUIEvent * Event ) { } void cMapEditor::OnNewGOTypeAdded( std::string name, Uint32 hash ) { - if ( "" != name ) + if ( "" != name ) { + for ( Uint32 i = 0; i < mGOTypeList->ListBox()->Count(); i++ ) { + cUIListBoxItem * Item = mGOTypeList->ListBox()->GetItem(i); + + if ( Item->Text() == name ) + return; + } + mGOTypeList->ListBox()->AddListBoxItem( name ); + mUIMap->Map()->AddVirtualObjectType( name ); + } } void cMapEditor::FillSGCombo() { @@ -301,10 +376,14 @@ void cMapEditor::FillShapeList() { } if ( items.size() ) { + std::sort( items.begin(), items.end() ); + mShapeList->AddListBoxItems( items ); mShapeList->SetSelected( 0 ); } } + + mShapeList->VerticalScrollBar()->ClickStep( 8.f / (eeFloat)mShapeList->Count() ); } void cMapEditor::OnShapeChange( const cUIEvent * Event ) { @@ -346,6 +425,7 @@ void cMapEditor::CreateUIMap() { mUIMap->Map()->Create( eeSize( 100, 100 ), 16, eeSize( 32, 32 ), MAP_FLAG_DRAW_GRID | MAP_FLAG_CLAMP_BODERS | MAP_FLAG_CLIP_AREA, Params.Size ); mUIMap->AddEventListener( cUIEvent::EventOnSizeChange, cb::Make1( this, &cMapEditor::OnMapSizeChange ) ); mUIMap->AddEventListener( cUIEvent::EventMouseDown, cb::Make1( this, &cMapEditor::OnMapMouseDown ) ); + mUIMap->AddEventListener( cUIEvent::EventMouseClick, cb::Make1( this, &cMapEditor::OnMapMouseClick ) ); mMapHScroll = mTheme->CreateScrollBar( mWinContainer, eeSize( Params.Size.Width(), 15 ), eeVector2i( 0, Params.Size.Height() ), UI_ANCHOR_LEFT | UI_ANCHOR_RIGHT | UI_ANCHOR_BOTTOM ); mMapHScroll->AddEventListener( cUIEvent::EventOnValueChange, cb::Make1( this, &cMapEditor::OnScrollMapH ) ); @@ -358,10 +438,10 @@ void cMapEditor::CreateUIMap() { void cMapEditor::OnMapSizeChange( const cUIEvent *Event ) { mMapHScroll->MinValue( 0 ); - mMapHScroll->MaxValue( mUIMap->Map()->Size().Width() * mUIMap->Map()->TileSize().Width() - mUIMap->Size().Width() ); + mMapHScroll->MaxValue( mUIMap->Map()->TotalSize().Width() - mUIMap->Size().Width() ); mMapHScroll->ClickStep( mUIMap->Map()->TileSize().Width() ); mMapVScroll->MinValue( 0 ); - mMapVScroll->MaxValue( mUIMap->Map()->Size().Height() * mUIMap->Map()->TileSize().Height() - mUIMap->Size().Height() ); + mMapVScroll->MaxValue( mUIMap->Map()->TotalSize().Height() - mUIMap->Size().Height() ); mMapVScroll->ClickStep( mUIMap->Map()->TileSize().Height() ); } @@ -408,6 +488,9 @@ void cMapEditor::FileMenuClick( const cUIEvent * Event ) { TGDialog->AddEventListener( cUIEvent::EventOpenFile, cb::Make1( this, &cMapEditor::MapOpen ) ); TGDialog->Center(); TGDialog->Show(); + } else if ( "Save" == txt ) { + //! Testing, temporal! + mUIMap->Map()->Save( GetProcessPath() + "data/test.eem" ); } else if ( "Quit" == txt ) { if ( mUIWindow == cUIManager::instance()->MainControl() ) { cUIManager::instance()->GetWindow()->Close(); @@ -429,6 +512,8 @@ void cMapEditor::ViewMenuClick( const cUIEvent * Event ) { if ( "Show Grid" == txt ) { mUIMap->Map()->DrawGrid( reinterpret_cast ( Event->Ctrl() )->Active() ); + } else if ( "Mark Tile Over" == txt ) { + mUIMap->Map()->DrawTileOver( reinterpret_cast ( Event->Ctrl() )->Active() ); } } void cMapEditor::MapMenuClick( const cUIEvent * Event ) { @@ -457,6 +542,54 @@ void cMapEditor::LayerMenuClick( const cUIEvent * Event ) { eeNew( cUILayerNew, ( mUIMap, MAP_LAYER_TILED, cb::Make1( this, &cMapEditor::OnLayerAdd ) ) ); } else if ( "Add Object Layer..." == txt ) { eeNew( cUILayerNew, ( mUIMap, MAP_LAYER_OBJECT, cb::Make1( this, &cMapEditor::OnLayerAdd ) ) ); + } else if ( "Remove Layer" == txt ) { + RemoveLayer(); + } else if ( "Move Layer Up" == txt ) { + MoveLayerUp(); + } else if ( "Move Layer Down" == txt ) { + MoveLayerDown(); + } +} + +void cMapEditor::MoveLayerUp() { + if ( mUIMap->Map()->MoveLayerUp( mCurLayer ) ) { + RefreshLayersList(); + } +} + +void cMapEditor::MoveLayerDown() { + if ( mUIMap->Map()->MoveLayerDown( mCurLayer ) ) { + RefreshLayersList(); + } +} + +void cMapEditor::RemoveLayer() { + if ( mUIMap->Map()->RemoveLayer( mCurLayer ) ) { + mCurLayer = NULL; + + RefreshLayersList(); + } +} + +void cMapEditor::RefreshLayersList() { + mLayerList->ListBox()->Clear(); + + if ( mUIMap->Map()->LayerCount() ) { + std::vector layers; + + for ( Uint32 i = 0; i < mUIMap->Map()->LayerCount(); i++ ) { + layers.push_back( mUIMap->Map()->GetLayer(i)->Name() ); + } + + mLayerList->ListBox()->AddListBoxItems( layers ); + } + + if ( NULL != mCurLayer ) { + mLayerList->ListBox()->SetSelected( mCurLayer->Name() ); + } else { + if ( mUIMap->Map()->LayerCount() ) { + mLayerList->ListBox()->SetSelected(0); + } } } @@ -525,7 +658,11 @@ cGameObject * cMapEditor::CreateGameObject() { } } else { //! Creates an empty game object. The client will interpret the GameObject Type, and instanciate the corresponding class. - tObj = eeNew( cGameObject, ( mCurGOFlags ) ); + + if ( mChkDI->Active() ) + tObj = eeNew( cGameObjectVirtual, ( MakeHash( mDataIdInput->Text().ToUtf8() ), mCurGOFlags, mCurGOType ) ); + else + tObj = eeNew( cGameObjectVirtual, ( mGfxPreview->Shape(), mCurGOFlags, mCurGOType ) ); } return tObj; @@ -536,8 +673,12 @@ void cMapEditor::AddGameObjectToTile() { cMap * tMap = mUIMap->Map(); cGameObject * tObj = CreateGameObject(); - if ( NULL != tObj ) + if ( NULL != tObj ) { + if ( tObj->Type() == GAMEOBJECT_TYPE_VIRTUAL ) + reinterpret_cast ( tObj )->SetLayer( tLayer ); + tLayer->AddGameObject( tObj, tMap->GetMouseTilePos() ); + } } void cMapEditor::RemoveGameObjectFromTile() { @@ -547,6 +688,44 @@ void cMapEditor::RemoveGameObjectFromTile() { tLayer->RemoveGameObject( tMap->GetMouseTilePos() ); } +void cMapEditor::AddGameObject() { + cObjectLayer * tLayer = reinterpret_cast ( mCurLayer ); + cMap * tMap = mUIMap->Map(); + cGameObject * tObj = CreateGameObject(); + + if ( NULL != tObj ) { + if ( tObj->Type() == GAMEOBJECT_TYPE_VIRTUAL ) + reinterpret_cast ( tObj )->SetLayer( tLayer ); + + eeVector2i p( tMap->GetMouseMapPos() ); + + tObj->Pos( eeVector2f( p.x, p.y ) ); + tLayer->AddGameObject( tObj ); + } +} + +void cMapEditor::RemoveGameObject() { + cObjectLayer * tLayer = reinterpret_cast ( mCurLayer ); + cMap * tMap = mUIMap->Map(); + + tLayer->RemoveGameObject( tMap->GetMouseMapPos() ); +} + +void cMapEditor::OnMapMouseClick( const cUIEvent * Event ) { + const cUIEventMouse * MEvent = reinterpret_cast ( Event ); + + if ( NULL == mCurLayer || NULL == mGfxPreview->Shape() || cUIManager::instance()->DownControl() != mUIMap ) + return; + + if ( MEvent->Flags() & EE_BUTTON_LMASK ) { + if ( mCurLayer->Type() == MAP_LAYER_OBJECT ) + AddGameObject(); + } else if ( MEvent->Flags() & EE_BUTTON_RMASK ) { + if ( mCurLayer->Type() == MAP_LAYER_OBJECT ) + RemoveGameObject(); + } +} + void cMapEditor::OnMapMouseDown( const cUIEvent * Event ) { const cUIEventMouse * MEvent = reinterpret_cast ( Event ); diff --git a/src/gaming/mapeditor/cmapeditor.hpp b/src/gaming/mapeditor/cmapeditor.hpp index 0ece6d73c..fca6acda0 100644 --- a/src/gaming/mapeditor/cmapeditor.hpp +++ b/src/gaming/mapeditor/cmapeditor.hpp @@ -43,6 +43,11 @@ class cMapEditor { cUIPushButton * mBtnGOTypeAdd; Uint32 mCurGOType; Uint32 mCurGOFlags; + cUIComplexControl * mRPCont; + cUIComplexControl * mSGCont; + cUIComplexControl * mDICont; + cUICheckBox * mChkDI; + cUITextInput * mDataIdInput; void WindowClose( const cUIEvent * Event ); @@ -98,8 +103,12 @@ class cMapEditor { void ChkClickAnimated( const cUIEvent * Event ); + void ChkClickDI( const cUIEvent * Event ); + void OnMapMouseDown( const cUIEvent * Event ); + void OnMapMouseClick( const cUIEvent * Event ); + void OnLayerAdd( cUILayerNew * UILayer ); void AddNewGOType( const cUIEvent * Event ); @@ -114,7 +123,19 @@ class cMapEditor { void RemoveGameObjectFromTile(); + void AddGameObject(); + + void RemoveGameObject(); + cGameObject * CreateGameObject(); + + void MoveLayerUp(); + + void MoveLayerDown(); + + void RemoveLayer(); + + void RefreshLayersList(); }; }}} diff --git a/src/gaming/maphelper.hpp b/src/gaming/maphelper.hpp index 8def09014..a4a34eba6 100644 --- a/src/gaming/maphelper.hpp +++ b/src/gaming/maphelper.hpp @@ -15,11 +15,11 @@ class GObjFlags { }; enum EE_GAMEOBJECT_TYPE { - GAMEOBJECT_TYPE_BASE, - GAMEOBJECT_TYPE_SHAPE, - GAMEOBJECT_TYPE_SHAPEEX, - GAMEOBJECT_TYPE_SPRITE, - GAMEOBJECT_TYPE_USER = 10 + GAMEOBJECT_TYPE_BASE = 236430550u, //MakeHash( "Base" ), + GAMEOBJECT_TYPE_VIRTUAL = 4069800883u, //MakeHash( "Virtual" ), + GAMEOBJECT_TYPE_SHAPE = 3517332124u, //MakeHash( "Shape" ), + GAMEOBJECT_TYPE_SHAPEEX = 3708695628u, //MakeHash( "ShapeEx" ), + GAMEOBJECT_TYPE_SPRITE = 2088954976u //MakeHash( "Sprite" ) }; enum EE_LAYER_TYPE { @@ -30,7 +30,8 @@ enum EE_LAYER_TYPE { enum EE_MAP_FLAGS { MAP_FLAG_CLAMP_BODERS = ( 1 << 0 ), MAP_FLAG_CLIP_AREA = ( 1 << 1 ), - MAP_FLAG_DRAW_GRID = ( 1 << 2 ) + MAP_FLAG_DRAW_GRID = ( 1 << 2 ), + MAP_FLAG_DRAW_TILE_OVER = ( 1 << 3 ) }; }} diff --git a/src/graphics/cshader.cpp b/src/graphics/cshader.cpp index 0dabb67c6..0fe368881 100644 --- a/src/graphics/cshader.cpp +++ b/src/graphics/cshader.cpp @@ -41,17 +41,19 @@ cShader::cShader( const Uint32& Type, const char * Data, const Uint32& DataSize } cShader::cShader( const Uint32& Type, cPack * Pack, const std::string& Filename ) { + cPack::PointerData PData; + Init( Type ); if ( NULL != Pack && Pack->IsOpen() && -1 != Pack->Exists( Filename ) ) { - std::vector TempData; + Pack->ExtractFileToMemory( Filename, PData ); - Pack->ExtractFileToMemory( Filename, TempData ); - - SetSource( reinterpret_cast ( &TempData[0] ), (Uint32)TempData.size() ); + SetSource( reinterpret_cast ( PData.Data ), PData.DataSize ); } Compile(); + + eeSAFE_DELETE( PData.Data ); } cShader::cShader( const Uint32& Type, const char ** Data, const Uint32& NumLines ) { diff --git a/src/graphics/cshape.cpp b/src/graphics/cshape.cpp index 593a11cda..732818ef4 100644 --- a/src/graphics/cshape.cpp +++ b/src/graphics/cshape.cpp @@ -66,7 +66,7 @@ cShape::cShape( const Uint32& TexId, const eeRecti& SrcRect, const eeFloat& Dest CreateUnnamed(); } -cShape::cShape( const Uint32& TexId, const eeRecti& SrcRect, const eeFloat& DestWidth, const eeFloat& DestHeight, const eeFloat& OffsetX, const eeFloat& OffsetY, const std::string& Name ) : +cShape::cShape( const Uint32& TexId, const eeRecti& SrcRect, const eeFloat& DestWidth, const eeFloat& DestHeight, const Int32& OffsetX, const Int32& OffsetY, const std::string& Name ) : mPixels(NULL), mAlpha(NULL), mName( Name ), @@ -143,19 +143,19 @@ void cShape::DestHeight( const eeFloat& height ) { mDestHeight = height; } -const eeFloat& cShape::OffsetX() const { +const Int32& cShape::OffsetX() const { return mOffSetX; } -void cShape::OffsetX( const eeFloat& offsetx ) { +void cShape::OffsetX( const Int32& offsetx ) { mOffSetX = offsetx; } -const eeFloat& cShape::OffsetY() const { +const Int32& cShape::OffsetY() const { return mOffSetY; } -void cShape::OffsetY( const eeFloat& offsety ) { +void cShape::OffsetY( const Int32& offsety ) { mOffSetY = offsety; } diff --git a/src/graphics/cshape.hpp b/src/graphics/cshape.hpp index 041110afd..da67c8e33 100644 --- a/src/graphics/cshape.hpp +++ b/src/graphics/cshape.hpp @@ -17,7 +17,7 @@ class EE_API cShape { cShape( const Uint32& TexId, const eeRecti& SrcRect, const eeFloat& DestWidth, const eeFloat& DestHeight, const std::string& Name = "" ); - cShape( const Uint32& TexId, const eeRecti& SrcRect, const eeFloat& DestWidth, const eeFloat& DestHeight, const eeFloat& OffsetX, const eeFloat& OffsetY, const std::string& Name = "" ); + cShape( const Uint32& TexId, const eeRecti& SrcRect, const eeFloat& DestWidth, const eeFloat& DestHeight, const Int32& OffsetX, const Int32& OffsetY, const std::string& Name = "" ); ~cShape(); @@ -43,13 +43,13 @@ class EE_API cShape { void DestHeight( const eeFloat& height ); - const eeFloat& OffsetX() const; + const Int32& OffsetX() const; - void OffsetX( const eeFloat& offsetx ); + void OffsetX( const Int32& offsetx ); - const eeFloat& OffsetY() const; + const Int32& OffsetY() const; - void OffsetY( const eeFloat& offsety ); + void OffsetY( const Int32& offsety ); void Draw( const eeFloat& X, const eeFloat& Y, const eeColorA& Color = eeColorA(), const eeFloat& Angle = 0.f, const eeFloat& Scale = 1.f, const EE_PRE_BLEND_FUNC& Blend = ALPHA_NORMAL, const EE_RENDERTYPE& Effect = RN_NORMAL, const bool& ScaleRendered = true ); @@ -100,8 +100,8 @@ class EE_API cShape { eeRecti mSrcRect; eeFloat mDestWidth; eeFloat mDestHeight; - eeFloat mOffSetX; - eeFloat mOffSetY; + Int32 mOffSetX; + Int32 mOffSetY; void CreateUnnamed(); }; diff --git a/src/graphics/cshapegroup.cpp b/src/graphics/cshapegroup.cpp index cb33cacb1..8c5f41099 100644 --- a/src/graphics/cshapegroup.cpp +++ b/src/graphics/cshapegroup.cpp @@ -20,6 +20,14 @@ void cShapeGroup::Name( const std::string& name ) { mId = MakeHash( mName ); } +const std::string& cShapeGroup::Path() const { + return mPath; +} + +void cShapeGroup::Path( const std::string& path ) { + mPath = path; +} + const Uint32& cShapeGroup::Id() const { return mId; } diff --git a/src/graphics/cshapegroup.hpp b/src/graphics/cshapegroup.hpp index 90945dfd5..46dfa256b 100644 --- a/src/graphics/cshapegroup.hpp +++ b/src/graphics/cshapegroup.hpp @@ -28,12 +28,17 @@ class EE_API cShapeGroup : public tResourceManager { void Name( const std::string& name ); + const std::string& Path() const; + + void Path( const std::string& path ); + const Uint32& Id() const; Uint32 Count(); protected: std::string mName; Uint32 mId; + std::string mPath; }; }} diff --git a/src/graphics/cshapegroupmanager.cpp b/src/graphics/cshapegroupmanager.cpp index 36c30119e..3e0823abc 100644 --- a/src/graphics/cshapegroupmanager.cpp +++ b/src/graphics/cshapegroupmanager.cpp @@ -45,6 +45,27 @@ void cShapeGroupManager::PrintResources() { (*it)->PrintNames(); } +std::vector cShapeGroupManager::GetShapesByPatternId( const Uint32& ShapeId, const std::string& extension, cShapeGroup * SearchInShapeGroup ) { + cShape * tShape = NULL; + std::string tName; + + if ( NULL == SearchInShapeGroup ) + tShape = GetShapeById( ShapeId ); + else + tShape = SearchInShapeGroup->GetById( ShapeId ); + + if ( NULL != tShape ) { + if ( extension.size() ) + tName = RemoveNumbersAtEnd( FileRemoveExtension( tShape->Name() ) ) + extension; + else + tName = tShape->Name(); + + return GetShapesByPattern( RemoveNumbersAtEnd( tShape->Name() ), "", SearchInShapeGroup ); + } + + return std::vector(); +} + std::vector cShapeGroupManager::GetShapesByPattern( const std::string& name, const std::string& extension, cShapeGroup * SearchInShapeGroup ) { std::vector Shapes; std::string search; diff --git a/src/graphics/cshapegroupmanager.hpp b/src/graphics/cshapegroupmanager.hpp index c8d46f6e0..b531e2d66 100644 --- a/src/graphics/cshapegroupmanager.hpp +++ b/src/graphics/cshapegroupmanager.hpp @@ -26,6 +26,8 @@ class EE_API cShapeGroupManager : public tResourceManager, public t */ std::vector GetShapesByPattern( const std::string& name, const std::string& extension = "", cShapeGroup * SearchInShapeGroup = NULL ); + std::vector GetShapesByPatternId( const Uint32& ShapeId, const std::string& extension = "", cShapeGroup * SearchInShapeGroup = NULL ); + void PrintResources(); }; diff --git a/src/graphics/csprite.cpp b/src/graphics/csprite.cpp index b8098e6ce..8b256724e 100755 --- a/src/graphics/csprite.cpp +++ b/src/graphics/csprite.cpp @@ -355,6 +355,18 @@ bool cSprite::AddFrames( const std::vector Shapes ) { return false; } +bool cSprite::AddFramesByPatternId( const Uint32& ShapeId, const std::string& extension, cShapeGroup * SearchInShapeGroup ) { + std::vector Shapes = cShapeGroupManager::instance()->GetShapesByPatternId( ShapeId, extension, SearchInShapeGroup ); + + if ( Shapes.size() ) { + AddFrames( Shapes ); + + return true; + } + + return false; +} + bool cSprite::AddFramesByPattern( const std::string& name, const std::string& extension, cShapeGroup * SearchInShapeGroup ) { std::vector Shapes = cShapeGroupManager::instance()->GetShapesByPattern( name, extension, SearchInShapeGroup ); @@ -405,7 +417,7 @@ eeUint cSprite::AddFrame(const Uint32& TexId, const eeFloat& DestWidth, const ee return 0; } -bool cSprite::AddSubFrame(const Uint32& TexId, const eeUint& NumFrame, const eeUint& NumSubFrame, const eeFloat& DestWidth, const eeFloat& DestHeight, const eeFloat& offSetX, const eeFloat& offSetY, const eeRecti& TexSector) { +bool cSprite::AddSubFrame(const Uint32& TexId, const eeUint& NumFrame, const eeUint& NumSubFrame, const eeFloat& DestWidth, const eeFloat& DestHeight, const Int32& offSetX, const Int32& offSetY, const eeRecti& TexSector) { if ( !cTextureFactory::instance()->TextureIdExists( TexId ) ) return false; @@ -580,39 +592,39 @@ eeUint cSprite::GetSubFrame( const eeUint& SubFrame ) { return SFN; } -eeFloat cSprite::OffSetX() { +Int32 cSprite::OffSetX() { cShape* S = GetCurrentShape(); if ( S != NULL ) return S->OffsetX(); - return 0.0f; + return 0; } -void cSprite::OffSetX( const eeFloat& offsetx ) { +void cSprite::OffSetX( const Int32& offsetx ) { cShape* S = GetCurrentShape(); if ( S != NULL ) S->OffsetX( offsetx ); } -eeFloat cSprite::OffSetY() { +Int32 cSprite::OffSetY() { cShape* S = GetCurrentShape(); if ( S != NULL ) return S->OffsetY(); - return 0.0f; + return 0; } -void cSprite::OffSetY( const eeFloat& offsety ) { +void cSprite::OffSetY( const Int32& offsety ) { cShape* S = GetCurrentShape(); if ( S != NULL ) S->OffsetY( offsety ); } -void cSprite::OffSet( const eeVector2f& offset ) { +void cSprite::OffSet( const eeVector2i& offset ) { cShape* S = GetCurrentShape(); if ( S != NULL ) { diff --git a/src/graphics/csprite.hpp b/src/graphics/csprite.hpp index 35c90cdb8..54db113ad 100755 --- a/src/graphics/csprite.hpp +++ b/src/graphics/csprite.hpp @@ -222,6 +222,8 @@ class EE_API cSprite { /** @see cShapeGroupManager::GetShapesByPattern */ bool AddFramesByPattern( const std::string& name, const std::string& extension = "", cShapeGroup * SearchInShapeGroup = NULL ); + bool AddFramesByPatternId( const Uint32& ShapeId, const std::string& extension, cShapeGroup * SearchInShapeGroup ); + /** Add a frame on an specific subframe to the sprite * @param TexId The internal Texture Id * @param NumFrame The Frame Number @@ -233,7 +235,7 @@ class EE_API cSprite { * @param TexSector The texture sector to be rendered ( default all the texture ) * @return True if success */ - bool AddSubFrame( const Uint32& TexId, const eeUint& NumFrame, const eeUint& NumSubFrame, const eeFloat& DestWidth = 0, const eeFloat& DestHeight = 0, const eeFloat& offSetX = 0, const eeFloat& offSetY = 0, const eeRecti& TexSector = eeRecti(0,0,0,0) ); + bool AddSubFrame( const Uint32& TexId, const eeUint& NumFrame, const eeUint& NumSubFrame, const eeFloat& DestWidth = 0, const eeFloat& DestHeight = 0, const Int32& offSetX = 0, const Int32& offSetY = 0, const eeRecti& TexSector = eeRecti(0,0,0,0) ); /** Add a frame on an specific subframe to the sprite * @param Shape The Shape used in the frame @@ -280,19 +282,19 @@ class EE_API cSprite { eeQuad2f GetQuad(); /** @return The OffSetX of the current frame */ - eeFloat OffSetX(); + Int32 OffSetX(); /** Set the OffSetX of the current frame */ - void OffSetX( const eeFloat& offsetx ); + void OffSetX( const Int32& offsetx ); /** @return The OffSetY of the current frame */ - eeFloat OffSetY(); + Int32 OffSetY(); /** Set the OffSetY of the current frame */ - void OffSetY( const eeFloat& offsety ); + void OffSetY( const Int32& offsety ); /** Set the OffSet of the current frame */ - void OffSet( const eeVector2f& offset ); + void OffSet( const eeVector2i& offset ); /** Reverse the animation from last frame to first mFrames. */ void ReverseAnim( const bool& Reverse ); diff --git a/src/graphics/ctexturefont.cpp b/src/graphics/ctexturefont.cpp index be1481545..352e0e30a 100755 --- a/src/graphics/ctexturefont.cpp +++ b/src/graphics/ctexturefont.cpp @@ -137,12 +137,15 @@ bool cTextureFont::Load( const Uint32& TexId, const std::string& CoordinatesDatP } bool cTextureFont::LoadFromPack( const Uint32& TexId, cPack* Pack, const std::string& FilePackPath, const bool& VerticalDraw ) { - std::vector TmpData; + bool Ret = false; + cPack::PointerData PData; - if ( Pack->IsOpen() && Pack->ExtractFileToMemory( FilePackPath, TmpData ) ) - return LoadFromMemory( TexId, reinterpret_cast (&TmpData[0]), (Uint32)TmpData.size(), VerticalDraw ); + if ( Pack->IsOpen() && Pack->ExtractFileToMemory( FilePackPath, PData ) ) + Ret = LoadFromMemory( TexId, reinterpret_cast ( PData.Data ), PData.DataSize, VerticalDraw ); - return false; + eeSAFE_DELETE( PData.Data ); + + return Ret; } bool cTextureFont::LoadFromMemory( const Uint32& TexId, const Uint8* CoordData, const Uint32& CoordDataSize, const bool& VerticalDraw ) { diff --git a/src/graphics/ctexturegrouploader.cpp b/src/graphics/ctexturegrouploader.cpp index 23bc005ef..7099be195 100644 --- a/src/graphics/ctexturegrouploader.cpp +++ b/src/graphics/ctexturegrouploader.cpp @@ -113,11 +113,13 @@ void cTextureGroupLoader::LoadFromPack( cPack * Pack, const std::string& FilePac if ( NULL != Pack && Pack->IsOpen() && -1 != Pack->Exists( FilePackPath ) ) { mPack = Pack; - std::vector TempData; + cPack::PointerData PData; - Pack->ExtractFileToMemory( FilePackPath, TempData ); + Pack->ExtractFileToMemory( FilePackPath, PData ); - LoadFromMemory( reinterpret_cast ( &TempData[0] ), (Uint32)TempData.size(), FilePackPath ); + LoadFromMemory( reinterpret_cast ( PData.Data ), PData.DataSize, FilePackPath ); + + eeSAFE_DELETE( PData.Data ); } } @@ -197,6 +199,11 @@ void cTextureGroupLoader::CreateShapes() { name = FileRemoveExtension( name ); mShapeGroup = eeNew( cShapeGroup, ( name ) ); + + std::string etgpath = FileRemoveExtension( path ) + ".etg"; + + mShapeGroup->Path( etgpath ); + cShapeGroupManager::instance()->Add( mShapeGroup ); } @@ -211,7 +218,7 @@ void cTextureGroupLoader::CreateShapes() { eeRecti tRect( tSh->X, tSh->Y, tSh->X + tSh->Width, tSh->Y + tSh->Height ); - cShape * tShape = eeNew( cShape, ( tTex->Id(), tRect, (eeFloat)tSh->DestWidth, (eeFloat)tSh->DestHeight, (eeFloat)tSh->OffsetX, (eeFloat)tSh->OffsetY, ShapeName ) ); + cShape * tShape = eeNew( cShape, ( tTex->Id(), tRect, (eeFloat)tSh->DestWidth, (eeFloat)tSh->DestHeight, tSh->OffsetX, tSh->OffsetY, ShapeName ) ); //if ( tSh->Flags & HDR_SHAPE_FLAG_FLIPED ) // Should rotate the shape, but.. shape rotation is not stored. diff --git a/src/graphics/ctextureloader.cpp b/src/graphics/ctextureloader.cpp index 0a383f47c..e3f92f1d1 100644 --- a/src/graphics/ctextureloader.cpp +++ b/src/graphics/ctextureloader.cpp @@ -172,14 +172,16 @@ void cTextureLoader::LoadFromPath() { } void cTextureLoader::LoadFromPack() { - std::vector TmpData; + cPack::PointerData PData; - if ( NULL != mPack && mPack->IsOpen() && mPack->ExtractFileToMemory( mFilepath, TmpData ) ) { - mImagePtr = reinterpret_cast (&TmpData[0]); - mSize = (Uint32)TmpData.size(); + if ( NULL != mPack && mPack->IsOpen() && mPack->ExtractFileToMemory( mFilepath, PData ) ) { + mImagePtr = PData.Data; + mSize = PData.DataSize; LoadFromMemory(); } + + eeSAFE_DELETE( PData.Data ); } void cTextureLoader::LoadFromMemory() { diff --git a/src/graphics/ctexturepackertex.hpp b/src/graphics/ctexturepackertex.hpp index 9058ae327..c72adc457 100644 --- a/src/graphics/ctexturepackertex.hpp +++ b/src/graphics/ctexturepackertex.hpp @@ -11,39 +11,55 @@ class cTexturePackerTex { void Place( Int32 x, Int32 y, bool flipped ); - inline const std::string& Name() const { return mName; } + inline const std::string& Name() const { return mName; } - inline const Int32& X() const { return mX; } + inline const Int32& X() const { return mX; } - inline const Int32& Y() const { return mY; } + inline const Int32& Y() const { return mY; } - inline const Int32& Channels() { return mChannels; } + inline const Int32& Channels() { return mChannels; } - inline void X( const Int32& x ) { mX = x; } + inline void X( const Int32& x ) { mX = x; } - inline void Y( const Int32& y ) { mY = y; } + inline void Y( const Int32& y ) { mY = y; } - inline const Int32& Width() const { return mWidth; } + inline const Int32& Width() const { return mWidth; } - inline const Int32& Height() const { return mHeight; } + inline const Int32& Height() const { return mHeight; } - inline void Width( const Int32& W ) { mWidth = W; } + inline void Width( const Int32& W ) { mWidth = W; } - inline void Height( const Int32& H ) { mHeight = H; } + inline void Height( const Int32& H ) { mHeight = H; } - inline const bool& LoadedInfo() const { return mLoadedInfo; } + inline const bool& LoadedInfo() const { return mLoadedInfo; } - inline const Int32& Area() const { return mArea; } + inline const Int32& Area() const { return mArea; } - inline const bool& Placed() const { return mPlaced; } + inline const bool& Placed() const { return mPlaced; } - inline const bool& Flipped() const { return mFlipped; } + inline const bool& Flipped() const { return mFlipped; } - inline const Int32& LongestEdge() const { return mLongestEdge; } + inline const Int32& LongestEdge() const { return mLongestEdge; } - inline const bool& Disabled() const { return mDisabled; } + inline const bool& Disabled() const { return mDisabled; } - inline void Disabled( const bool& d ) { mDisabled = d; } + inline void Disabled( const bool& d ) { mDisabled = d; } + + inline const Int32& DestWidth() const { return mDestWidth; } + + inline const Int32& DestHeight() const { return mDestHeight; } + + inline void DestWidth( const Int32& W ) { mDestWidth = W; } + + inline void DestHeight( const Int32& H ){ mDestHeight = H; } + + inline const Int32& OffsetX() const { return mOffsetX; } + + inline const Int32& OffsetY() const { return mOffsetY; } + + inline void OffsetX( const Int32& offx ){ mOffsetX = offx; } + + inline void OffsetY( const Int32& offy ){ mDestHeight = offy; } protected: std::string mName; Int32 mWidth; @@ -53,6 +69,10 @@ class cTexturePackerTex { Int32 mY; Int32 mLongestEdge; Int32 mArea; + Int32 mDestWidth; + Int32 mDestHeight; + Int32 mOffsetX; + Int32 mOffsetY; bool mFlipped; bool mPlaced; bool mLoadedInfo; diff --git a/src/graphics/cttffont.cpp b/src/graphics/cttffont.cpp index 7c6d70ae6..981f7a7e5 100755 --- a/src/graphics/cttffont.cpp +++ b/src/graphics/cttffont.cpp @@ -16,17 +16,18 @@ cTTFFont::~cTTFFont() { } bool cTTFFont::LoadFromPack( cPack* Pack, const std::string& FilePackPath, const eeUint& Size, EE_TTF_FONTSTYLE Style, const bool& VerticalDraw, const Uint16& NumCharsToGen, const eeColor& FontColor, const Uint8& OutlineSize, const eeColor& OutlineColor, const bool& AddPixelSeparator ) { - std::vector TmpData; + bool Ret = false; + cPack::PointerData PData; - if ( Pack->IsOpen() && Pack->ExtractFileToMemory( FilePackPath, TmpData ) ) { + if ( Pack->IsOpen() && Pack->ExtractFileToMemory( FilePackPath, PData ) ) { mFilepath = FilePackPath; - return LoadFromMemory( reinterpret_cast (&TmpData[0]), (eeUint)TmpData.size(), Size, Style, VerticalDraw, NumCharsToGen, FontColor, OutlineSize, OutlineColor, AddPixelSeparator ); + Ret = LoadFromMemory( PData.Data, PData.DataSize, Size, Style, VerticalDraw, NumCharsToGen, FontColor, OutlineSize, OutlineColor, AddPixelSeparator ); } - TmpData.clear(); + eeSAFE_DELETE( PData.Data ); - return false; + return Ret; } bool cTTFFont::LoadFromMemory( Uint8* TTFData, const eeUint& TTFDataSize, const eeUint& Size, EE_TTF_FONTSTYLE Style, const bool& VerticalDraw, const Uint16& NumCharsToGen, const eeColor& FontColor, const Uint8& OutlineSize, const eeColor& OutlineColor, const bool& AddPixelSeparator ) { diff --git a/src/system/cpack.hpp b/src/system/cpack.hpp index 660f67268..d2f478d02 100755 --- a/src/system/cpack.hpp +++ b/src/system/cpack.hpp @@ -9,6 +9,13 @@ namespace EE { namespace System { /** @brief Base class for al packing classes */ class EE_API cPack : protected cMutex { public: + class PointerData { + public: + PointerData() : Data( NULL ), DataSize( 0 ) {} + Uint8 * Data; + Uint32 DataSize; + }; + cPack(); virtual ~cPack(); @@ -51,7 +58,7 @@ class EE_API cPack : protected cMutex { virtual bool ExtractFileToMemory( const std::string& path, std::vector& data ) = 0; /** Extract a file to memory from the pack file */ - virtual bool ExtractFileToMemory( const std::string& path, Uint8** data, Uint32* dataSize ) = 0; + virtual bool ExtractFileToMemory( const std::string& path, PointerData& data ) = 0; /** Check if a file exists in the pack file and return the number of the file, otherwise return -1. */ virtual Int32 Exists( const std::string& path ) = 0; diff --git a/src/system/cpak.cpp b/src/system/cpak.cpp index 2b34b94a0..91c71a2ac 100755 --- a/src/system/cpak.cpp +++ b/src/system/cpak.cpp @@ -141,7 +141,7 @@ bool cPak::ExtractFileToMemory( const std::string& path, std::vector& dat return Ret; } -bool cPak::ExtractFileToMemory( const std::string& path, Uint8** data, Uint32* dataSize ) { +bool cPak::ExtractFileToMemory( const std::string& path, PointerData& data ) { Lock(); bool Ret = false; @@ -149,11 +149,11 @@ bool cPak::ExtractFileToMemory( const std::string& path, Uint8** data, Uint32* d Int32 Pos = Exists( path ); if ( Pos != -1 ) { - *dataSize = pakFiles[Pos].file_length; - *data = eeNew( Uint8, (*dataSize) ); + data.DataSize = pakFiles[Pos].file_length; + data.Data = eeNewArray( Uint8, ( data.DataSize ) ); myPak.fs.seekg( pakFiles[Pos].file_position, std::ios::beg ); - myPak.fs.read( reinterpret_cast ( *data ), pakFiles[Pos].file_length ); + myPak.fs.read( reinterpret_cast ( data.Data ), pakFiles[Pos].file_length ); Ret = true; } diff --git a/src/system/cpak.hpp b/src/system/cpak.hpp index aee9978b5..6f76feb41 100755 --- a/src/system/cpak.hpp +++ b/src/system/cpak.hpp @@ -51,7 +51,7 @@ class EE_API cPak : public cPack { bool ExtractFileToMemory( const std::string& path, std::vector& data ); /** Extract a file to memory from the pakFile */ - bool ExtractFileToMemory( const std::string& path, Uint8** data, Uint32* dataSize ); + bool ExtractFileToMemory( const std::string& path, PointerData& data ); /** Check if a file exists in the pakFile and return the number of the file, otherwise return -1. */ Int32 Exists( const std::string& path ); diff --git a/src/system/czip.cpp b/src/system/czip.cpp index fe704e355..08939c535 100644 --- a/src/system/czip.cpp +++ b/src/system/czip.cpp @@ -180,7 +180,7 @@ bool cZip::ExtractFileToMemory( const std::string& path, std::vector& dat return Ret; } -bool cZip::ExtractFileToMemory( const std::string& path, Uint8** data, Uint32* dataSize ) { +bool cZip::ExtractFileToMemory( const std::string& path, PointerData& data ) { Lock(); bool Ret = false; @@ -196,10 +196,10 @@ bool cZip::ExtractFileToMemory( const std::string& path, Uint8** data, Uint32* d struct zip_file * zf = zip_fopen_index( mZip, zs.index, 0 ); if ( NULL != zf ) { - *dataSize = (Uint32)zs.size; - *data = eeNew( Uint8, (*dataSize) ); + data.DataSize = (Uint32)zs.size; + data.Data = eeNewArray( Uint8, ( data.DataSize ) ); - Result = (Int32)zip_fread( zf, reinterpret_cast (&data[0]), (*dataSize) ); + Result = (Int32)zip_fread( zf, (void*)data.Data, data.DataSize ); zip_fclose(zf); diff --git a/src/system/czip.hpp b/src/system/czip.hpp index bb069d2d8..a7d40e76f 100644 --- a/src/system/czip.hpp +++ b/src/system/czip.hpp @@ -50,7 +50,7 @@ class EE_API cZip : public cPack { bool ExtractFileToMemory( const std::string& path, std::vector& data ); /** Extract a file to memory from the pakFile */ - bool ExtractFileToMemory( const std::string& path, Uint8** data, Uint32* dataSize ); + bool ExtractFileToMemory( const std::string& path, PointerData& data ); /** Check if a file exists in the pack file and return the number of the file, otherwise return -1. */ Int32 Exists( const std::string& path ); diff --git a/src/test/eetest.cpp b/src/test/eetest.cpp index a42641494..9789d1a93 100644 --- a/src/test/eetest.cpp +++ b/src/test/eetest.cpp @@ -66,20 +66,6 @@ void cEETest::Init() { run = ( mWindow->Created() && PAK.IsOpen() ); if ( run ) { - #ifdef EE_DEBUG - std::cout << "Size of Callback0: " << sizeof( cb::Callback0 ) << std::endl; - std::cout << "Size of cWaypoints: " << sizeof( cWaypoints ) << std::endl; - std::cout << "Size of UIEventsMap: " << sizeof( std::map< Uint32, std::map > ) << std::endl; - std::cout << "Size of eePolygon2f: " << sizeof(eePolygon2f) << std::endl; - std::cout << "Size of cTexture: " << sizeof(cTexture) << std::endl; - std::cout << "Size of cShape: " << sizeof(Graphics::cShape) << std::endl; - std::cout << "Size of cSprite: " << sizeof(cSprite) << std::endl; - std::cout << "Size of cUIControl: " << sizeof(cUIControl) << std::endl; - std::cout << "Size of cUIControlAnim: " << sizeof(cUIControlAnim) << std::endl; - std::cout << "Size of cUITextBox: " << sizeof(cUITextBox) << std::endl; - std::cout << "Size of cUIComplexControl: " << sizeof(cUIComplexControl) << std::endl; - #endif - SetScreen( 0 ); mWindow->Caption( "EE++ Test Application" ); @@ -880,7 +866,7 @@ void cEETest::LoadTextures() { TLayer->AddGameObject( eeNew( cGameObjectShape, ( GObjFlags::GAMEOBJECT_STATIC, Tiles[ Rand.RandRange( 0, 5 ) ] ) - ), eeVector2u( x, y ) + ), eeVector2i( x, y ) ); } }*/ diff --git a/src/ui/cuidropdownlist.cpp b/src/ui/cuidropdownlist.cpp index afc3743e1..b3380ab6a 100644 --- a/src/ui/cuidropdownlist.cpp +++ b/src/ui/cuidropdownlist.cpp @@ -86,16 +86,19 @@ void cUIDropDownList::ShowListBox() { mListBox->Parent()->ScreenToControl( Pos ); mListBox->Pos( Pos ); - eeRecti tPadding = mListBox->PaddingContainer(); + if ( mListBox->Count() ) { + eeRecti tPadding = mListBox->PaddingContainer(); - if ( mMinNumVisibleItems < mListBox->Count() ) - mListBox->Size( mSize.Width(), (Int32)( mMinNumVisibleItems * mSize.Height() ) + tPadding.Top ); - else - mListBox->Size( mSize.Width(), (Int32)( mListBox->Count() * mSize.Height() ) + tPadding.Top ); + if ( mMinNumVisibleItems < mListBox->Count() ) + mListBox->Size( mSize.Width(), (Int32)( mMinNumVisibleItems * mListBox->RowHeight() ) + tPadding.Top + tPadding.Bottom ); + else { + mListBox->Size( mSize.Width(), (Int32)( mListBox->Count() * mListBox->RowHeight() ) + tPadding.Top + tPadding.Bottom ); + } - Show(); + Show(); - mListBox->SetFocus(); + mListBox->SetFocus(); + } } else { Hide(); } diff --git a/src/ui/cuiwindow.cpp b/src/ui/cuiwindow.cpp index e59516802..8d83feb1f 100644 --- a/src/ui/cuiwindow.cpp +++ b/src/ui/cuiwindow.cpp @@ -584,6 +584,7 @@ void cUIWindow::Draw() { P.DrawTriangle( eeTriangle2f( eeVector2f( ShadowPos.x, ShadowPos.y + mSize.Height() ), eeVector2f( ShadowPos.x - SSize, ShadowPos.y + mSize.Height() ), eeVector2f( ShadowPos.x, ShadowPos.y + mSize.Height() + SSize ) ), BeginC, EndC, EndC ); + P.ForceDraw( true ); P.DrawBatch(); } } diff --git a/src/utils/utils.cpp b/src/utils/utils.cpp index 160cc455d..f4d9c1126 100755 --- a/src/utils/utils.cpp +++ b/src/utils/utils.cpp @@ -630,10 +630,6 @@ Uint32 MakeHash( const std::string& str ) { return MakeHash( reinterpret_cast( &str[0] ) ); } -Uint32 MakeHash( const EE::String& str ) { - return MakeHash( reinterpret_cast( str.data() ) ); -} - Uint32 MakeHash( const Uint8 * str ) { //! This is djb2 + sdbm mixed. This hash doesn't exists, but worked. //! Since i found this pretty funny because i used this hash in a lot of projects and never found a collision, i'll let it stay here. @@ -820,7 +816,7 @@ std::string RemoveLastFolderFromPath( std::string path ) { std::size_t pos = path.find_last_of( GetOSlash() ); - if ( std::string::npos != pos ) { + if ( std::string::npos != pos ) { std::string sstr; std::size_t pos2 = path.find_first_of( GetOSlash() ); @@ -830,15 +826,15 @@ std::string RemoveLastFolderFromPath( std::string path ) { if ( pos == pos2 ) { sstr = path.substr(0,pos2+1); } - } - - if ( sstr.size() ) { - DirPathAddSlashAtEnd( sstr ); - - return sstr; } - } - + + if ( sstr.size() ) { + DirPathAddSlashAtEnd( sstr ); + + return sstr; + } + } + DirPathAddSlashAtEnd( path ); return path; diff --git a/src/utils/utils.hpp b/src/utils/utils.hpp index a919b6d08..73c9602fe 100755 --- a/src/utils/utils.hpp +++ b/src/utils/utils.hpp @@ -43,9 +43,6 @@ namespace EE { namespace Utils { /** @return string hash */ Uint32 EE_API MakeHash( const Uint8 * str ); - /** @return string hash */ - Uint32 EE_API MakeHash( const EE::String& str ); - /** Copy a file to memory * @param path The file path * @param data The vector to allocate the file in memory