add more basic block types

FactoryCraft/BasicBlock.cpp

@@ -14,23 +14,19 @@ void BasicBlock::onPostTick()
 {}
 
 
-DirtBlockType::DirtBlockType()
-    : BlockType( ID, 0 )
-{
-    defaultBlock = createBlockAt( { 0, 0, 0 }, 0 );
-}
-
-void DirtBlockType::loadSuperBlock( Block* zBlock, Framework::StreamReader* zReader ) const
-{
-    BlockType::loadSuperBlock( zBlock, zReader );
-}
-
-void DirtBlockType::saveSuperBlock( Block* zBlock, Framework::StreamWriter* zWriter ) const
-{
-    BlockType::saveSuperBlock( zBlock, zWriter );
-}
+BasicBlockType::BasicBlockType( int typeId, int itemTypeId )
+    : BlockType( typeId, 0 ),
+    itemType( itemTypeId ),
+    transparent( 0 ),
+    passable( 0 ),
+    maxHp( 100.f ),
+    hardness( 1.f ),
+    zTool( 0 ),
+    speedModifier( 1.f ),
+    interactable( 1 )
+{}
 
-void DirtBlockType::createSuperBlock( Block* zBlock, Item* zItem ) const
+void BasicBlockType::createSuperBlock( Block* zBlock, Item* zItem ) const
 {
     if( zItem )
         BlockType::createSuperBlock( zBlock, zItem );
@@ -39,30 +35,32 @@ void DirtBlockType::createSuperBlock( Block* zBlock, Item* zItem ) const
         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;
-        block->interactable = 1;
+        block->transparent = transparent;
+        block->passable = passable;
+        block->hp = maxHp;
+        block->maxHP = maxHp;
+        block->hardness = hardness;
+        block->zTool = zTool;
+        block->speedModifier = speedModifier;
+        block->interactable = interactable;
     }
 }
 
-void DirtBlockType::createSuperItem( Block* zBlock, Item* zItem ) const
+Block* BasicBlockType::createBlock( Framework::Vec3<int> position ) const
 {
-    BlockType::createSuperItem( zBlock, zItem );
+    return new BasicBlock( this, 0, position );
 }
 
-Block* DirtBlockType::createBlock( Framework::Vec3<int> position ) const
+Item* BasicBlockType::createItem() const
 {
-    return new BasicBlock( this, 0, position ); // TODO: add efective tool
+    return StaticRegistry<ItemType>::INSTANCE.zElement( itemType )->createItem();
 }
 
-Item* DirtBlockType::createItem() const
+// Dirt
+DirtBlockType::DirtBlockType()
+    : BasicBlockType( ID, DirtBlockItemType::ID )
 {
-    return StaticRegistry<ItemType>::INSTANCE.zElement( DirtBlockItemType::ID )->createItem();
+    defaultBlock = createBlockAt( { 0, 0, 0 }, 0 );
 }
 
 
@@ -75,4 +73,204 @@ Item* DirtBlockItemType::createItem() const
     BasicBlockItem* item = new BasicBlockItem( (ItemType*)this, DirtBlockType::INSTANCE, "Dirt" );
     initializeItem( item, 0, 0, 100, 100, 1, 0, 1 );
     return item;
+}
+
+// Stone
+StoneBlockType::StoneBlockType()
+    : BasicBlockType( ID, StoneBlockItemType::ID )
+{
+    hardness = 2.f;
+    defaultBlock = createBlockAt( { 0, 0, 0 }, 0 );
+}
+
+
+StoneBlockItemType::StoneBlockItemType()
+    : BasicBlockItemType( ID, 0, 0 )
+{}
+
+Item* StoneBlockItemType::createItem() const
+{
+    BasicBlockItem* item = new BasicBlockItem( (ItemType*)this, StoneBlockType::INSTANCE, "Stone" );
+    initializeItem( item, 0, 0, 100, 100, 2, 0, 1 );
+    return item;
+}
+
+// Sand
+SandBlockType::SandBlockType()
+    : BasicBlockType( ID, SandBlockItemType::ID )
+{
+    hardness = 0.5f;
+    defaultBlock = createBlockAt( { 0, 0, 0 }, 0 );
+}
+
+
+SandBlockItemType::SandBlockItemType()
+    : BasicBlockItemType( ID, 0, 0 )
+{}
+
+Item* SandBlockItemType::createItem() const
+{
+    BasicBlockItem* item = new BasicBlockItem( (ItemType*)this, SandBlockType::INSTANCE, "Sand" );
+    initializeItem( item, 0, 0, 100, 100, 0.5f, 0, 1 );
+    return item;
+}
+
+// Oak Wood
+OakBlockType::OakBlockType()
+    : BasicBlockType( ID, OakBlockItemType::ID )
+{
+    hardness = 1.5f;
+    defaultBlock = createBlockAt( { 0, 0, 0 }, 0 );
+}
+
+
+OakBlockItemType::OakBlockItemType()
+    : BasicBlockItemType( ID, 0, 0 )
+{}
+
+Item* OakBlockItemType::createItem() const
+{
+    BasicBlockItem* item = new BasicBlockItem( (ItemType*)this, OakBlockType::INSTANCE, "Oak" );
+    initializeItem( item, 0, 0, 100, 100, 1.5f, 0, 1 );
+    return item;
+}
+
+// Leaves Wood
+LeavesBlockType::LeavesBlockType()
+    : BasicBlockType( ID, LeavesBlockItemType::ID )
+{
+    hardness = 0.1f;
+    defaultBlock = createBlockAt( { 0, 0, 0 }, 0 );
+}
+
+
+LeavesBlockItemType::LeavesBlockItemType()
+    : BasicBlockItemType( ID, 0, 0 )
+{}
+
+Item* LeavesBlockItemType::createItem() const
+{
+    BasicBlockItem* item = new BasicBlockItem( (ItemType*)this, LeavesBlockType::INSTANCE, "Leaves" );
+    initializeItem( item, 0, 0, 100, 100, 0.1f, 0, 1 );
+    return item;
+}
+
+// Gravel
+GravelBlockType::GravelBlockType()
+    : BasicBlockType( ID, GravelBlockItemType::ID )
+{
+    hardness = 0.75f;
+    defaultBlock = createBlockAt( { 0, 0, 0 }, 0 );
+}
+
+
+GravelBlockItemType::GravelBlockItemType()
+    : BasicBlockItemType( ID, 0, 0 )
+{}
+
+Item* GravelBlockItemType::createItem() const
+{
+    BasicBlockItem* item = new BasicBlockItem( (ItemType*)this, GravelBlockType::INSTANCE, "Gravel" );
+    initializeItem( item, 0, 0, 100, 100, 0.75f, 0, 1 );
+    return item;
+}
+
+// Granite
+GraniteBlockType::GraniteBlockType()
+    : BasicBlockType( ID, GraniteBlockItemType::ID )
+{
+    hardness = 3.f;
+    defaultBlock = createBlockAt( { 0, 0, 0 }, 0 );
+}
+
+
+GraniteBlockItemType::GraniteBlockItemType()
+    : BasicBlockItemType( ID, 0, 0 )
+{}
+
+Item* GraniteBlockItemType::createItem() const
+{
+    BasicBlockItem* item = new BasicBlockItem( (ItemType*)this, GraniteBlockType::INSTANCE, "Granite" );
+    initializeItem( item, 0, 0, 100, 100, 3.f, 0, 1 );
+    return item;
+}
+
+// Cobble
+CobbleBlockType::CobbleBlockType()
+    : BasicBlockType( ID, CobbleBlockItemType::ID )
+{
+    hardness = 1.f;
+    defaultBlock = createBlockAt( { 0, 0, 0 }, 0 );
+}
+
+
+CobbleBlockItemType::CobbleBlockItemType()
+    : BasicBlockItemType( ID, 0, 0 )
+{}
+
+Item* CobbleBlockItemType::createItem() const
+{
+    BasicBlockItem* item = new BasicBlockItem( (ItemType*)this, CobbleBlockType::INSTANCE, "Cobble" );
+    initializeItem( item, 0, 0, 100, 100, 1.f, 0, 1 );
+    return item;
+}
+
+// Birch Wood
+BirchBlockType::BirchBlockType()
+    : BasicBlockType( ID, BirchBlockItemType::ID )
+{
+    hardness = 1.5f;
+    defaultBlock = createBlockAt( { 0, 0, 0 }, 0 );
+}
+
+
+BirchBlockItemType::BirchBlockItemType()
+    : BasicBlockItemType( ID, 0, 0 )
+{}
+
+Item* BirchBlockItemType::createItem() const
+{
+    BasicBlockItem* item = new BasicBlockItem( (ItemType*)this, BirchBlockType::INSTANCE, "Birch" );
+    initializeItem( item, 0, 0, 100, 100, 1.5f, 0, 1 );
+    return item;
+}
+
+// Beech Wood
+BeechBlockType::BeechBlockType()
+    : BasicBlockType( ID, BeechBlockItemType::ID )
+{
+    hardness = 1.5f;
+    defaultBlock = createBlockAt( { 0, 0, 0 }, 0 );
+}
+
+
+BeechBlockItemType::BeechBlockItemType()
+    : BasicBlockItemType( ID, 0, 0 )
+{}
+
+Item* BeechBlockItemType::createItem() const
+{
+    BasicBlockItem* item = new BasicBlockItem( (ItemType*)this, BeechBlockType::INSTANCE, "Beech" );
+    initializeItem( item, 0, 0, 100, 100, 1.5f, 0, 1 );
+    return item;
+}
+
+// Basalt
+BasaltBlockType::BasaltBlockType()
+    : BasicBlockType( ID, BasaltBlockItemType::ID )
+{
+    hardness = 2.f;
+    defaultBlock = createBlockAt( { 0, 0, 0 }, 0 );
+}
+
+
+BasaltBlockItemType::BasaltBlockItemType()
+    : BasicBlockItemType( ID, 0, 0 )
+{}
+
+Item* BasaltBlockItemType::createItem() const
+{
+    BasicBlockItem* item = new BasicBlockItem( (ItemType*)this, BasaltBlockType::INSTANCE, "Basalt" );
+    initializeItem( item, 0, 0, 100, 100, 2.f, 0, 1 );
+    return item;
 }

FactoryCraft/BasicBlocks.h

@@ -16,20 +16,37 @@ public:
     virtual bool onTick( TickQueue* zQueue, int numTicks, bool& blocked ) override;
     virtual void onPostTick() override;
 
-    friend DirtBlockType;
+    friend BasicBlockType;
 };
 
-class DirtBlockType : public BlockType
+class BasicBlockType : public BlockType
 {
-    REGISTRABLE( DirtBlockType )
+private:
+    int itemType;
 
 protected:
-    virtual void loadSuperBlock( Block* zBlock, Framework::StreamReader* zReader ) const override;
-    virtual void saveSuperBlock( Block* zBlock, Framework::StreamWriter* zWriter ) const override;
+    bool transparent;
+    bool passable;
+    float maxHp;
+    float hardness;
+    ItemType* zTool;
+    float speedModifier;
+    bool interactable;
+
+    BasicBlockType( int typeId, int itemTypeId );
     virtual void createSuperBlock( Block* zBlock, Item* zItem ) const override;
-    virtual void createSuperItem( Block* zBlock, Item* zItem ) const override;
+
+public:
     virtual Block* createBlock( Framework::Vec3<int> position ) const override;
     virtual Item* createItem() const override;
+};
+
+// Dirt
+class DirtBlockType : public BasicBlockType
+{
+    REGISTRABLE( DirtBlockType )
+
+protected:
     DirtBlockType();
 };
 REGISTER( DirtBlockType, BlockType )
@@ -45,3 +62,223 @@ public:
     virtual Item* createItem() 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();
+
+public:
+    virtual Item* createItem() const override;
+};
+REGISTER( StoneBlockItemType, ItemType )
+
+// Sand
+class SandBlockType : public BasicBlockType
+{
+    REGISTRABLE( SandBlockType )
+
+protected:
+    SandBlockType();
+};
+REGISTER( SandBlockType, BlockType )
+
+class SandBlockItemType : public BasicBlockItemType
+{
+    REGISTRABLE( SandBlockItemType )
+
+protected:
+    SandBlockItemType();
+
+public:
+    virtual Item* createItem() const override;
+};
+REGISTER( SandBlockItemType, ItemType )
+
+// Oak Wood
+class OakBlockType : public BasicBlockType
+{
+    REGISTRABLE( OakBlockType )
+
+protected:
+    OakBlockType();
+};
+REGISTER( OakBlockType, BlockType )
+
+class OakBlockItemType : public BasicBlockItemType
+{
+    REGISTRABLE( OakBlockItemType )
+
+protected:
+    OakBlockItemType();
+
+public:
+    virtual Item* createItem() const override;
+};
+REGISTER( OakBlockItemType, ItemType )
+
+// Leaves
+class LeavesBlockType : public BasicBlockType
+{
+    REGISTRABLE( LeavesBlockType )
+
+protected:
+    LeavesBlockType();
+};
+REGISTER( LeavesBlockType, BlockType )
+
+class LeavesBlockItemType : public BasicBlockItemType
+{
+    REGISTRABLE( LeavesBlockItemType )
+
+protected:
+    LeavesBlockItemType();
+
+public:
+    virtual Item* createItem() const override;
+};
+REGISTER( LeavesBlockItemType, ItemType )
+
+// Gravel
+class GravelBlockType : public BasicBlockType
+{
+    REGISTRABLE( GravelBlockType )
+
+protected:
+    GravelBlockType();
+};
+REGISTER( GravelBlockType, BlockType )
+
+class GravelBlockItemType : public BasicBlockItemType
+{
+    REGISTRABLE( GravelBlockItemType )
+
+protected:
+    GravelBlockItemType();
+
+public:
+    virtual Item* createItem() const override;
+};
+REGISTER( GravelBlockItemType, ItemType )
+
+// Granite
+class GraniteBlockType : public BasicBlockType
+{
+    REGISTRABLE( GraniteBlockType )
+
+protected:
+    GraniteBlockType();
+};
+REGISTER( GraniteBlockType, BlockType )
+
+class GraniteBlockItemType : public BasicBlockItemType
+{
+    REGISTRABLE( GraniteBlockItemType )
+
+protected:
+    GraniteBlockItemType();
+
+public:
+    virtual Item* createItem() const override;
+};
+REGISTER( GraniteBlockItemType, ItemType )
+
+// Cobble
+class CobbleBlockType : public BasicBlockType
+{
+    REGISTRABLE( CobbleBlockType )
+
+protected:
+    CobbleBlockType();
+};
+REGISTER( CobbleBlockType, BlockType )
+
+class CobbleBlockItemType : public BasicBlockItemType
+{
+    REGISTRABLE( CobbleBlockItemType )
+
+protected:
+    CobbleBlockItemType();
+
+public:
+    virtual Item* createItem() const override;
+};
+REGISTER( CobbleBlockItemType, ItemType )
+
+// Birch Wood
+class BirchBlockType : public BasicBlockType
+{
+    REGISTRABLE( BirchBlockType )
+
+protected:
+    BirchBlockType();
+};
+REGISTER( BirchBlockType, BlockType )
+
+class BirchBlockItemType : public BasicBlockItemType
+{
+    REGISTRABLE( BirchBlockItemType )
+
+protected:
+    BirchBlockItemType();
+
+public:
+    virtual Item* createItem() const override;
+};
+REGISTER( BirchBlockItemType, ItemType )
+
+// Beech Wood
+class BeechBlockType : public BasicBlockType
+{
+    REGISTRABLE( BeechBlockType )
+
+protected:
+    BeechBlockType();
+};
+REGISTER( BeechBlockType, BlockType )
+
+class BeechBlockItemType : public BasicBlockItemType
+{
+    REGISTRABLE( BeechBlockItemType )
+
+protected:
+    BeechBlockItemType();
+
+public:
+    virtual Item* createItem() const override;
+};
+REGISTER( BeechBlockItemType, ItemType )
+
+// Basalt
+class BasaltBlockType : public BasicBlockType
+{
+    REGISTRABLE( BasaltBlockType )
+
+protected:
+    BasaltBlockType();
+};
+REGISTER( BasaltBlockType, BlockType )
+
+class BasaltBlockItemType : public BasicBlockItemType
+{
+    REGISTRABLE( BasaltBlockItemType )
+
+protected:
+    BasaltBlockItemType();
+
+public:
+    virtual Item* createItem() const override;
+};
+REGISTER( BasaltBlockItemType, ItemType )

FactoryCraft/FastNoiseWrapper.cpp

@@ -4,6 +4,7 @@ FastNoiseWrapper::FastNoiseWrapper( FastNoiseLite* noise, int seed )
 {
     this->noise = noise;
     this->seed = seed;
+    this->multiplier = 1.f;
 }
 
 FastNoiseWrapper::~FastNoiseWrapper()
@@ -11,6 +12,12 @@ FastNoiseWrapper::~FastNoiseWrapper()
     delete noise;
 }
 
+void FastNoiseWrapper::setMultiplier( float multiplier )
+{
+    assert( multiplier > 0 );
+    this->multiplier = multiplier;
+}
+
 int FastNoiseWrapper::getSeed() const
 {
     return seed;
@@ -19,5 +26,5 @@ int FastNoiseWrapper::getSeed() const
 double FastNoiseWrapper::getNoise( double x, double y, double z )
 {
     // scale the noise from 0 to 1
-    return (noise->GetNoise( x, y, z ) + 1) / 2;
+    return (noise->GetNoise( x, y, z ) * multiplier + 1) / 2;
 }

FactoryCraft/FastNoiseWrapper.h

@@ -6,11 +6,13 @@ class FastNoiseWrapper : public Noise
 {
 private:
     int seed;
+    float multiplier;
     FastNoiseLite* noise;
 
 public:
     FastNoiseWrapper( FastNoiseLite* noise, int seed );
     ~FastNoiseWrapper();
+    void setMultiplier( float multiplier );
     int getSeed() const;
     double getNoise( double x, double y, double z );
 };

FactoryCraft/GrasslandBiom.cpp

@@ -27,6 +27,8 @@ Noise* GrasslandBiom::zHeightMapNoise( int seed )
         return heightNoise;
     FastNoiseLite* noise = new FastNoiseLite( seed );
     noise->SetNoiseType( FastNoiseLite::NoiseType::NoiseType_ValueCubic );
-    heightNoise = new FastNoiseWrapper( noise, seed );
+    FastNoiseWrapper* wrapper = new FastNoiseWrapper( noise, seed );
+    wrapper->setMultiplier( 0.2f );
+    heightNoise = wrapper;
     return heightNoise;
 }