add more basic blocks

FactoryCraft/BasicBlocks.cpp

@@ -52,62 +52,170 @@ float BasicBlock::getEffectPercentage()
     return 1 - hp / maxHP;
 }
 
-
-DirtBlockType::DirtBlockType()
-    : BlockType( ID )
+BasicBlockType::BasicBlockType( int id, const char* texturPath )
+    : BlockType( id ),
+    texturPath( texturPath ),
+    transparent( 0 ),
+    passable( 0 ),
+    maxHp( 100.f ),
+    hardness( 1.f ),
+    zTool( 0 ),
+    speedModifier( 1.f ),
+    interactable( 1 )
 {}
 
-void DirtBlockType::loadSuperBlock( Block* zBlock, Framework::StreamReader* zReader )
-{
-    BlockType::loadSuperBlock( zBlock, zReader );
-}
-
-Block* DirtBlockType::createBlock( Framework::Vec3<int> position )
+Block* BasicBlockType::createBlock( Framework::Vec3<int> position )
 {
-    Block* b = new BasicBlock( DirtBlockType::INSTANCE, "blocks.ltdb/dirt.png", 0, position, 0 ); // TODO: add efective tool
+    Block* b = new BasicBlock( this, texturPath, 0, position, 0 ); // TODO: add efective tool
     initializeSuperBlock( b );
     return b;
 }
 
-void DirtBlockType::initializeSuperBlock( Block* zBlock )
+void BasicBlockType::initializeSuperBlock( Block* zBlock )
 {
     BasicBlock* block = dynamic_cast<BasicBlock*>(zBlock);
     if( !block )
-        throw "DirtBlockType::createSuperBlock was called with a block witch is not an instance of BasicBlock";
-    block->transparent = 0;
-    block->passable = 0;
-    block->hp = 100;
-    block->maxHP = 100;
-    block->hardness = 1;
-    block->zTool = 0;
-    block->speedModifier = 1;
+        throw "BasicBlockType::initializeSuperBlock was called with a block witch is not an instance of BasicBlock";
+    block->transparent = transparent;
+    block->passable = passable;
+    block->hp = maxHp;
+    block->maxHP = maxHp;
+    block->hardness = hardness;
+    block->zTool = zTool;
+    block->speedModifier = speedModifier;
 }
 
-bool DirtBlockType::needsInstance() const
+bool BasicBlockType::needsInstance() const
 {
     return 1;
 }
 
 
+DirtBlockType::DirtBlockType()
+    : BasicBlockType( ID, "blocks.ltdb/dirt.png" )
+{}
+
+
 DirtBlockItemType::DirtBlockItemType()
-    : BasicBlockItemType( ID )
+    : BasicBlockItemType( ID, "Dirt", "blocks.ltdb/dirt.png" )
 {}
 
-Item* DirtBlockItemType::createItem() const
+
+StoneBlockType::StoneBlockType()
+    : BasicBlockType( ID, "blocks.ltdb/stone.png" )
 {
-    BasicBlockItem* item = new BasicBlockItem( (ItemType*)this, "Dirt" );
-    return item;
+    hardness = 2.f;
 }
 
-Framework::Model3DTextur* DirtBlockItemType::getItemTextur() const
+
+StoneBlockItemType::StoneBlockItemType()
+    : BasicBlockItemType( ID, "Stone", "blocks.ltdb/stone.png" )
+{}
+
+
+SandBlockType::SandBlockType()
+    : BasicBlockType( ID, "blocks.ltdb/sand.png" )
 {
-    Model3DTextur* textur = new Model3DTextur();
-    Textur* tex = currentGame->zScreen()->zGraphicsApi()->createOrGetTextur( "blocks.ltdb/dirt.png", 0 );
-    textur->setPolygonTextur( 0, dynamic_cast<Textur*>(tex->getThis()) );
-    textur->setPolygonTextur( 1, dynamic_cast<Textur*>(tex->getThis()) );
-    textur->setPolygonTextur( 2, dynamic_cast<Textur*>(tex->getThis()) );
-    textur->setPolygonTextur( 3, dynamic_cast<Textur*>(tex->getThis()) );
-    textur->setPolygonTextur( 4, dynamic_cast<Textur*>(tex->getThis()) );
-    textur->setPolygonTextur( 5, tex );
-    return textur;
-}
+    hardness = 0.5f;
+}
+
+
+SandBlockItemType::SandBlockItemType()
+    : BasicBlockItemType( ID, "Sand", "blocks.ltdb/sand.png" )
+{}
+
+
+OakBlockType::OakBlockType()
+    : BasicBlockType( ID, "blocks.ltdb/oak.png" )
+{
+    hardness = 1.5f;
+}
+
+
+OakBlockItemType::OakBlockItemType()
+    : BasicBlockItemType( ID, "Oak Wood", "blocks.ltdb/oak.png" )
+{}
+
+
+LeavesBlockType::LeavesBlockType()
+    : BasicBlockType( ID, "blocks.ltdb/leaves.png" )
+{
+    hardness = 0.1f;
+}
+
+
+LeavesBlockItemType::LeavesBlockItemType()
+    : BasicBlockItemType( ID, "Leaves", "blocks.ltdb/leaves.png" )
+{}
+
+
+GravelBlockType::GravelBlockType()
+    : BasicBlockType( ID, "blocks.ltdb/gravel.png" )
+{
+    hardness = 0.75f;
+}
+
+
+GravelBlockItemType::GravelBlockItemType()
+    : BasicBlockItemType( ID, "Gravel", "blocks.ltdb/gravel.png" )
+{}
+
+
+GraniteBlockType::GraniteBlockType()
+    : BasicBlockType( ID, "blocks.ltdb/granite.png" )
+{
+    hardness = 3.f;
+}
+
+
+GraniteBlockItemType::GraniteBlockItemType()
+    : BasicBlockItemType( ID, "Granite", "blocks.ltdb/granite.png" )
+{}
+
+
+CobbleBlockType::CobbleBlockType()
+    : BasicBlockType( ID, "blocks.ltdb/cobble.png" )
+{
+    hardness = 1.f;
+}
+
+
+CobbleBlockItemType::CobbleBlockItemType()
+    : BasicBlockItemType( ID, "Cobble", "blocks.ltdb/cobble.png" )
+{}
+
+
+BirchBlockType::BirchBlockType()
+    : BasicBlockType( ID, "blocks.ltdb/birch.png" )
+{
+    hardness = 1.5f;
+}
+
+
+BirchBlockItemType::BirchBlockItemType()
+    : BasicBlockItemType( ID, "Birch Wood", "blocks.ltdb/birch.png" )
+{}
+
+
+BeechBlockType::BeechBlockType()
+    : BasicBlockType( ID, "blocks.ltdb/beech.png" )
+{
+    hardness = 1.5f;
+}
+
+
+BeechBlockItemType::BeechBlockItemType()
+    : BasicBlockItemType( ID, "Beech Wood", "blocks.ltdb/beech.png" )
+{}
+
+
+BasaltBlockType::BasaltBlockType()
+    : BasicBlockType( ID, "blocks.ltdb/basalt.png" )
+{
+    hardness = 2.f;
+}
+
+
+BasaltBlockItemType::BasaltBlockItemType()
+    : BasicBlockItemType( ID, "Basalt", "blocks.ltdb/basalt.png" )
+{}

FactoryCraft/BasicBlocks.h

@@ -21,22 +21,38 @@ public:
     virtual Textur* zEffectTextur() override;
     virtual float getEffectPercentage() override;
 
-    friend DirtBlockType;
+    friend BasicBlockType;
 };
 
-class DirtBlockType : public BlockType
+class BasicBlockType : public BlockType
 {
-    REGISTRABLE( DirtBlockType )
+private:
+    const char* texturPath;
 
 protected:
-    DirtBlockType();
-    virtual void loadSuperBlock( Block* zBlock, Framework::StreamReader* zReader ) override;
+    bool transparent;
+    bool passable;
+    float maxHp;
+    float hardness;
+    ItemType* zTool;
+    float speedModifier;
+    bool interactable;
 
+    BasicBlockType( int id, const char* texturPath );
 public:
     virtual Block* createBlock( Framework::Vec3<int> position ) override;
     virtual void initializeSuperBlock( Block* zBlock )  override;
     virtual bool needsInstance() const override;
 };
+
+// Dirt
+class DirtBlockType : public BasicBlockType
+{
+    REGISTRABLE( DirtBlockType )
+
+protected:
+    DirtBlockType();
+};
 REGISTER( DirtBlockType, BlockType )
 
 class DirtBlockItemType : public BasicBlockItemType
@@ -45,9 +61,196 @@ class DirtBlockItemType : public BasicBlockItemType
 
 protected:
     DirtBlockItemType();
-
-public:
-    virtual Item* createItem() const override;
-    virtual Framework::Model3DTextur* getItemTextur() const override;
 };
 REGISTER( DirtBlockItemType, ItemType )
+
+
+// Stone
+class StoneBlockType : public BasicBlockType
+{
+    REGISTRABLE( StoneBlockType )
+
+protected:
+    StoneBlockType();
+};
+REGISTER( StoneBlockType, BlockType )
+
+class StoneBlockItemType : public BasicBlockItemType
+{
+    REGISTRABLE( StoneBlockItemType )
+
+protected:
+    StoneBlockItemType();
+};
+REGISTER( StoneBlockItemType, ItemType )
+
+// Sand
+class SandBlockType : public BasicBlockType
+{
+    REGISTRABLE( SandBlockType )
+
+protected:
+    SandBlockType();
+};
+REGISTER( SandBlockType, BlockType )
+
+class SandBlockItemType : public BasicBlockItemType
+{
+    REGISTRABLE( SandBlockItemType )
+
+protected:
+    SandBlockItemType();
+};
+REGISTER( SandBlockItemType, ItemType )
+
+// Oak Wood
+class OakBlockType : public BasicBlockType
+{
+    REGISTRABLE( OakBlockType )
+
+protected:
+    OakBlockType();
+};
+REGISTER( OakBlockType, BlockType )
+
+class OakBlockItemType : public BasicBlockItemType
+{
+    REGISTRABLE( OakBlockItemType )
+
+protected:
+    OakBlockItemType();
+};
+REGISTER( OakBlockItemType, ItemType )
+
+// Leaves
+class LeavesBlockType : public BasicBlockType
+{
+    REGISTRABLE( LeavesBlockType )
+
+protected:
+    LeavesBlockType();
+};
+REGISTER( LeavesBlockType, BlockType )
+
+class LeavesBlockItemType : public BasicBlockItemType
+{
+    REGISTRABLE( LeavesBlockItemType )
+
+protected:
+    LeavesBlockItemType();
+};
+REGISTER( LeavesBlockItemType, ItemType )
+
+// Gravel
+class GravelBlockType : public BasicBlockType
+{
+    REGISTRABLE( GravelBlockType )
+
+protected:
+    GravelBlockType();
+};
+REGISTER( GravelBlockType, BlockType )
+
+class GravelBlockItemType : public BasicBlockItemType
+{
+    REGISTRABLE( GravelBlockItemType )
+
+protected:
+    GravelBlockItemType();
+};
+REGISTER( GravelBlockItemType, ItemType )
+
+// Granite
+class GraniteBlockType : public BasicBlockType
+{
+    REGISTRABLE( GraniteBlockType )
+
+protected:
+    GraniteBlockType();
+};
+REGISTER( GraniteBlockType, BlockType )
+
+class GraniteBlockItemType : public BasicBlockItemType
+{
+    REGISTRABLE( GraniteBlockItemType )
+
+protected:
+    GraniteBlockItemType();
+};
+REGISTER( GraniteBlockItemType, ItemType )
+
+// Cobble
+class CobbleBlockType : public BasicBlockType
+{
+    REGISTRABLE( CobbleBlockType )
+
+protected:
+    CobbleBlockType();
+};
+REGISTER( CobbleBlockType, BlockType )
+
+class CobbleBlockItemType : public BasicBlockItemType
+{
+    REGISTRABLE( CobbleBlockItemType )
+
+protected:
+    CobbleBlockItemType();
+};
+REGISTER( CobbleBlockItemType, ItemType )
+
+// Birch Wood
+class BirchBlockType : public BasicBlockType
+{
+    REGISTRABLE( BirchBlockType )
+
+protected:
+    BirchBlockType();
+};
+REGISTER( BirchBlockType, BlockType )
+
+class BirchBlockItemType : public BasicBlockItemType
+{
+    REGISTRABLE( BirchBlockItemType )
+
+protected:
+    BirchBlockItemType();
+};
+REGISTER( BirchBlockItemType, ItemType )
+
+// Beech Wood
+class BeechBlockType : public BasicBlockType
+{
+    REGISTRABLE( BeechBlockType )
+
+protected:
+    BeechBlockType();
+};
+REGISTER( BeechBlockType, BlockType )
+
+class BeechBlockItemType : public BasicBlockItemType
+{
+    REGISTRABLE( BeechBlockItemType )
+
+protected:
+    BeechBlockItemType();
+};
+REGISTER( BeechBlockItemType, ItemType )
+
+// Basalt
+class BasaltBlockType : public BasicBlockType
+{
+    REGISTRABLE( BasaltBlockType )
+
+protected:
+    BasaltBlockType();
+};
+REGISTER( BasaltBlockType, BlockType )
+
+class BasaltBlockItemType : public BasicBlockItemType
+{
+    REGISTRABLE( BasaltBlockItemType )
+
+protected:
+    BasaltBlockItemType();
+};
+REGISTER( BasaltBlockItemType, ItemType )

FactoryCraft/Block.cpp

@@ -58,8 +58,10 @@ BasicBlockItem::BasicBlockItem( const ItemType* zType, const char* name )
 }
 
 
-BasicBlockItemType::BasicBlockItemType( int id )
-    : ItemType( id )
+BasicBlockItemType::BasicBlockItemType( int id, const char* name, const char* texturPath )
+    : ItemType( id ),
+    name( name ),
+    texturPath( texturPath )
 {}
 
 void BasicBlockItemType::loadSuperItem( Item* zItem, Framework::StreamReader* zReader ) const
@@ -86,4 +88,22 @@ Framework::Model3DData* BasicBlockItemType::getItemModel() const
 Framework::Model3DTextur* BasicBlockItemType::getItemTextur() const
 {
     return 0;
+}
+
+Item* BasicBlockItemType::createItem() const
+{
+    return new BasicBlockItem( this, name );
+}
+
+Framework::Model3DTextur* BasicBlockItemType::getItemTextur() const
+{
+    Model3DTextur* textur = new Model3DTextur();
+    Textur* tex = currentGame->zScreen()->zGraphicsApi()->createOrGetTextur( texturPath, 0 );
+    textur->setPolygonTextur( 0, dynamic_cast<Textur*>(tex->getThis()) );
+    textur->setPolygonTextur( 1, dynamic_cast<Textur*>(tex->getThis()) );
+    textur->setPolygonTextur( 2, dynamic_cast<Textur*>(tex->getThis()) );
+    textur->setPolygonTextur( 3, dynamic_cast<Textur*>(tex->getThis()) );
+    textur->setPolygonTextur( 4, dynamic_cast<Textur*>(tex->getThis()) );
+    textur->setPolygonTextur( 5, tex );
+    return textur;
 }

FactoryCraft/Block.h

@@ -60,9 +60,18 @@ public:
 
 class BasicBlockItemType : public ItemType
 {
+private:
+    const char* name;
+    const char* texturPath;
+
 protected:
-    BasicBlockItemType( int id );
+    BasicBlockItemType( int id, const char* name, const char* texturPath );
     virtual void loadSuperItem( Item* zItem, Framework::StreamReader* zReader ) const override;
+
+public:
     virtual Framework::Model3DData* getItemModel() const override;
     virtual Framework::Model3DTextur* getItemTextur() const override;
+
+    virtual Item* createItem() const override;
+    virtual Framework::Model3DTextur* getItemTextur() const override;
 };