implement all todos that were about items that needed to be spawned

FactoryCraft/BasicBlock.cpp

@@ -4,13 +4,17 @@
 #include "ItemEntity.h"
 #include "TreeSeblingBlock.h"
 
-BasicBlock::BasicBlock(int typeId, ItemType* zTool, Framework::Vec3<int> pos)
-    : BasicBlock(typeId, zTool, pos, false)
+BasicBlock::BasicBlock(
+    int typeId, ItemType* zTool, Framework::Vec3<int> pos, int dimensionId)
+    : BasicBlock(typeId, zTool, pos, dimensionId, false)
 {}
 
-BasicBlock::BasicBlock(
-    int typeId, ItemType* zTool, Framework::Vec3<int> pos, bool hasInventory)
-    : Block(typeId, zTool, pos, hasInventory)
+BasicBlock::BasicBlock(int typeId,
+    ItemType* zTool,
+    Framework::Vec3<int> pos,
+    int dimensionId,
+    bool hasInventory)
+    : Block(typeId, zTool, pos, dimensionId, hasInventory)
 {}
 
 bool BasicBlock::onTick(TickQueue* zQueue, int numTicks, bool& blocked)
@@ -21,8 +25,8 @@ bool BasicBlock::onTick(TickQueue* zQueue, int numTicks, bool& blocked)
 void BasicBlock::onPostTick() {}
 
 AdditionalItemSpawningBlock::AdditionalItemSpawningBlock(
-    int typeId, ItemType* zTool, Framework::Vec3<int> pos)
-    : BasicBlock(typeId, zTool, pos)
+    int typeId, ItemType* zTool, Framework::Vec3<int> pos, int dimensionId)
+    : BasicBlock(typeId, zTool, pos, dimensionId)
 {}
 
 void AdditionalItemSpawningBlock::addSpawn(SpawnConfig config)
@@ -71,8 +75,8 @@ BasicBlockType::BasicBlockType(
         typeId,
         itemTypeId,
         model,
-        [typeId](Framework::Vec3<int> pos) {
-            return new BasicBlock(typeId, 0, pos);
+        [typeId](Framework::Vec3<int> pos, int dimensionId) {
+            return new BasicBlock(typeId, 0, pos, dimensionId);
         },
         name,
         mapColor)
@@ -81,7 +85,7 @@ BasicBlockType::BasicBlockType(
 BasicBlockType::BasicBlockType(int typeId,
     int itemTypeId,
     ModelInfo model,
-    std::function<Block*(Framework::Vec3<int>)> creatBlockCustom,
+    std::function<Block*(Framework::Vec3<int>, int)> creatBlockCustom,
     const char* name,
     int mapColor)
     : BasicBlockType(
@@ -91,7 +95,7 @@ BasicBlockType::BasicBlockType(int typeId,
 BasicBlockType::BasicBlockType(int typeId,
     int itemTypeId,
     ModelInfo model,
-    std::function<Block* (Framework::Vec3<int>)> creatBlockCustom,
+    std::function<Block* (Framework::Vec3<int>, int)> creatBlockCustom,
     const char* name,
     int mapColor,
     bool modelSubscription)
@@ -120,9 +124,10 @@ void BasicBlockType::createSuperBlock(Block* zBlock, Item* zItem) const
     BlockType::createSuperBlock(zBlock, zItem);
 }
 
-Block* BasicBlockType::createBlock(Framework::Vec3<int> position) const
+Block* BasicBlockType::createBlock(
+    Framework::Vec3<int> position, int dimensionId) const
 {
-    return creatBlockCustom(position);
+    return creatBlockCustom(position, dimensionId);
 }
 
 Item* BasicBlockType::createItem() const

FactoryCraft/BasicBlocks.h

@@ -11,8 +11,13 @@ class BasicBlockType;
 class BasicBlock : public Block
 {
 public:
-    BasicBlock(int typeId, ItemType* zTool, Framework::Vec3<int> pos);
-    BasicBlock(int typeId, ItemType* zTool, Framework::Vec3<int> pos, bool hasInventory);
+    BasicBlock(
+        int typeId, ItemType* zTool, Framework::Vec3<int> pos, int dimensionId);
+    BasicBlock(int typeId,
+        ItemType* zTool,
+        Framework::Vec3<int> pos,
+        int dimensionId,
+        bool hasInventory);
     virtual bool onTick(
         TickQueue* zQueue, int numTicks, bool& blocked) override;
     virtual void onPostTick() override;
@@ -35,7 +40,7 @@ private:
 
 public:
     AdditionalItemSpawningBlock(
-        int typeId, ItemType* zTool, Framework::Vec3<int> pos);
+        int typeId, ItemType* zTool, Framework::Vec3<int> pos, int dimensionId);
     void addSpawn(SpawnConfig config);
     virtual void onDestroy() override;
 };
@@ -50,28 +55,32 @@ private:
     ItemType* zTool;
     float speedModifier;
     bool interactable;
-    std::function<Block*(Framework::Vec3<int>)> creatBlockCustom;
+    std::function<Block*(Framework::Vec3<int>, int)> creatBlockCustom;
 
 protected:
     virtual void createSuperBlock(Block* zBlock, Item* zItem) const override;
 
 public:
-    BasicBlockType(
-        int typeId, int itemTypeId, ModelInfo model, const char* name, int mapColor);
     BasicBlockType(int typeId,
         int itemTypeId,
         ModelInfo model,
-        std::function<Block*(Framework::Vec3<int>)> creatBlockCustom,
         const char* name,
         int mapColor);
     BasicBlockType(int typeId,
         int itemTypeId,
         ModelInfo model,
-        std::function<Block*(Framework::Vec3<int>)> creatBlockCustom,
+        std::function<Block*(Framework::Vec3<int>, int)> creatBlockCustom,
+        const char* name,
+        int mapColor);
+    BasicBlockType(int typeId,
+        int itemTypeId,
+        ModelInfo model,
+        std::function<Block*(Framework::Vec3<int>, int)> creatBlockCustom,
         const char* name,
         int mapColor,
         bool modelSubscription);
-    virtual Block* createBlock(Framework::Vec3<int> position) const override;
+    virtual Block* createBlock(
+        Framework::Vec3<int> position, int dimensionId) const override;
     virtual Item* createItem() const override;
     BasicBlockType* setHardness(float hardness);
     BasicBlockType* setTransparent(bool transparent);

FactoryCraft/BiomGenerator.h

@@ -19,20 +19,28 @@ protected:
 
 public:
     BiomGenerator();
-    virtual Framework::Either<Block*, int> generateAboveSurfaceBlock(
-        int x, int y, int z, int surfaceHeight, Chunk* partialGeneratedChunk)
+    virtual Framework::Either<Block*, int> generateAboveSurfaceBlock(int x,
+        int y,
+        int z,
+        int dimensionId,
+        int surfaceHeight,
+        Chunk* partialGeneratedChunk)
         = 0;
     virtual Framework::Either<Block*, int> generateSurfaceBlock(
-        int x, int y, int z)
+        int x, int y, int z, int dimensionId)
         = 0;
     virtual Framework::Either<Block*, int> generateBelowSurfaceBlock(
-        int x, int y, int z)
+        int x, int y, int z, int dimensionId)
         = 0;
     virtual Framework::Either<Block*, int> generateCaveBlock(
-        int x, int y, int z)
+        int x, int y, int z, int dimensionId)
         = 0;
-    virtual Framework::Either<Block*, int> generateUnderWaterBlock(
-        int x, int y, int z, int surfaceHeight, Chunk* partialGeneratedChunk)
+    virtual Framework::Either<Block*, int> generateUnderWaterBlock(int x,
+        int y,
+        int z,
+        int dimensionId,
+        int surfaceHeight,
+        Chunk* partialGeneratedChunk)
         = 0;
     virtual void setSeed(int seed);
     virtual Noise* zHeightMapNoise() = 0;

FactoryCraft/Block.cpp

@@ -10,8 +10,9 @@
 Block::Block(int typeId,
     const ItemType* zTool,
     Framework::Vec3<int> pos,
+    int dimensionId,
     bool hasInventory)
-    : Inventory(pos, hasInventory)
+    : Inventory(pos, dimensionId, hasInventory)
 {
     transparent = false;
     passable = false;
@@ -28,7 +29,6 @@ Block::Block(int typeId,
     maxTickTimeout = -1;
     tickSource = 0;
     currentTickTimeout = 0;
-    dimensionId = 0;
     interactable = 0;
     deadAndRemoved = 0;
     memset(zNeighbours, 0, sizeof(Block*) * 6);
@@ -61,21 +61,12 @@ void Block::onDestroy()
         Item* blockItem = zBlockType()->getItemFromBlock(this);
         if (blockItem)
         {
-            ItemEntity* itemEntity
-                = (ItemEntity*)StaticRegistry<EntityType>::INSTANCE
-                      .zElement(EntityTypeEnum::ITEM)
-                      ->createEntity(
-                          location + Framework::Vec3<float>(0.5f, 0.5f, 0.5f),
-                          dimensionId,
-                          Game::INSTANCE->getNextEntityId());
-            ItemStack* stack
-                = new ItemStack(blockItem, 1, blockItem->getMaxStackSize());
-            itemEntity->unsaveAddItem(stack, NO_DIRECTION, 0);
-            stack->release();
-            Game::INSTANCE->requestWorldUpdate(
-                new AddEntityUpdate(itemEntity, dimensionId));
-            deadAndRemoved = 1;
+            Game::INSTANCE->spawnItem(
+                location + Framework::Vec3<float>(0.5f, 0.5f, 0.5f),
+                dimensionId,
+                blockItem);
         }
+        deadAndRemoved = 1;
         for (MultiblockStructure* structure : structures)
             structure->onBlockRemoved(this);
         Game::INSTANCE->zDimension(dimensionId)
@@ -165,11 +156,6 @@ void Block::setNeighbourType(Direction dir, int type)
     neighbourTypes[getDirectionIndex(dir)] = type;
 }
 
-void Block::setDimensionId(int id)
-{
-    dimensionId = id;
-}
-
 void Block::addToStructure(MultiblockStructure* structure)
 {
     if (structure->isBlockMember(this))
@@ -205,7 +191,6 @@ void Block::interact(Item* zItem, Entity* zActor) {}
 
 void Block::api(Framework::StreamReader* zRequest, NetworkMessage* zResponse)
 {
-    // TODO: answer api requests
     char id = 0;
     zRequest->lese(&id, 1);
     switch (id)
@@ -281,11 +266,6 @@ const Framework::Vec3<int> Block::getPos() const
     return (Framework::Vec3<int>)location;
 }
 
-int Block::getDimensionId() const
-{
-    return dimensionId;
-}
-
 bool Block::isVisible() const
 {
     if (passable || transparent) return 1;

FactoryCraft/Block.h

@@ -32,7 +32,6 @@ private:
     int currentTickTimeout;
     bool wasTicked;
     bool onTickCalled;
-    int dimensionId;
 
 protected:
     bool transparent;
@@ -80,12 +79,12 @@ public:
     Block(int typeId,
         const ItemType* zTool,
         Framework::Vec3<int> pos,
+        int dimensionId,
         bool hasInventory);
     virtual ~Block();
 
     void tick(TickQueue* zQueue) override;
     void postTick() override;
-    void setDimensionId(int id);
     void addToStructure(MultiblockStructure* structure);
     virtual void onLoaded();
     virtual void onUnloaded();
@@ -109,7 +108,6 @@ public:
     const ItemType* zEffectiveTool() const;
     float getSpeedModifier() const;
     const Framework::Vec3<int> getPos() const;
-    int getDimensionId() const;
     bool isVisible() const;
     void setHP(float hp);
     bool isDeadAndRemoved() const;

FactoryCraft/BlockType.cpp

@@ -143,7 +143,7 @@ Block* BlockType::loadBlock(Framework::Vec3<int> position,
     Framework::StreamReader* zReader,
     int dimensionId) const
 {
-    Block* result = createBlock(position);
+    Block* result = createBlock(position, dimensionId);
     loadSuperBlock(result, zReader, dimensionId);
     return result;
 }
@@ -164,9 +164,9 @@ Item* BlockType::getItemFromBlock(Block* zBlock) const
 }
 
 Block* BlockType::createBlockAt(
-    Framework::Vec3<int> position, Item* zUsedItem) const
+    Framework::Vec3<int> position, int dimensionId, Item* zUsedItem) const
 {
-    Block* result = createBlock(position);
+    Block* result = createBlock(position, dimensionId);
     createSuperBlock(result, zUsedItem);
     return result;
 }
@@ -211,7 +211,7 @@ const Block* getDefaultBlock(Either<Block*, int> b)
 
 BlockType* BlockType::initializeDefault()
 {
-    defaultBlock = createBlockAt({0, 0, 0}, 0);
+    defaultBlock = createBlockAt({0, 0, 0}, 0, 0);
     return this;
 }
 

FactoryCraft/BlockType.h

@@ -79,7 +79,7 @@ protected:
         Block* zBlock, Framework::StreamWriter* zWriter) const;
     virtual void createSuperBlock(Block* zBlock, Item* zItem) const;
     virtual void createSuperItem(Block* zBlock, Item* zItem) const;
-    virtual Block* createBlock(Framework::Vec3<int> position) const = 0;
+    virtual Block* createBlock(Framework::Vec3<int> position, int dimensionId) const = 0;
     virtual Item* createItem() const = 0;
 
 public:
@@ -91,7 +91,7 @@ public:
         Block* zBlock, Framework::StreamWriter* zWriter) const;
     virtual Item* getItemFromBlock(Block* zBlock) const;
     virtual Block* createBlockAt(
-        Framework::Vec3<int> position, Item* zUsedItem) const;
+        Framework::Vec3<int> position, int dimensionId, Item* zUsedItem) const;
     virtual const Block* zDefault() const;
     bool doesNeedClientInstance() const;
     const ModelInfo& getModel() const;

FactoryCraft/Chest.cpp

@@ -4,8 +4,9 @@
 
 #include "Game.h"
 
-Chest::Chest(int typeId, ItemType* zTool, Framework::Vec3<int> pos)
-    : BasicBlock(typeId, zTool, pos, 1),
+Chest::Chest(
+    int typeId, ItemType* zTool, Framework::Vec3<int> pos, int dimensionId)
+    : BasicBlock(typeId, zTool, pos, dimensionId, 1),
       open(0),
       userEntityId(0)
 {
@@ -19,7 +20,16 @@ Chest::Chest(int typeId, ItemType* zTool, Framework::Vec3<int> pos)
 
 void Chest::onDestroy()
 {
-    // TODO: drop inventory
+    for (ItemSlot* slot : *this)
+    {
+        if (!slot->isEmpty())
+        {
+            Game::INSTANCE->spawnItem(location + Vec3<float>(0.5f, 0.5f, 0.5f),
+                getDimensionId(),
+                slot->takeItemsOut(slot->getNumberOfItems(), NO_DIRECTION));
+        }
+    }
+    BasicBlock::onDestroy();
 }
 
 void Chest::onDialogClosed(Framework::Text dialogId)

FactoryCraft/Chest.h

@@ -13,10 +13,12 @@ private:
     Framework::Text getDialogId() const;
 
 protected:
-    virtual bool onTick(TickQueue* zQueue, int numTicks, bool& blocked) override;
+    virtual bool onTick(
+        TickQueue* zQueue, int numTicks, bool& blocked) override;
 
 public:
-    Chest(int typeId, ItemType* zTool, Framework::Vec3<int> pos);
+    Chest(
+        int typeId, ItemType* zTool, Framework::Vec3<int> pos, int dimensionId);
     virtual void interact(Item* zItem, Entity* zActor) override;
     virtual void sendModelInfo(NetworkMessage* zMessage) override;
 };

FactoryCraft/Chunk.cpp

@@ -305,7 +305,6 @@ void Chunk::api(Framework::StreamReader* zRequest,
     Entity* zSource,
     DoLaterHandler& laterHandler)
 {
-    // TODO: answer api messages
     char type;
     zRequest->lese(&type, 1);
     switch (type)
@@ -425,7 +424,7 @@ void Chunk::instantiateBlock(Framework::Vec3<int> location)
                 ->createBlockAt(
                     {location.x + this->location.x - CHUNK_SIZE / 2,
                         location.y + this->location.y - CHUNK_SIZE / 2,
-                        location.z},
+                        location.z}, dimensionId,
                     0));
 }
 

FactoryCraft/CraftingStorage.cpp

@@ -113,7 +113,8 @@ bool BasicShapedCrafter::isAllAvailable(Framework::RCArray<ItemFilter>& filters,
                         = craftingInput.get((h + y) * this->width + (x + w));
                     const Item* item = 0;
                     if (s && s->zStack()
-                        && s->zStack()->getSize() >= inputAmount.get(h * width + w))
+                        && s->zStack()->getSize()
+                               >= inputAmount.get(h * width + w))
                         item = s->zStack()->zItem();
                     wrong |= (item && !f) || (!item && f);
                     wrong |= item && f && !f->matchItem(item);
@@ -215,19 +216,22 @@ bool BasicShapedCrafter::consume(Framework::RCArray<ItemFilter>& filters,
                 target, target->getNumberOfItems(), INSIDE);
             if (stack)
             {
-                if (stack->getSize()
-                    > inputAmount.get(y * width + x))
+                if (stack->getSize() > inputAmount.get(y * width + x))
                 {
                     ItemStack* overflow = stack->split(
-                        stack->getSize()
-                        - inputAmount.get(y * width + x));
+                        stack->getSize() - inputAmount.get(y * width + x));
                     zInventory->unsaveAddItem(
                         overflow, INSIDE, &otherSlotsTarget);
                     if (overflow->getSize() > 0)
                     {
-                        // TODO: drop items
+                        Game::INSTANCE->spawnItem(zInventory->getLocation(),
+                            zInventory->getDimensionId(),
+                            overflow);
+                    }
+                    else
+                    {
+                        overflow->release();
                     }
-                    overflow->release();
                 }
                 if (stack->getSize() > 0 && stack->zItem())
                 {
@@ -240,22 +244,38 @@ bool BasicShapedCrafter::consume(Framework::RCArray<ItemFilter>& filters,
                 {
                     Item* broken = stack->zItem()->zItemType()->breakItem(
                         stack->zItem());
-                    stack->release();
                     if (broken)
                     {
                         ItemStack* brokenStack
                             = new ItemStack(broken, stack->getSize());
                         zInventory->unsaveAddItem(
                             brokenStack, INSIDE, &otherSlotsTarget);
-                        // TODO: if brokenStack is not empty spawn an item
-                        // entity
-                        brokenStack->release();
+                        if (brokenStack->getSize() > 0)
+                        {
+                            Game::INSTANCE->spawnItem(zInventory->getLocation(),
+                                zInventory->getDimensionId(),
+                                brokenStack);
+                        }
+                        else
+                        {
+                            brokenStack->release();
+                        }
                     }
+                    stack->release();
                 }
                 else
                 {
                     zInventory->addItems(target, stack, INSIDE);
-                    // TODO: if stack is not empty spawn an item entity
+                    if (stack->getSize() > 0)
+                    {
+                        Game::INSTANCE->spawnItem(zInventory->getLocation(),
+                            zInventory->getDimensionId(),
+                            stack);
+                    }
+                    else
+                    {
+                        stack->release();
+                    }
                 }
             }
             ItemFilter* f = filters.z(y * width + x);
@@ -315,9 +335,14 @@ bool BasicShapedCrafter::consume(Framework::RCArray<ItemFilter>& filters,
                             overflow, INSIDE, &otherSlotsTarget);
                         if (overflow->getSize() > 0)
                         {
-                            // TODO: drop items
+                            Game::INSTANCE->spawnItem(zInventory->getLocation(),
+                                zInventory->getDimensionId(),
+                                overflow);
+                        }
+                        else
+                        {
+                            overflow->release();
                         }
-                        overflow->release();
                     }
                     if (stack->getSize() > 0 && stack->zItem())
                     {
@@ -330,22 +355,39 @@ bool BasicShapedCrafter::consume(Framework::RCArray<ItemFilter>& filters,
                     {
                         Item* broken = stack->zItem()->zItemType()->breakItem(
                             stack->zItem());
-                        stack->release();
                         if (broken)
                         {
                             ItemStack* brokenStack
                                 = new ItemStack(broken, stack->getSize());
                             zInventory->unsaveAddItem(
                                 brokenStack, INSIDE, &otherSlotsTarget);
-                            // TODO: if brokenStack is not empty spawn an item
-                            // entity
-                            brokenStack->release();
+                            if (brokenStack->getSize() > 0)
+                            {
+                                Game::INSTANCE->spawnItem(
+                                    zInventory->getLocation(),
+                                    zInventory->getDimensionId(),
+                                    brokenStack);
+                            }
+                            else
+                            {
+                                brokenStack->release();
+                            }
                         }
+                        stack->release();
                     }
                     else
                     {
                         zInventory->addItems(target, stack, INSIDE);
-                        // TODO: if stack is not empty spawn an item entity
+                        if (stack->getSize() > 0)
+                        {
+                            Game::INSTANCE->spawnItem(zInventory->getLocation(),
+                                zInventory->getDimensionId(),
+                                stack);
+                        }
+                        else
+                        {
+                            stack->release();
+                        }
                     }
                 }
                 ItemFilter* f = filters.z(i);

FactoryCraft/DimensionGenerator.cpp

@@ -96,7 +96,8 @@ DimensionGenerator::getGeneratedStructoresForArea(
                                * (MAX_AIR_LEVEL - MIN_AIR_LEVEL));
             for (int z = minSearchZ; z <= maxSearchZ && z < height; z++)
             {
-                double rValue = structureNoise->getNoise((double)x, (double)y, (double)z);
+                double rValue
+                    = structureNoise->getNoise((double)x, (double)y, (double)z);
                 double probSum = 0;
                 for (auto t : biom->getTemplates())
                 {
@@ -193,7 +194,8 @@ Chunk* DimensionGenerator::generateChunk(int centerX, int centerY)
                         structureTime2 += zm.getSekunden();
                         zm.messungStart();
                         generated = structure->generateBlockAt(
-                            Framework::Vec3<int>(x + centerX, y + centerY, z));
+                            Framework::Vec3<int>(x + centerX, y + centerY, z),
+                            dimensionId);
                         structureAffected = 1;
                         zm.messungEnde();
                         structureTime3 += zm.getSekunden();
@@ -212,22 +214,30 @@ Chunk* DimensionGenerator::generateChunk(int centerX, int centerY)
                     zm.messungStart();
                     if (inCave)
                         generated = biom->generateCaveBlock(
-                            x + centerX, y + centerY, z);
+                            x + centerX, y + centerY, z, dimensionId);
                     else if (z < height && z >= height - actualSurfaceHeight)
                         generated = biom->generateSurfaceBlock(
-                            x + centerX, y + centerY, z);
+                            x + centerX, y + centerY, z, dimensionId);
                     else if (z < height)
                         generated = biom->generateBelowSurfaceBlock(
-                            x + centerX, y + centerY, z);
+                            x + centerX, y + centerY, z, dimensionId);
                     else if (z >= height && z < WATER_LEVEL)
                     {
-                        generated = biom->generateUnderWaterBlock(
-                            x + centerX, y + centerY, z, height, chunk);
+                        generated = biom->generateUnderWaterBlock(x + centerX,
+                            y + centerY,
+                            z,
+                            dimensionId,
+                            height,
+                            chunk);
                     }
                     else
                     {
-                        generated = biom->generateAboveSurfaceBlock(
-                            x + centerX, y + centerY, z, height, chunk);
+                        generated = biom->generateAboveSurfaceBlock(x + centerX,
+                            y + centerY,
+                            z,
+                            dimensionId,
+                            height,
+                            chunk);
                     }
                     zm.messungEnde();
                     blockGenTime += zm.getSekunden();
@@ -284,22 +294,24 @@ Framework::Either<Block*, int> DimensionGenerator::generateBlock(
     {
         if (structure->isBlockAffected(location))
         {
-            auto generated = structure->generateBlockAt(location);
+            auto generated = structure->generateBlockAt(location, dimensionId);
             structures->release();
             return generated;
         }
     }
     structures->release();
     if (location.z < height && location.z >= height - actualSurfaceHeight)
-        return biom->generateSurfaceBlock(location.x, location.y, location.z);
+        return biom->generateSurfaceBlock(
+            location.x, location.y, location.z, dimensionId);
     else if (location.z < height)
         return biom->generateBelowSurfaceBlock(
-            location.x, location.y, location.z);
+            location.x, location.y, location.z, dimensionId);
     else if (location.z >= height && location.z < WATER_LEVEL)
     {
         return biom->generateUnderWaterBlock(location.x,
             location.y,
             location.z,
+            dimensionId,
             height,
             Game::INSTANCE->zDimension(getDimensionId())
                 ->zChunk(
@@ -310,6 +322,7 @@ Framework::Either<Block*, int> DimensionGenerator::generateBlock(
         return biom->generateAboveSurfaceBlock(location.x,
             location.x,
             location.z,
+            dimensionId,
             height,
             Game::INSTANCE->zDimension(getDimensionId())
                 ->zChunk(
@@ -350,7 +363,7 @@ bool DimensionGenerator::spawnStructure(Framework::Vec3<int> location,
                                     Framework::Vec3<int>(x, y, z)))
                             {
                                 auto gen = genStr->generateBlockAt(
-                                    Framework::Vec3<int>(x, y, z));
+                                    Framework::Vec3<int>(x, y, z), dimensionId);
                                 Game::INSTANCE->zDimension(dimensionId)
                                     ->placeBlock(
                                         Framework::Vec3<int>(x, y, z), gen);

FactoryCraft/Entity.cpp

@@ -43,7 +43,7 @@ void ActionTarget::useItemSkillOnTarget(
     else
     {
         Block* block = Game::INSTANCE->zRealBlockInstance(
-            blockPos, zActor->getCurrentDimensionId());
+            blockPos, zActor->getDimensionId());
         if (block) zItemSkill->use(zActor, zUsedItem, block);
     }
 }
@@ -61,7 +61,7 @@ void ActionTarget::interactItemSkillOnTarget(
         else
         {
             Block* block = Game::INSTANCE->zRealBlockInstance(
-                blockPos, zActor->getCurrentDimensionId());
+                blockPos, zActor->getDimensionId());
             if (block) zItemSkill->interact(zActor, zUsedItem, block);
         }
     }
@@ -70,13 +70,13 @@ void ActionTarget::interactItemSkillOnTarget(
         if (entityId >= 0)
         {
             Block* block = Game::INSTANCE->zRealBlockInstance(
-                blockPos, zActor->getCurrentDimensionId());
+                blockPos, zActor->getDimensionId());
             if (block) block->interact(zUsedItem, zActor);
         }
         else
         {
             Block* block = Game::INSTANCE->zRealBlockInstance(
-                blockPos, zActor->getCurrentDimensionId());
+                blockPos, zActor->getDimensionId());
             if (block) block->interact(zUsedItem, zActor);
         }
     }
@@ -86,14 +86,16 @@ void ActionTarget::placeBlock(Entity* zActor, Item* zItem)
 {
     if (zActor->getStamina() > 0.2f)
     {
-        if (zItem->canBePlacedAt(zActor->getCurrentDimensionId(),
+        if (zItem->canBePlacedAt(zActor->getDimensionId(),
                 blockPos + getDirection(targetBlockSide)))
         {
             Block* block = zItem->zPlacedBlockType()->createBlockAt(
-                blockPos + getDirection(targetBlockSide), zItem);
+                blockPos + getDirection(targetBlockSide),
+                zActor->getDimensionId(),
+                zItem);
             if (block)
             {
-                Game::INSTANCE->zDimension(zActor->getCurrentDimensionId())
+                Game::INSTANCE->zDimension(zActor->getDimensionId())
                     ->placeBlock(block->getPos(), block);
                 zItem->onPlaced();
                 zActor->setStamina(zActor->getStamina() - 0.2f);
@@ -204,13 +206,12 @@ ActionTarget* ActionTarget::load(Framework::StreamReader* zReader)
 
 Entity::Entity(
     int typeId, Framework::Vec3<float> location, int dimensionId, int entityId)
-    : Inventory(location, true),
+    : Inventory(location, dimensionId, true),
       chatSecurityLevel(0),
       speed(0, 0, 0),
       faceDir(1, 0, 0),
       target(0),
       typeId(typeId),
-      currentDimensionId(dimensionId),
       removed(0),
       gravityMultiplier(1.f),
       id(entityId),
@@ -221,7 +222,7 @@ void Entity::onDeath()
 {
     removed = 1;
     Game::INSTANCE->requestWorldUpdate(
-        new EntityRemovedUpdate(id, currentDimensionId, location));
+        new EntityRemovedUpdate(id, dimensionId, location));
 }
 
 void Entity::useItem(int typeId, Item* zItem, bool left)
@@ -328,8 +329,7 @@ void Entity::calculateTarget(Framework::Vec3<float> basePos,
     Direction dir = BOTTOM;
     while (true)
     {
-        if (getDefaultBlock(Game::INSTANCE->zBlockAt(
-                                Vec3<int>{px, py, pz}, currentDimensionId))
+        if (getDefaultBlock(Game::INSTANCE->zBlockAt(Vec3<int>{px, py, pz}, dimensionId))
                 ->isInteractable(zItem))
         {
             if (!target || !target->isBlock({px, py, pz}, dir))
@@ -531,7 +531,7 @@ void Entity::tick(const Dimension* zDimension)
                         break;
                 }
                 double t = MIN(currentFrame.duration, seconds);
-                // TODO: add collisin detection to reduce cheating capability
+                // TODO: add collision detection to reduce cheating capability
                 location += (currentFrame.targetPosition - location)
                           * (float)(t / currentFrame.duration);
                 currentFrame.duration -= t;
@@ -739,11 +739,6 @@ float Entity::getGravityMultiplier() const
     return gravityMultiplier;
 }
 
-int Entity::getCurrentDimensionId() const
-{
-    return currentDimensionId;
-}
-
 bool Entity::isRemoved() const
 {
     return removed;

FactoryCraft/Entity.h

@@ -70,7 +70,6 @@ protected:
     Framework::RCArray<ItemSkill> skills;
     ActionTarget* target;
     int typeId;
-    int currentDimensionId;
     bool removed;
     float gravityMultiplier;
     int id;
@@ -125,7 +124,6 @@ public:
     Framework::Vec3<float> getFaceDir() const;
     Framework::Vec3<float> getPosition() const;
     float getGravityMultiplier() const;
-    int getCurrentDimensionId() const;
     bool isRemoved() const;
     const EntityType* zType() const;
     const ActionTarget* zTarget() const;

FactoryCraft/EntityType.cpp

@@ -30,7 +30,7 @@ void EntityType::loadSuperEntity(
     zReader->lese((char*)&zEntity->speed.z, 4);
     zReader->lese((char*)&zEntity->faceDir.x, 4);
     zReader->lese((char*)&zEntity->faceDir.y, 4);
-    zReader->lese((char*)&zEntity->currentDimensionId, 4);
+    zReader->lese((char*)&zEntity->dimensionId, 4);
     zReader->lese((char*)&zEntity->location.x, 4);
     zReader->lese((char*)&zEntity->location.y, 4);
     zReader->lese((char*)&zEntity->location.z, 4);
@@ -69,7 +69,7 @@ void EntityType::saveSuperEntity(
     zWriter->schreibe((char*)&zEntity->speed.z, 4);
     zWriter->schreibe((char*)&zEntity->faceDir.x, 4);
     zWriter->schreibe((char*)&zEntity->faceDir.y, 4);
-    zWriter->schreibe((char*)&zEntity->currentDimensionId, 4);
+    zWriter->schreibe((char*)&zEntity->dimensionId, 4);
     zWriter->schreibe((char*)&zEntity->location.x, 4);
     zWriter->schreibe((char*)&zEntity->location.y, 4);
     zWriter->schreibe((char*)&zEntity->location.z, 4);

FactoryCraft/FluidBlock.cpp

@@ -2,8 +2,8 @@
 
 #include "Game.h"
 
-FluidBlock::FluidBlock(int typeId, Framework::Vec3<int> pos)
-    : Block(typeId, 0, pos, 0)
+FluidBlock::FluidBlock(int typeId, Framework::Vec3<int> pos, int dimensionId)
+    : Block(typeId, 0, pos, dimensionId, 0)
 {
     transparent = 1;
     passable = 1;
@@ -153,7 +153,7 @@ void FluidBlock::onPostTick()
                         = getPos() + getDirection(getDirectionFromIndex(i));
                     if (neighbourTypes[i] == BlockTypeEnum::AIR)
                     {
-                        FluidBlock* spawn = new FluidBlock(typeId, pos);
+                        FluidBlock* spawn = new FluidBlock(typeId, pos, dimensionId);
                         spawn->fluidAmount = 1;
                         Game::INSTANCE->zDimension(getDimensionId())
                             ->placeBlock(pos, spawn);
@@ -167,7 +167,7 @@ void FluidBlock::onPostTick()
                     ->placeBlock(getPos(),
                         StaticRegistry<BlockType>::INSTANCE
                             .zElement(BlockTypeEnum::AIR)
-                            ->createBlockAt(getPos(), 0));
+                            ->createBlockAt(getPos(), dimensionId, 0));
             }
             else
             {
@@ -270,9 +270,9 @@ Item* FluidBlockType::createItem() const
     return 0;
 }
 
-Block* FluidBlockType::createBlock(Framework::Vec3<int> position) const
+Block* FluidBlockType::createBlock(Framework::Vec3<int> position, int dimensionId) const
 {
-    FluidBlock* result = new FluidBlock(getId(), position);
+    FluidBlock* result = new FluidBlock(getId(), position, dimensionId);
     result->fluidAmount = 1000;
     return result;
 }

FactoryCraft/FluidBlock.h

@@ -20,7 +20,7 @@ protected:
     void broadcastAmount();
 
 public:
-    FluidBlock(int typeId, Framework::Vec3<int> pos);
+    FluidBlock(int typeId, Framework::Vec3<int> pos, int dimensionId);
     virtual ~FluidBlock();
 
     virtual void sendModelInfo(NetworkMessage* zMessage) override;
@@ -38,7 +38,7 @@ protected:
     virtual void saveSuperBlock(
         Block* zBlock, Framework::StreamWriter* zWriter) const override;
     virtual Item* createItem() const override;
-    virtual Block* createBlock(Framework::Vec3<int> position) const override;
+    virtual Block* createBlock(Framework::Vec3<int> position, int dimesionId) const override;
 
 public:
     FluidBlockType(int id, ModelInfo model, const char* name, int mapColor);

FactoryCraft/Game.cpp

@@ -4,6 +4,7 @@
 #include "AsynchronCall.h"
 #include "Entity.h"
 #include "EntityRemovedUpdate.h"
+#include "ItemEntity.h"
 #include "NetworkMessage.h"
 #include "NoBlock.h"
 #include "OverworldDimension.h"
@@ -114,7 +115,7 @@ void GameClient::thread()
 void GameClient::sendWorldUpdate(WorldUpdate* update)
 {
     bool add = 0;
-    if (zPlayer->getCurrentDimensionId() == update->getAffectedDimension())
+    if (zPlayer->getDimensionId() == update->getAffectedDimension())
     {
         auto pos = (Vec3<int>)zPlayer->getPosition();
         int dist = update->distanceTo(pos.x, pos.y);
@@ -151,7 +152,7 @@ void GameClient::reply()
         client->zForegroundWriter()->schreibe(
             (char*)&Message::POSITION_UPDATE, 1);
         client->zForegroundWriter()->schreibe((char*)&id, 4);
-        id = zPlayer->getCurrentDimensionId();
+        id = zPlayer->getDimensionId();
         client->zForegroundWriter()->schreibe((char*)&id, 4);
         foreground.unlock();
         first = 0;
@@ -385,11 +386,11 @@ void Game::thread()
                 pFile.close();
                 removed.add(index, 0);
                 Dimension* dim
-                    = zDimension(player->zEntity()->getCurrentDimensionId());
+                    = zDimension(player->zEntity()->getDimensionId());
                 dim->removeSubscriptions(player->zEntity());
                 this->requestWorldUpdate(
                     new EntityRemovedUpdate(player->zEntity()->getId(),
-                        player->zEntity()->getCurrentDimensionId(),
+                        player->zEntity()->getDimensionId(),
                         player->zEntity()->getPosition()));
             }
             index++;
@@ -486,12 +487,10 @@ void Game::api(Framework::InMemoryBuffer* zRequest, GameClient* zOrigin)
     {
     case 1: // world
         {
-            Dimension* dim
-                = zDimension(zOrigin->zEntity()->getCurrentDimensionId());
+            Dimension* dim = zDimension(zOrigin->zEntity()->getDimensionId());
             if (!dim)
             {
-                dim = new Dimension(
-                    zOrigin->zEntity()->getCurrentDimensionId());
+                dim = new Dimension(zOrigin->zEntity()->getDimensionId());
                 addDimension(dim);
             }
             dim->api(zRequest, response, zOrigin->zEntity());
@@ -697,12 +696,12 @@ GameClient* Game::addPlayer(FCKlient* client, Framework::Text name)
     GameClient* gameClient = new GameClient(player, client);
     gameClient->sendTypes();
     clients->add(gameClient);
-    if (!zDimension(player->getCurrentDimensionId()))
+    if (!zDimension(player->getDimensionId()))
     {
-        this->addDimension(new Dimension(player->getCurrentDimensionId()));
+        this->addDimension(new Dimension(player->getDimensionId()));
     }
     // subscribe the new player as an observer of the new chunk
-    Dimension* dim = zDimension(player->getCurrentDimensionId());
+    Dimension* dim = zDimension(player->getDimensionId());
     InMemoryBuffer* buffer = new InMemoryBuffer();
     buffer->schreibe("\0", 1);
     Punkt center = getChunkCenter(
@@ -733,12 +732,11 @@ GameClient* Game::addPlayer(FCKlient* client, Framework::Text name)
             b = zBlockAt({(int)player->getPosition().x,
                              (int)player->getPosition().y,
                              --h},
-                player->getCurrentDimensionId());
+                player->getDimensionId());
         player->setPosition(
             {player->getPosition().x, player->getPosition().y, (float)h + 1.f});
     }
-    requestWorldUpdate(
-        new AddEntityUpdate(player, player->getCurrentDimensionId()));
+    requestWorldUpdate(new AddEntityUpdate(player, player->getDimensionId()));
     chat->addObserver(gameClient->zEntity()->getId());
     chat->broadcastMessage(name + " joined the game.", Chat::CHANNEL_INFO);
     cs.unlock();
@@ -785,6 +783,25 @@ void Game::entityTargetChanged(Entity* zEntity)
     }
 }
 
+void Game::spawnItem(
+    Framework::Vec3<float> location, int dimensionId, Item* stack)
+{
+    spawnItem(location, dimensionId, new ItemStack(stack, 1));
+}
+
+void Game::spawnItem(
+    Framework::Vec3<float> location, int dimensionId, ItemStack* stack)
+{
+    ItemEntity* itemEntity
+        = (ItemEntity*)StaticRegistry<EntityType>::INSTANCE
+              .zElement(EntityTypeEnum::ITEM)
+              ->createEntity(
+                  location, dimensionId, Game::INSTANCE->getNextEntityId());
+    itemEntity->unsaveAddItem(stack, NO_DIRECTION, 0);
+    stack->release();
+    requestWorldUpdate(new AddEntityUpdate(itemEntity, dimensionId));
+}
+
 Framework::Either<Block*, int> Game::zBlockAt(
     Framework::Vec3<int> location, int dimension) const
 {

FactoryCraft/Game.h

@@ -11,13 +11,13 @@
 #include "Dimension.h"
 #include "InMemoryBuffer.h"
 #include "Player.h"
+#include "PlayerRegister.h"
 #include "RecipieLoader.h"
 #include "Server.h"
 #include "TickOrganizer.h"
 #include "WorldGenerator.h"
 #include "WorldLoader.h"
 #include "WorldUpdate.h"
-#include "PlayerRegister.h"
 
 class FCKlient;
 
@@ -116,6 +116,10 @@ public:
     bool doesChunkExist(int x, int y, int dimension);
     void blockTargetChanged(Block* zBlock);
     void entityTargetChanged(Entity* zEntity);
+    void spawnItem(
+        Framework::Vec3<float> location, int dimensionId, Item* stack);
+    void spawnItem(
+        Framework::Vec3<float> location, int dimensionId, ItemStack* stack);
     bool isChunkLoaded(int x, int y, int dimension) const;
     Framework::Either<Block*, int> zBlockAt(
         Framework::Vec3<int> location, int dimension) const;
@@ -141,7 +145,7 @@ public:
     Chat* zChat() const;
     Player* zPlayerByName(const char* name) const;
     int getPlayerId(const char* name) const;
-    
+
     double getAverageTickTime() const;
     int getTicksPerSecond() const;
     int getPlayerCount() const;

FactoryCraft/GeneratedStructure.cpp

@@ -61,7 +61,7 @@ bool GeneratedStructure::isBlockAffected(Framework::Vec3<int> location) const
 }
 
 Framework::Either<Block*, int> GeneratedStructure::generateBlockAt(
-    Framework::Vec3<int> location) const
+    Framework::Vec3<int> location, int dimensionId) const
 {
     Framework::Vec3<int> localPos = location - minAffectedPos;
     if (localPos.x >= 0 && localPos.y >= 0 && localPos.z >= 0
@@ -82,7 +82,8 @@ Framework::Either<Block*, int> GeneratedStructure::generateBlockAt(
                 Block* result
                     = StaticRegistry<BlockType>::INSTANCE
                           .zElement(blockIds[index])
-                          ->createBlockAt(minAffectedPos + localPos, 0);
+                          ->createBlockAt(
+                              minAffectedPos + localPos, dimensionId, 0);
                 if (result)
                 {
                     result->addToStructure(dynamic_cast<MultiblockStructure*>(

FactoryCraft/GeneratedStructure.h

@@ -30,7 +30,7 @@ public:
         Framework::Either<Block*, int> block, Framework::Vec3<int> localPos);
     bool isBlockAffected(Framework::Vec3<int> location) const;
     Framework::Either<Block*, int> generateBlockAt(
-        Framework::Vec3<int> location) const;
+        Framework::Vec3<int> location, int dimensionId) const;
     void addAllBlocksToStructure(MultiblockStructure* structure);
 
     Framework::Vec3<int> getOriginPos() const;

FactoryCraft/Grass.cpp

@@ -4,9 +4,11 @@
 #include "Game.h"
 #include "ItemEntity.h"
 
-GrassBlock::GrassBlock(
-    int typeId, const ItemType* zTool, Framework::Vec3<int> pos)
-    : Block(typeId, zTool, pos, 0)
+GrassBlock::GrassBlock(int typeId,
+    const ItemType* zTool,
+    Framework::Vec3<int> pos,
+    int dimensionId)
+    : Block(typeId, zTool, pos, dimensionId, 0)
 {
     tickSource = 1;
 }
@@ -107,7 +109,8 @@ Item* GrassBlockType::createItem() const
     return 0;
 }
 
-Block* GrassBlockType::createBlock(Framework::Vec3<int> position) const
+Block* GrassBlockType::createBlock(
+    Framework::Vec3<int> position, int dimensionId) const
 {
-    return new GrassBlock(getId(), zTool, position);
+    return new GrassBlock(getId(), zTool, position, dimensionId);
 }

FactoryCraft/Grass.h

@@ -7,7 +7,10 @@ class GrassBlockType;
 class GrassBlock : public Block
 {
 public:
-    GrassBlock(int typeId, const ItemType* zTool, Framework::Vec3<int> pos);
+    GrassBlock(int typeId,
+        const ItemType* zTool,
+        Framework::Vec3<int> pos,
+        int dimensionId);
     virtual bool onTick(
         TickQueue* zQueue, int numTicks, bool& blocked) override;
     virtual void onPostTick() override;
@@ -35,7 +38,8 @@ protected:
     virtual void saveSuperBlock(
         Block* zBlock, Framework::StreamWriter* zWriter) const override;
     virtual Item* createItem() const override;
-    virtual Block* createBlock(Framework::Vec3<int> position) const override;
+    virtual Block* createBlock(
+        Framework::Vec3<int> position, int dimensionId) const override;
 
 public:
     GrassBlockType(int typeId,

FactoryCraft/GrasslandBiom.cpp

@@ -48,8 +48,12 @@ GrasslandBiom::~GrasslandBiom()
     if (undergroundDirdNoise) undergroundDirdNoise->release();
 }
 
-Framework::Either<Block*, int> GrasslandBiom::generateAboveSurfaceBlock(
-    int x, int y, int z, int surfaceHeight, Chunk* partialGeneratedChunk)
+Framework::Either<Block*, int> GrasslandBiom::generateAboveSurfaceBlock(int x,
+    int y,
+    int z,
+    int dimensionId,
+    int surfaceHeight,
+    Chunk* partialGeneratedChunk)
 {
     int cx = x % CHUNK_SIZE;
     int cy = y % CHUNK_SIZE;
@@ -70,7 +74,7 @@ Framework::Either<Block*, int> GrasslandBiom::generateAboveSurfaceBlock(
 }
 
 Framework::Either<Block*, int> GrasslandBiom::generateSurfaceBlock(
-    int x, int y, int z)
+    int x, int y, int z, int dimensionId)
 {
     if (surfaceSandNoise->getNoise((double)x, (double)y, (double)z) < 0.35)
     {
@@ -85,7 +89,7 @@ Framework::Either<Block*, int> GrasslandBiom::generateSurfaceBlock(
 }
 
 Framework::Either<Block*, int> GrasslandBiom::generateBelowSurfaceBlock(
-    int x, int y, int z)
+    int x, int y, int z, int dimensionId)
 {
     if (undergroundDirdNoise->getNoise((double)x, (double)y, (double)z) < 0.35)
     {
@@ -100,16 +104,20 @@ Framework::Either<Block*, int> GrasslandBiom::generateBelowSurfaceBlock(
 }
 
 Framework::Either<Block*, int> GrasslandBiom::generateCaveBlock(
-    int x, int y, int z)
+    int x, int y, int z, int dimensionId)
 {
     return BlockTypeEnum::AIR;
 }
 
-Framework::Either<Block*, int> GrasslandBiom::generateUnderWaterBlock(
-    int x, int y, int z, int surfaceHeight, Chunk* partialGeneratedChunk)
+Framework::Either<Block*, int> GrasslandBiom::generateUnderWaterBlock(int x,
+    int y,
+    int z,
+    int dimensionId,
+    int surfaceHeight,
+    Chunk* partialGeneratedChunk)
 {
     return StaticRegistry<BlockType>::INSTANCE.zElement(BlockTypeEnum::WATER)
-        ->createBlockAt(Framework::Vec3<int>(x, y, z), 0);
+        ->createBlockAt(Framework::Vec3<int>(x, y, z), dimensionId, 0);
 }
 
 void GrasslandBiom::setSeed(int seed)

FactoryCraft/GrasslandBiom.h

@@ -19,17 +19,19 @@ public:
     Framework::Either<Block*, int> generateAboveSurfaceBlock(int x,
         int y,
         int z,
+        int dimensionId,
         int surfaceHeight,
         Chunk* partialGeneratedChunk) override;
     Framework::Either<Block*, int> generateSurfaceBlock(
-        int x, int y, int z) override;
+        int x, int y, int z, int dimensionId) override;
     Framework::Either<Block*, int> generateBelowSurfaceBlock(
-        int x, int y, int z) override;
+        int x, int y, int z, int dimensionId) override;
     Framework::Either<Block*, int> generateCaveBlock(
-        int x, int y, int z) override;
+        int x, int y, int z, int dimensionId) override;
     Framework::Either<Block*, int> generateUnderWaterBlock(int x,
         int y,
         int z,
+        int dimensionId,
         int surfaceHeight,
         Chunk* partialGeneratedChunk) override;
     Noise* zHeightMapNoise() override;

FactoryCraft/GrowingPlant.cpp

@@ -27,10 +27,11 @@ GrowthState& GrowthState::operator=(const GrowthState& right)
 GrowingPlantBlock::GrowingPlantBlock(int typeId,
     const ItemType* zTool,
     Framework::Vec3<int> pos,
+    int dimensionId,
     int maxTicks,
     const char* name,
     int blockTypeAfterGrowth)
-    : Block(typeId, zTool, pos, 0),
+    : Block(typeId, zTool, pos, dimensionId, 0),
       seblingTicks(0),
       seblingTicksMax(maxTicks),
       name(name),
@@ -185,11 +186,13 @@ Item* GrowingPlantBlockType::createItem() const
     return 0;
 }
 
-Block* GrowingPlantBlockType::createBlock(Framework::Vec3<int> position) const
+Block* GrowingPlantBlockType::createBlock(
+    Framework::Vec3<int> position, int dimensionId) const
 {
     GrowingPlantBlock* block = new GrowingPlantBlock(getId(),
         zTool,
         position,
+        dimensionId,
         ticksNeeded,
         readableName,
         blockTypeAfterGrowth);

FactoryCraft/GrowingPlant.h

@@ -30,6 +30,7 @@ public:
     GrowingPlantBlock(int typeId,
         const ItemType* zTool,
         Framework::Vec3<int> pos,
+        int dimensionId,
         int maxTicks,
         const char* name,
         int blockTypeAfterGrowth);
@@ -65,7 +66,8 @@ protected:
     virtual void saveSuperBlock(
         Block* zBlock, Framework::StreamWriter* zWriter) const override;
     virtual Item* createItem() const override;
-    virtual Block* createBlock(Framework::Vec3<int> position) const override;
+    virtual Block* createBlock(
+        Framework::Vec3<int> position, int dimensionId) const override;
 
 public:
     GrowingPlantBlockType(int typeId,

FactoryCraft/Inventory.cpp

@@ -248,9 +248,10 @@ void MultipleInventoryLock::lock()
     }
 }
 
-Inventory::Inventory(const Framework::Vec3<float> location, bool hasInventory)
+Inventory::Inventory(const Framework::Vec3<float> location, int dimensionId, bool hasInventory)
     : ReferenceCounter(),
       nextSlotId(1),
+      dimensionId(dimensionId),
       location(location)
 {
     if (hasInventory)
@@ -830,6 +831,16 @@ void Inventory::registerObserverAddedCall(
     observerAddedCalls.add(call);
 }
 
+int Inventory::getDimensionId() const
+{
+    return dimensionId;
+}
+
+Framework::Vec3<float> Inventory::getLocation() const
+{
+    return location;
+}
+
 bool Inventory::unsafeMove(Inventory* zSource,
     Inventory* zTarget,
     Iterator<ItemSlot*>& sourceSlot,

FactoryCraft/Inventory.h

@@ -75,6 +75,7 @@ private:
     void updateCache(ItemSlot* zSlot, int beforeKey);
 
 protected:
+    int dimensionId;
     Framework::Vec3<float> location;
 
     virtual bool allowPullStack(ItemSlot* zSlot, Direction dir) const;
@@ -94,7 +95,9 @@ protected:
     void unlock();
 
 public:
-    Inventory(const Framework::Vec3<float> location, bool hasInventory);
+    Inventory(const Framework::Vec3<float> location,
+        int dimensionId,
+        bool hasInventory);
     virtual ~Inventory();
     void notifyObservers(NetworkMessage* msg);
     const ItemSlot* zSlot(int id) const;
@@ -123,6 +126,8 @@ public:
             call);
     void registerObserverAddedCall(
         std::function<void(Entity* zSource, Framework::Text id)> call);
+    int getDimensionId() const;
+    Framework::Vec3<float> getLocation() const;
 
     friend InventoryInteraction;
     friend MultipleInventoryLock;

FactoryCraft/ItemEntity.cpp

@@ -31,7 +31,7 @@ void ItemEntity::prepareTick(const Dimension* zDimension)
     if (movements.getEintragAnzahl() <= 1)
     {
         Entity* zOther = Game::INSTANCE->zNearestEntity(
-            currentDimensionId, location, [this](Entity* zOther) {
+            dimensionId, location, [this](Entity* zOther) {
                 return zOther != this
                     && zOther->numberOfAddableItems(
                         slot->zStack(), NO_DIRECTION)
@@ -55,7 +55,7 @@ void ItemEntity::prepareTick(const Dimension* zDimension)
 void ItemEntity::tick(const Dimension* zDimension)
 {
     Entity* zOther = Game::INSTANCE->zNearestEntity(
-        currentDimensionId, location, [this](Entity* zOther) {
+        dimensionId, location, [this](Entity* zOther) {
             return zOther != this
                 && zOther->numberOfAddableItems(slot->zStack(), NO_DIRECTION)
                 && (!this->slot->isFull()

FactoryCraft/LightSources.cpp

@@ -49,8 +49,9 @@ LightSourceItemType* LightSourceItemType::setColor(int color)
     return this;
 }
 
-BasicLightSource::BasicLightSource(int typeId, Framework::Vec3<int> pos)
-    : Block(typeId, 0, pos, 0)
+BasicLightSource::BasicLightSource(
+    int typeId, Framework::Vec3<int> pos, int dimensionId)
+    : Block(typeId, 0, pos, dimensionId, 0)
 {}
 
 void BasicLightSource::setLight(int light)
@@ -121,9 +122,9 @@ void BasicLightSourceBlockType::saveSuperBlock(
 }
 
 Block* BasicLightSourceBlockType::createBlock(
-    Framework::Vec3<int> position) const
+    Framework::Vec3<int> position, int dimensionId) const
 {
-    return new BasicLightSource(getId(), position);
+    return new BasicLightSource(getId(), position, dimensionId);
 }
 
 Item* BasicLightSourceBlockType::createItem() const

FactoryCraft/LightSources.h

@@ -44,7 +44,7 @@ protected:
     void setLight(int light);
 
 public:
-    BasicLightSource(int typeId, Framework::Vec3<int> pos);
+    BasicLightSource(int typeId, Framework::Vec3<int> pos, int dimensionId);
     virtual bool onTick(
         TickQueue* zQueue, int numTicks, bool& blocked) override;
     virtual void onPostTick() override;
@@ -71,8 +71,10 @@ protected:
         Block* zBlock, Framework::StreamWriter* zWriter) const override;
 
 public:
-    BasicLightSourceBlockType(int typeId, int itemTypeId, ModelInfo model, const char *name);
-    virtual Block* createBlock(Framework::Vec3<int> position) const override;
+    BasicLightSourceBlockType(
+        int typeId, int itemTypeId, ModelInfo model, const char* name);
+    virtual Block* createBlock(
+        Framework::Vec3<int> position, int dimensionId) const override;
     virtual Item* createItem() const override;
     BasicLightSourceBlockType* setHardness(float hardness);
     BasicLightSourceBlockType* setColor(int color);

FactoryCraft/NetworkMessage.cpp

@@ -40,7 +40,7 @@ void NetworkMessage::addressEntity(const Entity* zEntity)
     addressLength = 10;
     address = new char[addressLength];
     address[0] = 1; // dimension response
-    *(int*)(address + 1) = zEntity->getCurrentDimensionId();
+    *(int*)(address + 1) = zEntity->getDimensionId();
     address[5] = 2; // entity
     *(int*)(address + 6) = zEntity->getId();
 }

FactoryCraft/NoBlock.cpp

@@ -5,7 +5,8 @@ NoBlockBlockType::NoBlockBlockType(int id, const Block* defaultB)
       defaultB(defaultB)
 {}
 
-Block* NoBlockBlockType::createBlock(Framework::Vec3<int> position) const
+Block* NoBlockBlockType::createBlock(
+    Framework::Vec3<int> position, int dimensionId) const
 {
     return 0;
 }
@@ -32,7 +33,7 @@ Item* NoBlockBlockType::getItemFromBlock(Block* zBlock) const
 }
 
 Block* NoBlockBlockType::createBlockAt(
-    Framework::Vec3<int> position, Item* zUsedItem) const
+    Framework::Vec3<int> position, int dimensionId, Item* zUsedItem) const
 {
     return 0;
 }
@@ -43,7 +44,7 @@ const Block* NoBlockBlockType::zDefault() const
 }
 
 NoBlock::NoBlock()
-    : Block(BlockTypeEnum::NO_BLOCK, 0, {0, 0, 0}, false)
+    : Block(BlockTypeEnum::NO_BLOCK, 0, {0, 0, 0}, 0, false)
 {
     transparent = 0;
     passable = 0;
@@ -62,7 +63,7 @@ void NoBlock::onPostTick() {}
 const NoBlock NoBlock::INSTANCE;
 
 AirBlock::AirBlock()
-    : Block(BlockTypeEnum::AIR, 0, {0, 0, 0}, false)
+    : Block(BlockTypeEnum::AIR, 0, {0, 0, 0}, 0, false)
 {
     transparent = 1;
     passable = 1;

FactoryCraft/NoBlock.h

@@ -9,7 +9,8 @@ private:
     const Block* defaultB;
 
 protected:
-    virtual Block* createBlock(Framework::Vec3<int> position) const override;
+    virtual Block* createBlock(
+        Framework::Vec3<int> position, int dimensionId) const override;
     virtual Item* createItem() const override;
     virtual Block* loadBlock(Framework::Vec3<int> position,
         Framework::StreamReader* zReader,
@@ -17,8 +18,9 @@ protected:
     virtual void saveBlock(
         Block* zBlock, Framework::StreamWriter* zWriter) const override;
     virtual Item* getItemFromBlock(Block* zBlock) const override;
-    virtual Block* createBlockAt(
-        Framework::Vec3<int> position, Item* zUsedItem) const override;
+    virtual Block* createBlockAt(Framework::Vec3<int> position,
+        int dimensionId,
+        Item* zUsedItem) const override;
     virtual const Block* zDefault() const override;
 
 public:

FactoryCraft/Player.cpp

@@ -39,7 +39,7 @@ Player::Player(Framework::Vec3<float> location, int dimensionId, int entityId)
 void Player::onTargetChange()
 {
     NetworkMessage* msg = new NetworkMessage();
-    ActionTarget::toMessage(zTarget(), getCurrentDimensionId(), msg);
+    ActionTarget::toMessage(zTarget(), dimensionId, msg);
     Game::INSTANCE->sendMessage(msg, this);
 }
 
@@ -105,7 +105,12 @@ void Player::useItemSlot(ItemSlot* zSlot, bool left)
                         addItems(oldItems, NO_DIRECTION, 0);
                         if (oldItems->getSize() > 0)
                         {
-                            // TODO: drop remaining items
+                            Game::INSTANCE->spawnItem(
+                                getLocation(), getDimensionId(), oldItems);
+                        }
+                        else
+                        {
+                            oldItems->release();
                         }
                     }
                     else
@@ -140,7 +145,9 @@ void Player::useItemSlot(ItemSlot* zSlot, bool left)
                             addItems(stack, NO_DIRECTION, 0);
                             if (stack->getSize() > 0)
                             {
-                                // TODO: drop remaining items
+                                Game::INSTANCE->spawnItem(getLocation(),
+                                    getDimensionId(),
+                                    dynamic_cast<ItemStack*>(stack->getThis()));
                             }
                         }
                     }
@@ -171,8 +178,7 @@ void Player::tick(const Dimension* zDimension)
     if ((keyState | Key::LEFT_HAND_ACTION) == keyState)
         useItemSlot(itemBar.get(leftHandPosition), true);
     if ((keyState | Key::RIGHT_HAND_ACTION) == keyState)
-        useItemSlot(
-            itemBar.get(leftHandPosition), false);
+        useItemSlot(itemBar.get(leftHandPosition), false);
     return Entity::tick(zDimension);
 }
 
@@ -225,9 +231,8 @@ void Player::playerApi(
             calculateTarget(frame.targetPosition,
                 frame.direction,
                 !itemBar.get(leftHandPosition)->isEmpty()
-                    ? itemBar.get(leftHandPosition)
-                    ->zStack()
-                    ->zItem() : 0);
+                    ? itemBar.get(leftHandPosition)->zStack()->zItem()
+                    : 0);
             break;
         }
     case 3:
@@ -277,7 +282,7 @@ void Player::playerApi(
             {
                 int id;
                 zRequest->lese((char*)&id, 4);
-                source = Game::INSTANCE->zEntity(id, getCurrentDimensionId());
+                source = Game::INSTANCE->zEntity(id, dimensionId);
             }
             else
             {
@@ -297,7 +302,7 @@ void Player::playerApi(
             {
                 int id;
                 zRequest->lese((char*)&id, 4);
-                target = Game::INSTANCE->zEntity(id, getCurrentDimensionId());
+                target = Game::INSTANCE->zEntity(id, dimensionId);
             }
             else
             {
@@ -330,7 +335,7 @@ void Player::playerApi(
                 int id;
                 zRequest->lese((char*)&id, 4);
                 target = dynamic_cast<BasicShapedCrafter*>(
-                    Game::INSTANCE->zEntity(id, getCurrentDimensionId()));
+                    Game::INSTANCE->zEntity(id, dimensionId));
             }
             else
             {

FactoryCraft/StaticInitializerOrder.cpp

@@ -3,11 +3,11 @@
 #include "StaticRegistry.h"
 // block types
 #include "BasicBlocks.h"
+#include "Chest.h"
 #include "Grass.h"
 #include "GrowingPlant.h"
 #include "NoBlock.h"
 #include "TreeSeblingBlock.h"
-#include "Chest.h"
 // fluid blocks
 #include "FluidBlock.h"
 // dimensions
@@ -72,10 +72,10 @@ void initializeBlockTypes()
          BlockTypeEnum::LEAVES_WOOD_OAK,
          ItemTypeEnum::LEAVES_WOOD_OAK,
          ModelInfo("cube", "blocks.ltdb/leaves.png", 6),
-         [](Vec3<int> pos) {
+         [](Vec3<int> pos, int dimensionId) {
              AdditionalItemSpawningBlock* block
                  = new AdditionalItemSpawningBlock(
-                     BlockTypeEnum::LEAVES_WOOD_OAK, 0, pos);
+                     BlockTypeEnum::LEAVES_WOOD_OAK, 0, pos, dimensionId);
              block->addSpawn({1, 1, 0.015, ItemTypeEnum::SEBLING_WOOD_OAK});
              return (Block*)block;
          },
@@ -116,10 +116,10 @@ void initializeBlockTypes()
          BlockTypeEnum::LEAVES_WOOD_BIRCH,
          ItemTypeEnum::LEAVES_WOOD_BIRCH,
          ModelInfo("cube", "blocks.ltdb/leaves.png", 6),
-         [](Vec3<int> pos) {
+         [](Vec3<int> pos, int dimensionId) {
              AdditionalItemSpawningBlock* block
                  = new AdditionalItemSpawningBlock(
-                     BlockTypeEnum::LEAVES_WOOD_BIRCH, 0, pos);
+                     BlockTypeEnum::LEAVES_WOOD_BIRCH, 0, pos, dimensionId);
              block->addSpawn({1, 1, 0.03, ItemTypeEnum::SEBLING_WOOD_BIRCH});
              return (Block*)block;
          },
@@ -139,10 +139,10 @@ void initializeBlockTypes()
          BlockTypeEnum::LEAVES_WOOD_BEECH,
          ItemTypeEnum::LEAVES_WOOD_BEECH,
          ModelInfo("cube", "blocks.ltdb/leaves.png", 6),
-         [](Vec3<int> pos) {
+         [](Vec3<int> pos, int dimensionId) {
              AdditionalItemSpawningBlock* block
                  = new AdditionalItemSpawningBlock(
-                     BlockTypeEnum::LEAVES_WOOD_BEECH, 0, pos);
+                     BlockTypeEnum::LEAVES_WOOD_BEECH, 0, pos, dimensionId);
              block->addSpawn({1, 1, 0.02, ItemTypeEnum::SEBLING_WOOD_BEECH});
              return (Block*)block;
          },
@@ -169,10 +169,10 @@ void initializeBlockTypes()
          BlockTypeEnum::LEAVES_WOOD_PINE,
          ItemTypeEnum::LEAVES_WOOD_PINE,
          ModelInfo("cube", "blocks.ltdb/leaves.png", 6),
-         [](Vec3<int> pos) {
+         [](Vec3<int> pos, int dimensionId) {
              AdditionalItemSpawningBlock* block
                  = new AdditionalItemSpawningBlock(
-                     BlockTypeEnum::LEAVES_WOOD_PINE, 0, pos);
+                     BlockTypeEnum::LEAVES_WOOD_PINE, 0, pos, dimensionId);
              block->addSpawn({1, 1, 0.025, ItemTypeEnum::SEBLING_WOOD_PINE});
              return (Block*)block;
          },
@@ -269,10 +269,10 @@ void initializeBlockTypes()
          BlockTypeEnum::WHEAT,
          ItemTypeEnum::WHEAT,
          ModelInfo("grass", "plants.ltdb/wheat.png", 16).setTransparent(),
-         [](Vec3<int> pos) {
+         [](Vec3<int> pos, int dimensionId) {
              AdditionalItemSpawningBlock* block
                  = new AdditionalItemSpawningBlock(
-                     BlockTypeEnum::WHEAT, 0, pos);
+                     BlockTypeEnum::WHEAT, 0, pos, dimensionId);
              block->addSpawn({0, 4, 1.0, ItemTypeEnum::WHEAT});
              return (Block*)block;
          },
@@ -296,15 +296,17 @@ void initializeBlockTypes()
          "Crafting Table",
          0xFFC4A783))
         ->initializeDefault(); // TODO: implement crafting table block type
-    (new BasicBlockType(BlockTypeEnum::CHEST,
+    (new BasicBlockType(
+         BlockTypeEnum::CHEST,
          ItemTypeEnum::CHEST,
-         ModelInfo(
-             "blocks.m3/chest", {"blocks.ltdb/chest.png", "blocks.ltdb/chestcover.png"}),
-         [](Framework::Vec3<int> pos) {
-             return new Chest(BlockTypeEnum::CHEST, 0, pos);
+         ModelInfo("blocks.m3/chest",
+             {"blocks.ltdb/chest.png", "blocks.ltdb/chestcover.png"}),
+         [](Framework::Vec3<int> pos, int dimensionId) {
+             return new Chest(BlockTypeEnum::CHEST, 0, pos, dimensionId);
          },
          "Chest",
-         0xFFE2C292, 1))
+         0xFFE2C292,
+         1))
         ->initializeDefault();
 }
 
@@ -620,8 +622,8 @@ void initializeItemTypes()
         "Chest",
         0,
         0,
-        ModelInfo(
-            "blocks.m3/chest", {"blocks.ltdb/chest.png", "blocks.ltdb/chestcover.png"}),
+        ModelInfo("blocks.m3/chest",
+            {"blocks.ltdb/chest.png", "blocks.ltdb/chestcover.png"}),
         BlockTypeEnum::CHEST));
 }
 

FactoryCraft/TreeSeblingBlock.cpp

@@ -9,9 +9,10 @@
 TreeSeblingBlock::TreeSeblingBlock(int typeId,
     const ItemType* zTool,
     Framework::Vec3<int> pos,
+    int dimensionId,
     const BlockType* wood,
     const BlockType* leaves)
-    : Block(typeId, zTool, pos, 0),
+    : Block(typeId, zTool, pos, dimensionId, 0),
       seblingTicks(0),
       seblingTicksMax(10000),
       wood(wood),
@@ -129,11 +130,13 @@ Item* TreeSeblingBlockType::createItem() const
     return StaticRegistry<ItemType>::INSTANCE.zElement(itemType)->createItem();
 }
 
-Block* TreeSeblingBlockType::createBlock(Framework::Vec3<int> position) const
+Block* TreeSeblingBlockType::createBlock(
+    Framework::Vec3<int> position, int dimensionId) const
 {
     return new TreeSeblingBlock(getId(),
         zTool,
         position,
+        dimensionId,
         StaticRegistry<BlockType>::INSTANCE.zElement(woodType),
         StaticRegistry<BlockType>::INSTANCE.zElement(leavesType));
 }

FactoryCraft/TreeSeblingBlock.h

@@ -16,6 +16,7 @@ public:
     TreeSeblingBlock(int typeId,
         const ItemType* zTool,
         Framework::Vec3<int> pos,
+        int dimensionId,
         const BlockType* wood,
         const BlockType* leaves);
     virtual bool onTick(
@@ -47,7 +48,7 @@ protected:
     virtual void saveSuperBlock(
         Block* zBlock, Framework::StreamWriter* zWriter) const override;
     virtual Item* createItem() const override;
-    virtual Block* createBlock(Framework::Vec3<int> position) const override;
+    virtual Block* createBlock(Framework::Vec3<int> position, int dimensionId) const override;
 
 public:
     TreeSeblingBlockType(int typeId,