remove unused includes

FactoryCraft/Animal.cpp

@@ -2,8 +2,6 @@
 
 #include "Dimension.h"
 #include "Game.h"
-#include "ItemEntity.h"
-#include "ItemStack.h"
 #include "TypeRegistry.h"
 
 Animal::Animal(

FactoryCraft/Animal.h

@@ -1,7 +1,6 @@
 #pragma once
 
 #include "AnimalAI.h"
-#include "BasicBlocks.h"
 #include "Entity.h"
 #include "EntityType.h"
 

FactoryCraft/BiomGenerator.cpp

@@ -1,10 +1,8 @@
 #include "BiomGenerator.h"
 
-#include "Constants.h"
-#include "Dimension.h"
+#include "Chunk.h"
 #include "Entity.h"
 #include "Game.h"
-#include "JNoise.h"
 
 BiomGenerator::BiomGenerator()
     : ReferenceCounter(),

FactoryCraft/BiomGenerator.h

@@ -6,7 +6,6 @@
 
 #include "EntityGenerator.h"
 #include "GeneratorRule.h"
-#include "JNoise.h"
 #include "JsonExpression.h"
 #include "PlantConfig.h"
 #include "StructureCollection.h"

FactoryCraft/Chunk.cpp

@@ -1,6 +1,5 @@
 #include "Chunk.h"
 
-#include <AsynchronCall.h>
 #include <InMemoryBuffer.h>
 #include <Logging.h>
 
@@ -10,7 +9,6 @@
 #include "EntityType.h"
 #include "FluidBlock.h"
 #include "Game.h"
-#include "NoBlock.h"
 #include "WorldGenerator.h"
 
 Chunk::Chunk(Framework::Punkt location, int dimensionId)

FactoryCraft/Chunk.h

@@ -1,7 +1,6 @@
 #pragma once
 
 #include <Array.h>
-#include <Datei.h>
 #include <Either.h>
 #include <Punkt.h>
 #include <Vec3.h>

FactoryCraft/Dimension.cpp

@@ -352,7 +352,7 @@ Chunk* Dimension::zChunk(Punkt wPos) const
 }
 
 Framework::Either<Block*, int> Dimension::zBlock(
-    Vec3<int> location, OUT Chunk** zChunk)
+    Vec3<int> location, OUT Chunk** zChunk) const
 {
     Chunk* c
         = this->zChunk(Game::INSTANCE->getChunkCenter(location.x, location.y));
@@ -368,7 +368,7 @@ Framework::Either<Block*, int> Dimension::zBlock(
     return 0;
 }
 
-Block* Dimension::zRealBlockInstance(Framework::Vec3<int> location)
+Block* Dimension::zRealBlockInstance(Framework::Vec3<int> location) const
 {
     Chunk* c = zChunk(Game::INSTANCE->getChunkCenter(location.x, location.y));
     if (c)
@@ -381,7 +381,7 @@ Block* Dimension::zRealBlockInstance(Framework::Vec3<int> location)
     return 0;
 }
 
-const Block* Dimension::zBlockOrDefault(Framework::Vec3<int> location)
+const Block* Dimension::zBlockOrDefault(Framework::Vec3<int> location) const
 {
     Chunk* c = zChunk(Game::INSTANCE->getChunkCenter(location.x, location.y));
     if (c)
@@ -392,7 +392,7 @@ const Block* Dimension::zBlockOrDefault(Framework::Vec3<int> location)
     return &NoBlock::INSTANCE;
 }
 
-int Dimension::getBlockType(Framework::Vec3<int> location)
+int Dimension::getBlockType(Framework::Vec3<int> location) const
 {
     Chunk* c = zChunk(Game::INSTANCE->getChunkCenter(location.x, location.y));
     if (c)
@@ -626,7 +626,7 @@ int Dimension::getDimensionId() const
     return dimensionId;
 }
 
-bool Dimension::hasChunck(int x, int y)
+bool Dimension::hasChunck(int x, int y) const
 {
     if (zChunk(Punkt(x, y))) return 1;
     removedChunksCs.lock();
@@ -720,7 +720,7 @@ Entity* Dimension::zEntity(int id) const
 }
 
 Entity* Dimension::zNearestEntity(
-    Framework::Vec3<float> pos, std::function<bool(Entity*)> filter)
+    Framework::Vec3<float> pos, std::function<bool(Entity*)> filter) const
 {
     Entity* result = 0;
     float sqDist = 0;
@@ -970,7 +970,7 @@ void Dimension::updateMap(int x, int y, int height)
     chunkCs.unlock();
 }
 
-int Dimension::getChunkCount()
+int Dimension::getChunkCount() const
 {
     return chunkList.getEintragAnzahl();
 }

FactoryCraft/Dimension.h

@@ -48,7 +48,7 @@ private:
     Framework::Critical prioLightCs;
     Framework::Critical structurCs;
     Framework::RCArray<Chunk> removedChunks;
-    Framework::Critical removedChunksCs;
+    mutable Framework::Critical removedChunksCs;
     Framework::RCArray<MultiblockStructure> structures;
     MultiblockStructureManager* structureManager;
     DimensionMap* map;
@@ -77,10 +77,10 @@ public:
     void thread() override;
 
     Framework::Either<Block*, int> zBlock(
-        Framework::Vec3<int> location, OUT Chunk** zChunk);
-    Block* zRealBlockInstance(Framework::Vec3<int> location);
-    const Block* zBlockOrDefault(Framework::Vec3<int> location);
-    int getBlockType(Framework::Vec3<int> location);
+        Framework::Vec3<int> location, OUT Chunk** zChunk) const;
+    Block* zRealBlockInstance(Framework::Vec3<int> location) const;
+    const Block* zBlockOrDefault(Framework::Vec3<int> location) const;
+    int getBlockType(Framework::Vec3<int> location) const;
     void placeBlock(
         Framework::Vec3<int> location, Framework::Either<Block*, int> block);
     void sendBlockInfo(Framework::Vec3<int> location);
@@ -88,14 +88,14 @@ public:
     void setChunk(Chunk* chunk, Framework::Punkt center);
     void save(Framework::Text worldDir) const;
     int getDimensionId() const;
-    bool hasChunck(int x, int y);
+    bool hasChunck(int x, int y) const;
     bool reviveChunk(int x, int y);
     Chunk* zChunk(Framework::Punkt wPos) const;
     float getGravity() const;
     void removeOldChunks();
     Entity* zEntity(int id) const;
     Entity* zNearestEntity(
-        Framework::Vec3<float> pos, std::function<bool(Entity*)> filter);
+        Framework::Vec3<float> pos, std::function<bool(Entity*)> filter) const;
     void removeEntity(int id);
     void removeSubscriptions(Entity* zEntity);
     void updateLightning(Framework::Vec3<int> location);
@@ -108,7 +108,7 @@ public:
     MultiblockStructure* zStructureById(__int64 id);
     void requestStopAndWait();
     void updateMap(int x, int y, int height);
-    int getChunkCount();
+    int getChunkCount() const;
     double getCurrentDayTime() const;
     double getNightDuration() const;
     double getNightTransitionDuration() const;

FactoryCraft/DimensionGenerator.cpp

@@ -1,13 +1,9 @@
 #include "DimensionGenerator.h"
 
-#include <iostream>
-#include <Logging.h>
-#include <Zeit.h>
-
+#include "BiomGenerator.h"
 #include "Constants.h"
 #include "Dimension.h"
 #include "Game.h"
-#include "NoBlock.h"
 #include "Noise.h"
 #include "RandNoise.h"
 #include "WormCaveGenerator.h"
@@ -135,7 +131,7 @@ void DimensionGenerator::calculateHeightLayers()
     }
 }
 
-Dimension* DimensionGenerator::createDimension()
+Dimension* DimensionGenerator::createDimension() const
 {
     return new Dimension(getId());
 }

FactoryCraft/DimensionGenerator.h

@@ -7,7 +7,7 @@
 #include "BiomGenerator.h"
 #include "CaveGenerator.h"
 #include "Chunk.h"
-#include "JNoise.h"
+#include "GeneratorTemplate.h"
 #include "JsonExpression.h"
 
 // #define CHUNK_GENERATION_DEBUG_LOG to log generation times of chunks
@@ -71,7 +71,7 @@ protected:
     void calculateHeightLayers();
 
 public:
-    Dimension* createDimension();
+    Dimension* createDimension() const;
     virtual void initialize(int worldSeed);
     virtual Chunk* generateChunk(int centerX, int centerY) = 0;
     virtual void postprocessChunk(Chunk* zChunk) = 0;
@@ -164,8 +164,6 @@ protected:
     virtual S* createValue(Framework::JSON::JSONObject* zJson) const = 0;
 };
 
-class BiomGenerator;
-
 class BiomedCavedDimensionGenerator : public DimensionGenerator
 {
 private:

FactoryCraft/Entity.cpp

@@ -8,7 +8,6 @@
 #include "Game.h"
 #include "ItemSkill.h"
 #include "ItemStack.h"
-#include "NoBlock.h"
 
 ActionTarget::ActionTarget(Framework::Vec3<int> blockPos, Direction blockSide)
     : blockPos(blockPos),

FactoryCraft/Entity.h

@@ -1,13 +1,10 @@
 #pragma once
 
 #include <Maybe.h>
-#include <ReferenceCounter.h>
-#include <Vec2.h>
 #include <Vec3.h>
 #include <Writer.h>
 #include <Zeit.h>
 
-#include "Effect.h"
 #include "Inventory.h"
 #include "ItemSkill.h"
 #include "ModelInfo.h"

FactoryCraft/Game.cpp

@@ -2,7 +2,6 @@
 
 #include <Logging.h>
 
-#include "AsynchronCall.h"
 #include "Chat.h"
 #include "Dimension.h"
 #include "Entity.h"
@@ -916,21 +915,23 @@ Framework::Either<Block*, int> Game::zBlockAt(
     return 0;
 }
 
-Block* Game::zRealBlockInstance(Framework::Vec3<int> location, int dimension)
+Block* Game::zRealBlockInstance(
+    Framework::Vec3<int> location, int dimension) const
 {
     Dimension* dim = zDimension(dimension);
     if (dim) return dim->zRealBlockInstance(location);
     return 0;
 }
 
-const Block* Game::zConstBlock(Framework::Vec3<int> location, int dimension)
+const Block* Game::zConstBlock(
+    Framework::Vec3<int> location, int dimension) const
 {
     Dimension* dim = zDimension(dimension);
     if (dim) return dim->zBlockOrDefault(location);
     return 0;
 }
 
-int Game::getBlockType(Framework::Vec3<int> location, int dimension)
+int Game::getBlockType(Framework::Vec3<int> location, int dimension) const
 {
     Dimension* dim = zDimension(dimension);
     if (dim) return dim->getBlockType(location);
@@ -1051,7 +1052,7 @@ Entity* Game::zEntity(int id) const
 
 Entity* Game::zNearestEntity(int dimensionId,
     Framework::Vec3<float> pos,
-    std::function<bool(Entity*)> filter)
+    std::function<bool(Entity*)> filter) const
 {
     Dimension* d = zDimension(dimensionId);
     if (!d) return 0;

FactoryCraft/Game.h

@@ -4,14 +4,12 @@
 #include <Critical.h>
 #include <Either.h>
 #include <InMemoryBuffer.h>
-#include <Network.h>
 #include <Punkt.h>
 #include <Text.h>
 #include <Thread.h>
 
 #include "Area.h"
 #include "BlockTypeNameFactory.h"
-#include "Constants.h"
 #include "GameClient.h"
 #include "ItemTypeNameFactory.h"
 #include "NetworkMessage.h"
@@ -101,9 +99,11 @@ public:
     bool isChunkLoaded(int x, int y, int dimension) const;
     Framework::Either<Block*, int> zBlockAt(
         Framework::Vec3<int> location, int dimension, OUT Chunk** zChunk) const;
-    Block* zRealBlockInstance(Framework::Vec3<int> location, int dimension);
-    const Block* zConstBlock(Framework::Vec3<int> location, int dimension);
-    int getBlockType(Framework::Vec3<int> location, int dimension);
+    Block* zRealBlockInstance(
+        Framework::Vec3<int> location, int dimension) const;
+    const Block* zConstBlock(
+        Framework::Vec3<int> location, int dimension) const;
+    int getBlockType(Framework::Vec3<int> location, int dimension) const;
     Dimension* zDimension(int id) const;
     static Framework::Punkt getChunkCenter(int x, int y);
     Area getChunckArea(Framework::Punkt center) const;
@@ -118,7 +118,7 @@ public:
     Entity* zEntity(int id) const;
     Entity* zNearestEntity(int dimensionId,
         Framework::Vec3<float> pos,
-        std::function<bool(Entity*)> filter);
+        std::function<bool(Entity*)> filter) const;
     RecipieLoader* zRecipies() const;
     void doLater(std::function<void()> action);
     TickOrganizer* zTickOrganizer() const;

FactoryCraft/NeutralAnimalAI.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#include "Animal.h"
+#include "AnimalAI.h"
 
 class NeutralAnimalAI : public AnimalAI
 {};

FactoryCraft/Player.cpp

@@ -6,7 +6,6 @@
 #include "Game.h"
 #include "ItemFilter.h"
 #include "ItemStack.h"
-#include "PlayerHand.h"
 #include "QuestDialog.h"
 #include "UIController.h"
 

FactoryCraft/Server.cpp

@@ -2,10 +2,7 @@
 
 #include <AsynchronCall.h>
 #include <Globals.h>
-#include <HttpRequest.h>
 #include <iostream>
-#include <JSON.h>
-#include <Klient.h>
 #include <Logging.h>
 
 #include "PlayerRegister.h"

FactoryCraft/Start.cpp

@@ -1,31 +1,26 @@
 #include <csignal>
 #include <cstdlib>
 #include <Datei.h>
-#include <fstream>
 #include <Globals.h>
 #include <iostream>
-#include <Klient.h>
 #ifndef _WINDOWS
 #    include <sys/resource.h>
 #else
 #    define NO_MAIN
 #    include <main.h>
 #endif
-#include <AsynchronCall.h>
 #include <Console.h>
 #include <Logging.h>
 #include <Text.h>
 #include <Zeit.h>
 
-#include "Chat.h"
-#include "ChunkMap.h"
 #include "Server.h"
 #include "WorldGenerator.h"
 
 FactoryCraftServer* mserver = 0;
 
 #ifdef _WINDOWS
-LONG WINAPI exceptionHandler(struct _EXCEPTION_POINTERS* apExceptionInfo)
+static LONG WINAPI exceptionHandler(struct _EXCEPTION_POINTERS* apExceptionInfo)
 {
     Sleep(10000);
     Logging::error() << "Creating dump";
@@ -41,7 +36,7 @@ LONG WINAPI exceptionHandler(struct _EXCEPTION_POINTERS* apExceptionInfo)
 }
 #endif
 
-void onError(int i)
+static void onError(int i)
 {
     Sleep(10000);
     Logging::error() << "Creating dump";
@@ -55,7 +50,7 @@ void onError(int i)
     }
 }
 
-void onExit()
+static void onExit()
 {
     Sleep(10000);
     Logging::info() << "Programm exited";

FactoryCraft/TypeRegistry.cpp

@@ -13,7 +13,6 @@
 #include "Chest.h"
 #include "DefaultBlockItemDrop.h"
 #include "DefaultInventoryDrop.h"
-#include "Dimension.h"
 #include "DimensionGenerator.h"
 #include "DropChanceCondition.h"
 #include "DropConditionOperator.h"
@@ -21,7 +20,6 @@
 #include "FireBasedProcessingBlockComponent.h"
 #include "FluidBlock.h"
 #include "FluidContainer.h"
-#include "GeneratorRule.h"
 #include "Grass.h"
 #include "GrowingPlant.h"
 #include "ItemSlot.h"

FactoryCraft/WorldGenerator.cpp

@@ -1,13 +1,12 @@
 #include "WorldGenerator.h"
 
-#include <Betriebssystem.h>
+#include <Datei.h>
 #include <functional>
 #include <Logging.h>
 
 #include "Dimension.h"
 #include "Game.h"
 #include "JsonUtils.h"
-#include "NoiseInterpolator.h"
 
 using namespace Framework;
 using namespace Framework::JSON;
@@ -211,7 +210,7 @@ bool WorldGenerator::spawnStructure(Framework::Vec3<int> location,
     return zGenerator(dimensionId)->spawnStructure(location, filter);
 }
 
-double WorldGenerator::getGeneratedChunksPerSecond()
+double WorldGenerator::getGeneratedChunksPerSecond() const
 {
     return chunksPerSecond;
 }

FactoryCraft/WorldGenerator.h

@@ -33,5 +33,5 @@ public:
     bool spawnStructure(Framework::Vec3<int> location,
         int dimensionId,
         std::function<bool(GeneratorTemplate* tmpl)> filter);
-    double getGeneratedChunksPerSecond();
+    double getGeneratedChunksPerSecond() const;
 };

FactoryCraft/WorldLoader.cpp

@@ -6,7 +6,6 @@
 #include <Text.h>
 
 #include "Dimension.h"
-#include "Entity.h"
 #include "EntityType.h"
 #include "Game.h"
 #include "WorldGenerator.h"
@@ -83,10 +82,10 @@ void WorldLoader::thread()
         int xDir = start.x > end.x ? -1 : 1;
         int yDir = start.y > end.y ? -1 : 1;
         for (int x = start.x; xDir < 0 ? x >= end.x : x <= end.x;
-             x += CHUNK_SIZE * xDir)
+            x += CHUNK_SIZE * xDir)
         {
             for (int y = start.y; yDir < 0 ? y >= end.y : y <= end.y;
-                 y += CHUNK_SIZE * yDir)
+                y += CHUNK_SIZE * yDir)
             {
                 Dimension* zDim = Game::INSTANCE->zDimension(next.dimensionId);
                 bool revived = 0;