adjust to framework changes

FactoryCraft/BasicBlocks.cpp

@@ -84,7 +84,7 @@ void BasicBlock::getLightEmisionColor(unsigned char* result) const
 
 TickSourceType BasicBlock::isTickSource() const
 {
-    return components.getEintragAnzahl() > 0 ? TickSourceType::EACH_TICK
+    return components.getEntryCount() > 0 ? TickSourceType::EACH_TICK
                                              : TickSourceType::NONE;
 }
 
@@ -98,8 +98,8 @@ void BasicBlock::onApiCall(char messageType,
     case 2: // component request
         {
             int index;
-            zRequest->lese((char*)&index, sizeof(int));
-            if (index >= 0 && index < components.getEintragAnzahl())
+            zRequest->read((char*)&index, sizeof(int));
+            if (index >= 0 && index < components.getEntryCount())
             {
                 components.z(index)->api(zRequest, zResponse, zSource);
             }
@@ -168,7 +168,7 @@ Block* BasicBlockType::createBlock(
     Framework::Vec3<int> position, int dimensionId) const
 {
     return new BasicBlock(
-        getId(), position, dimensionId, itemSlots.getEintragAnzahl() > 0);
+        getId(), position, dimensionId, itemSlots.getEntryCount() > 0);
 }
 
 Item* BasicBlockType::createItem() const
@@ -187,7 +187,7 @@ Framework::Text BasicBlockType::getItemTypeName() const
 
 ItemType* BasicBlockType::createItemTypeInternal() const
 {
-    if (getItemTypeName().istGleich(""))
+    if (getItemTypeName().isEqual(""))
     {
         return 0;
     }

FactoryCraft/BasicBlocks.h

@@ -134,7 +134,7 @@ public:
     {
         Framework::JSON::JSONObject* result
             = BlockTypeFactoryBase<T>::toJsonObject(zObject);
-        if (zObject->getItemTypeName().istGleich(""))
+        if (zObject->getItemTypeName().isEqual(""))
         {
             result->addValue("itemType", new Framework::JSON::JSONValue());
         }

FactoryCraft/BasicTool.cpp

@@ -224,11 +224,11 @@ void BasicToolItemType::loadSuperItem(
 {
     BasicToolItem* item = dynamic_cast<BasicToolItem*>(zItem);
     float data;
-    zReader->lese((char*)&data, 4);
+    zReader->read((char*)&data, 4);
     item->setHeadMaterialHardness(data);
-    zReader->lese((char*)&data, 4);
+    zReader->read((char*)&data, 4);
     item->setRodMaterialHardness(data);
-    zReader->lese((char*)&data, 4);
+    zReader->read((char*)&data, 4);
     item->setHandleMaterialHardness(data);
     ItemType::loadSuperItem(item, zReader);
 }
@@ -238,11 +238,11 @@ void BasicToolItemType::saveSuperItem(
 {
     const BasicToolItem* item = dynamic_cast<const BasicToolItem*>(zItem);
     float data = item->getHeadMaterialHardness();
-    zWriter->schreibe((char*)&data, 4);
+    zWriter->write((char*)&data, 4);
     data = item->getRodMaterialHardness();
-    zWriter->schreibe((char*)&data, 4);
+    zWriter->write((char*)&data, 4);
     data = item->getHandleMaterialHardness();
-    zWriter->schreibe((char*)&data, 4);
+    zWriter->write((char*)&data, 4);
     ItemType::saveSuperItem(item, zWriter);
 }
 
@@ -284,17 +284,17 @@ void BasicToolItemType::setItemAttribute(
     Item* zItem, Framework::Text name, Framework::JSON::JSONValue* zValue) const
 {
     BasicToolItem* item = dynamic_cast<BasicToolItem*>(zItem);
-    if (name.istGleich("headMaterialHardness")
+    if (name.isEqual("headMaterialHardness")
         && zValue->getType() == Framework::AbstractType::NUMBER)
     {
         item->setHeadMaterialHardness((float)zValue->asNumber()->getNumber());
     }
-    else if (name.istGleich("rodMaterialHardness")
+    else if (name.isEqual("rodMaterialHardness")
              && zValue->getType() == Framework::AbstractType::NUMBER)
     {
         item->setRodMaterialHardness((float)zValue->asNumber()->getNumber());
     }
-    else if (name.istGleich("handleMaterialHardness")
+    else if (name.isEqual("handleMaterialHardness")
              && zValue->getType() == Framework::AbstractType::NUMBER)
     {
         item->setHandleMaterialHardness((float)zValue->asNumber()->getNumber());
@@ -911,13 +911,13 @@ BlockReplaceItemSkill::~BlockReplaceItemSkill()
 
 void BlockReplaceItemSkill::load(Framework::StreamReader* zReader)
 {
-    zReader->lese((char*)&cooldownTicks, 4);
+    zReader->read((char*)&cooldownTicks, 4);
     ItemSkill::load(zReader);
 }
 
 void BlockReplaceItemSkill::save(Framework::StreamWriter* zWriter)
 {
-    zWriter->schreibe((char*)&cooldownTicks, 4);
+    zWriter->write((char*)&cooldownTicks, 4);
     ItemSkill::save(zWriter);
 }
 

FactoryCraft/BiomGenerator.cpp

@@ -166,7 +166,7 @@ void BiomGenerator::addTemplate(StructureTemplateCollection* collection)
     templates.add(collection);
     Framework::Vec3<int> min = collection->getMinAffected();
     Framework::Vec3<int> max = collection->getMaxAffected();
-    if (templates.getEintragAnzahl())
+    if (templates.getEntryCount())
     {
         minStructureOffset = min;
         maxStructureOffset = max;

FactoryCraft/Block.cpp

@@ -86,7 +86,7 @@ void Block::onDestroy(Entity* zActor, Item* zUsedItem, ItemSkill* zUsedSkill)
         }
         else
         {
-            if (structures.getEintragAnzahl() > 0)
+            if (structures.getEntryCount() > 0)
             { // replace this block in the structures
                 Block* zReplacement = block.isA()
                                         ? block.getA()
@@ -262,7 +262,7 @@ void Block::api(Framework::StreamReader* zRequest,
     Entity* zSource)
 {
     char id = 0;
-    zRequest->lese(&id, 1);
+    zRequest->read(&id, 1);
     switch (id)
     {
     case 0:
@@ -272,9 +272,9 @@ void Block::api(Framework::StreamReader* zRequest,
     case 1: // dialog closed
         {
             short nameLen;
-            zRequest->lese((char*)&nameLen, 2);
+            zRequest->read((char*)&nameLen, 2);
             char* name = new char[nameLen + 1];
-            zRequest->lese(name, nameLen);
+            zRequest->read(name, nameLen);
             name[nameLen] = 0;
             onDialogClosed(name);
             delete[] name;
@@ -395,7 +395,7 @@ void Block::updateModel(ModelInfo* zInfo) const
             zInfo->writeTo(&buffer);
             char* msg = new char[(int)buffer.getSize() + 1];
             msg[0] = 1; // hmodel change
-            buffer.lese(msg + 1, (int)buffer.getSize());
+            buffer.read(msg + 1, (int)buffer.getSize());
             changeMsg->setMessage(msg, (int)buffer.getSize() + 1);
             zChunk->notifyObservers(changeMsg);
         }
@@ -569,11 +569,11 @@ void BasicBlockItemType::loadSuperItem(
     if (!item)
         throw "BasicBlockItemType::loadSuperItem was called with an invalid "
               "item";
-    zReader->lese((char*)&item->transparent, 1);
-    zReader->lese((char*)&item->passable, 1);
-    zReader->lese((char*)&item->hardness, 4);
-    zReader->lese((char*)&item->speedModifier, 4);
-    zReader->lese((char*)&item->interactable, 1);
+    zReader->read((char*)&item->transparent, 1);
+    zReader->read((char*)&item->passable, 1);
+    zReader->read((char*)&item->hardness, 4);
+    zReader->read((char*)&item->speedModifier, 4);
+    zReader->read((char*)&item->interactable, 1);
 }
 
 void BasicBlockItemType::saveSuperItem(
@@ -584,11 +584,11 @@ void BasicBlockItemType::saveSuperItem(
     if (!item)
         throw "BasicBlockItemType::saveSuperItem was called with an invalid "
               "item";
-    zWriter->schreibe((char*)&item->transparent, 1);
-    zWriter->schreibe((char*)&item->passable, 1);
-    zWriter->schreibe((char*)&item->hardness, 4);
-    zWriter->schreibe((char*)&item->speedModifier, 4);
-    zWriter->schreibe((char*)&item->interactable, 1);
+    zWriter->write((char*)&item->transparent, 1);
+    zWriter->write((char*)&item->passable, 1);
+    zWriter->write((char*)&item->hardness, 4);
+    zWriter->write((char*)&item->speedModifier, 4);
+    zWriter->write((char*)&item->interactable, 1);
 }
 
 Item* BasicBlockItemType::createItem() const

FactoryCraft/BlockFilter.cpp

@@ -291,7 +291,7 @@ bool BlockFilterTypeGroup::test(const Block* zBlock) const
         for (Framework::Text* otherGroupName :
             zBlock->zBlockType()->getGroupNames())
         {
-            if (groupName->istGleich(*otherGroupName))
+            if (groupName->isEqual(*otherGroupName))
             {
                 return true;
             }

FactoryCraft/BlockType.cpp

@@ -35,20 +35,20 @@ void BlockType::loadSuperBlock(
     Block* zBlock, Framework::StreamReader* zReader, int dimensionId) const
 {
     zBlock->loadInventory(zReader);
-    zReader->lese((char*)&zBlock->transparent, 1);
-    zReader->lese((char*)&zBlock->passable, 1);
-    zReader->lese((char*)&zBlock->hp, 4);
-    zReader->lese((char*)&zBlock->maxHP, 4);
-    zReader->lese((char*)&zBlock->hardness, 4);
-    zReader->lese((char*)&zBlock->speedModifier, 4);
-    zReader->lese((char*)&zBlock->mapColor, 4);
-    zReader->lese((char*)&zBlock->interactable, 1);
+    zReader->read((char*)&zBlock->transparent, 1);
+    zReader->read((char*)&zBlock->passable, 1);
+    zReader->read((char*)&zBlock->hp, 4);
+    zReader->read((char*)&zBlock->maxHP, 4);
+    zReader->read((char*)&zBlock->hardness, 4);
+    zReader->read((char*)&zBlock->speedModifier, 4);
+    zReader->read((char*)&zBlock->mapColor, 4);
+    zReader->read((char*)&zBlock->interactable, 1);
     int strCount;
-    zReader->lese((char*)&strCount, 4);
+    zReader->read((char*)&strCount, 4);
     for (int i = 0; i < strCount; i++)
     {
         __int64 id;
-        zReader->lese((char*)&id, 8);
+        zReader->read((char*)&id, 8);
         MultiblockStructure* str
             = Game::INSTANCE->zDimension(dimensionId)->zStructureById(id);
         if (str)
@@ -63,20 +63,20 @@ void BlockType::saveSuperBlock(
     Block* zBlock, Framework::StreamWriter* zWriter) const
 {
     zBlock->saveInventory(zWriter);
-    zWriter->schreibe((char*)&zBlock->transparent, 1);
-    zWriter->schreibe((char*)&zBlock->passable, 1);
-    zWriter->schreibe((char*)&zBlock->hp, 4);
-    zWriter->schreibe((char*)&zBlock->maxHP, 4);
-    zWriter->schreibe((char*)&zBlock->hardness, 4);
-    zWriter->schreibe((char*)&zBlock->speedModifier, 4);
-    zWriter->schreibe((char*)&zBlock->mapColor, 4);
-    zWriter->schreibe((char*)&zBlock->interactable, 1);
-    int strCount = zBlock->structures.getEintragAnzahl();
-    zWriter->schreibe((char*)&strCount, 4);
+    zWriter->write((char*)&zBlock->transparent, 1);
+    zWriter->write((char*)&zBlock->passable, 1);
+    zWriter->write((char*)&zBlock->hp, 4);
+    zWriter->write((char*)&zBlock->maxHP, 4);
+    zWriter->write((char*)&zBlock->hardness, 4);
+    zWriter->write((char*)&zBlock->speedModifier, 4);
+    zWriter->write((char*)&zBlock->mapColor, 4);
+    zWriter->write((char*)&zBlock->interactable, 1);
+    int strCount = zBlock->structures.getEntryCount();
+    zWriter->write((char*)&strCount, 4);
     for (MultiblockStructure* structure : zBlock->structures)
     {
         __int64 id = structure->getStructureId();
-        zWriter->schreibe((char*)&id, 8);
+        zWriter->write((char*)&id, 8);
     }
 }
 
@@ -158,20 +158,20 @@ int BlockType::getItemTypeId() const
 void BlockType::writeTypeInfo(StreamWriter* zWriter) const
 {
     int id = getId();
-    zWriter->schreibe((char*)&id, 4);
+    zWriter->write((char*)&id, 4);
     bool inst = doesNeedClientInstance();
-    zWriter->schreibe((char*)&inst, 1);
+    zWriter->write((char*)&inst, 1);
     bool sub = doesNeedModelSubscription();
-    zWriter->schreibe((char*)&sub, 1);
+    zWriter->write((char*)&sub, 1);
     bool fluid = isFluid();
-    zWriter->schreibe((char*)&fluid, 1);
+    zWriter->write((char*)&fluid, 1);
     if (fluid)
     {
         char flowDist = getFlowDistance();
-        zWriter->schreibe(&flowDist, 1);
+        zWriter->write(&flowDist, 1);
     }
     int maxHp = getInitialMaxHP();
-    zWriter->schreibe((char*)&maxHp, 4);
+    zWriter->write((char*)&maxHp, 4);
     zModel()->writeTo(zWriter);
 }
 
@@ -351,7 +351,7 @@ int BlockType::getTypeId(const char* name)
     for (int i = 0; i < Game::INSTANCE->getBlockTypeCount(); i++)
     {
         if (Game::INSTANCE->zBlockType(i)
-            && n.istGleich(Game::INSTANCE->zBlockType(i)->getName()))
+            && n.isEqual(Game::INSTANCE->zBlockType(i)->getName()))
             return Game::INSTANCE->zBlockType(i)->getId();
     }
     return 0;

FactoryCraft/Chat.cpp

@@ -1,6 +1,6 @@
 #include "Chat.h"
 
-#include <Datei.h>
+#include <File.h>
 #include <Logging.h>
 
 #include "Game.h"
@@ -14,11 +14,10 @@ Chat::Chat()
     : ReferenceCounter(),
       commandExecutor(new ChatCommandExecutor())
 {
-    Framework::Datei messageData;
-    messageData.setDatei(
+    Framework::File messageData;
+    messageData.setFile(
         Game::INSTANCE->getWorldDirectory() + "/chat/history.chat");
-    if (messageData.existiert()
-        && messageData.open(Framework::Datei::Style::lesen))
+    if (messageData.exists() && messageData.open(Framework::File::Style::read))
     {
         Framework::Logging::info()
             << "loading chat history from " << messageData.zPfad()->getText()
@@ -26,7 +25,7 @@ Chat::Chat()
                "'/resetChat [channel] [timestamp]' command."; // TODO: implement
                                                               // /resetChat
                                                               // command
-        while (!messageData.istEnde())
+        while (!messageData.isEnd())
         {
             ChatMessage* message = new ChatMessage(&messageData);
             history.add(message);
@@ -56,8 +55,7 @@ void Chat::addMessage(ChatMessage* message)
         }
         if (it->isSubscribedTo(message->getChannel())
             && (!message->getTargetPlayerName().getLength()
-                || it->getPlayerName().istGleich(
-                    message->getTargetPlayerName())))
+                || it->getPlayerName().isEqual(message->getTargetPlayerName())))
         {
             Entity* zEtity = Game::INSTANCE->zEntity(it->getEntityId());
             if (zEtity)
@@ -82,7 +80,7 @@ void Chat::addObserver(int entityId)
     {
         if (obs->isSubscribedTo(msg->getChannel())
             && (!msg->getTargetPlayerName().getLength()
-                || name.istGleich(msg->getTargetPlayerName())))
+                || name.isEqual(msg->getTargetPlayerName())))
         {
             NetworkMessage* nMsg = new NetworkMessage();
             nMsg->sendChatMessage(msg);
@@ -121,15 +119,15 @@ void Chat::chatApi(Framework::StreamReader* zRequest,
     NetworkMessage* zResponse)
 {
     char id;
-    zRequest->lese(&id, 1);
+    zRequest->read(&id, 1);
     switch (id)
     {
     case 0: // send message
         {
             short len;
-            zRequest->lese((char*)&len, 2);
+            zRequest->read((char*)&len, 2);
             char* buffer = new char[len + 1];
-            zRequest->lese(buffer, len);
+            zRequest->read(buffer, len);
             buffer[len] = 0;
             if (buffer[0] == '/')
             {
@@ -160,9 +158,9 @@ void Chat::chatApi(Framework::StreamReader* zRequest,
     case 1: // add channel
         {
             char len;
-            zRequest->lese(&len, 1);
+            zRequest->read(&len, 1);
             char* buffer = new char[len + 1];
-            zRequest->lese(buffer, len);
+            zRequest->read(buffer, len);
             buffer[(int)len] = 0;
             for (ChatObserver* observer : this->observer)
             {
@@ -178,9 +176,9 @@ void Chat::chatApi(Framework::StreamReader* zRequest,
     case 2: // remove channel
         {
             char len;
-            zRequest->lese(&len, 1);
+            zRequest->read(&len, 1);
             char* buffer = new char[len + 1];
-            zRequest->lese(buffer, len);
+            zRequest->read(buffer, len);
             buffer[(int)len] = 0;
             for (ChatObserver* observer : this->observer)
             {
@@ -195,9 +193,9 @@ void Chat::chatApi(Framework::StreamReader* zRequest,
     case 3: // add ignored player
         {
             char len;
-            zRequest->lese(&len, 1);
+            zRequest->read(&len, 1);
             char* buffer = new char[len + 1];
-            zRequest->lese(buffer, len);
+            zRequest->read(buffer, len);
             buffer[(int)len] = 0;
             for (ChatObserver* observer : this->observer)
             {
@@ -212,9 +210,9 @@ void Chat::chatApi(Framework::StreamReader* zRequest,
     case 4: // remove ignored player
         {
             char len;
-            zRequest->lese(&len, 1);
+            zRequest->read(&len, 1);
             char* buffer = new char[len + 1];
-            zRequest->lese(buffer, len);
+            zRequest->read(buffer, len);
             buffer[(int)len] = 0;
             for (ChatObserver* observer : this->observer)
             {
@@ -257,11 +255,11 @@ void Chat::save()
     {
         obs->save();
     }
-    Framework::Datei messageData;
-    messageData.setDatei(
+    Framework::File messageData;
+    messageData.setFile(
         Game::INSTANCE->getWorldDirectory() + "/chat/history.chat");
-    if (!messageData.existiert()) messageData.erstellen();
-    messageData.open(Framework::Datei::Style::schreiben);
+    if (!messageData.exists()) messageData.create();
+    messageData.open(Framework::File::Style::write);
     for (ChatMessage* msg : history)
     {
         msg->writeTo(&messageData);

FactoryCraft/ChatCommand.cpp

@@ -26,24 +26,24 @@ void ChatCommand::addAutocompletePossibilities(
     Framework::RCArray<Framework::Text>& possibilities) const
 {
     int index
-        = appendToLast ? args.getEintragAnzahl() - 1 : args.getEintragAnzahl();
-    if (index < 0 || index >= params.getEintragAnzahl()) return;
+        = appendToLast ? args.getEntryCount() - 1 : args.getEntryCount();
+    if (index < 0 || index >= params.getEntryCount()) return;
     for (Framework::Text* possibility : params.z(index)->getAutocompleteValues(
-             appendToLast ? *args.z(args.getEintragAnzahl() - 1)
+             appendToLast ? *args.z(args.getEntryCount() - 1)
                           : Framework::Text("")))
     {
         possibilities.add(
             dynamic_cast<Framework::Text*>(possibility->getThis()));
     }
-    if (possibilities.getEintragAnzahl() == 0
-        || (possibilities.getEintragAnzahl() == 1 && appendToLast
-            && possibilities.z(0)->istGleich(
-                *args.z(args.getEintragAnzahl() - 1))))
+    if (possibilities.getEntryCount() == 0
+        || (possibilities.getEntryCount() == 1 && appendToLast
+            && possibilities.z(0)->isEqual(
+                *args.z(args.getEntryCount() - 1))))
     {
         Framework::Text help = getHelp();
-        while (help.hat("\n"))
+        while (help.has("\n"))
         {
-            Framework::Text* line = help.getTeilText(0, help.positionVon("\n"));
+            Framework::Text* line = help.getTeilText(0, help.positionOf("\n"));
             Framework::Logging::info() << line->getText();
             help.remove(0, line->getLength() + 1);
             line->release();
@@ -159,7 +159,7 @@ Framework::RCArray<Framework::Text> PlayerNameParameter::getAutocompleteValues(
     Game::INSTANCE->listPlayerNames(result);
     for (auto iterator = result.begin(); iterator;)
     {
-        if (iterator->hatAt(0, current))
+        if (iterator->hasAt(0, current))
         {
             iterator.remove();
         }
@@ -179,7 +179,7 @@ IntegerParameter::IntegerParameter(Framework::Text name,
 
 bool IntegerParameter::isLegalValue(Framework::Text value) const
 {
-    return Framework::Text((int)value).istGleich(value);
+    return Framework::Text((int)value).isEqual(value);
 }
 
 Framework::Text IntegerParameter::getDefaultValue(Entity* zActor) const

FactoryCraft/ChatCommandExecutor.cpp

@@ -22,14 +22,14 @@ ChatCommandExecutor::ChatCommandExecutor()
 
 bool ChatCommandExecutor::execute(Framework::Text line, Entity* zActor)
 {
-    if (line.hatAt(0, "/"))
+    if (line.hasAt(0, "/"))
     {
         for (ChatCommand* command : knownCommands)
         {
-            if (line.hatAt(0, Framework::Text("/") + command->getName()))
+            if (line.hasAt(0, Framework::Text("/") + command->getName()))
             {
                 if (line.getLength() > command->getName().getLength() + 1
-                    && !line.hatAt(command->getName().getLength() + 1, " "))
+                    && !line.hasAt(command->getName().getLength() + 1, " "))
                 {
                     continue;
                 }
@@ -40,12 +40,12 @@ bool ChatCommandExecutor::execute(Framework::Text line, Entity* zActor)
                      i < line.getLength();
                      i++)
                 {
-                    if (line.hatAt(i, " ") && !escaped)
+                    if (line.hasAt(i, " ") && !escaped)
                     {
                         if (start < i)
                         {
-                            if (line.hatAt(start, "'")
-                                && line.hatAt(i - 1, "'"))
+                            if (line.hasAt(start, "'")
+                                && line.hasAt(i - 1, "'"))
                             {
                                 params.add(line.getTeilText(start + 1, i - 1));
                             }
@@ -56,15 +56,15 @@ bool ChatCommandExecutor::execute(Framework::Text line, Entity* zActor)
                         }
                         start = i + 1;
                     }
-                    else if (line.hatAt(i, "'"))
+                    else if (line.hasAt(i, "'"))
                     {
                         escaped = !escaped;
                     }
                 }
                 if (start < line.getLength())
                 {
-                    if (line.hatAt(start, "'")
-                        && line.hatAt(line.getLength() - 1, "'"))
+                    if (line.hasAt(start, "'")
+                        && line.hasAt(line.getLength() - 1, "'"))
                     {
                         params.add(
                             line.getTeilText(start + 1, line.getLength() - 1));
@@ -77,7 +77,7 @@ bool ChatCommandExecutor::execute(Framework::Text line, Entity* zActor)
                 int index = 0;
                 for (ChatCommandParameter* param : command->getParams())
                 {
-                    if (params.getEintragAnzahl() > index
+                    if (params.getEntryCount() > index
                         && param->isLegalValue(*params.z(index)))
                     {
                         index++;
@@ -108,7 +108,7 @@ bool ChatCommandExecutor::execute(Framework::Text line, Entity* zActor)
                             Framework::Text error
                                 = "Illegal parameter at position ";
                             error.append() << (index + 1) << ": ";
-                            if (params.getEintragAnzahl() > index)
+                            if (params.getEntryCount() > index)
                             {
                                 error += *params.z(index);
                             }
@@ -123,7 +123,7 @@ bool ChatCommandExecutor::execute(Framework::Text line, Entity* zActor)
                         }
                     }
                 }
-                if (index != params.getEintragAnzahl())
+                if (index != params.getEntryCount())
                 {
                     Framework::Text error = "Illegal number of parameters. "
                                             "First unknown parameter: ";

FactoryCraft/ChatMessage.cpp

@@ -27,24 +27,24 @@ ChatMessage::ChatMessage(Framework::Text message,
 ChatMessage::ChatMessage(Framework::StreamReader* zReader)
     : ReferenceCounter()
 {
-    zReader->lese((char*)&time, 8);
+    zReader->read((char*)&time, 8);
     short len;
-    zReader->lese((char*)&len, 2);
+    zReader->read((char*)&len, 2);
     char* buffer = new char[len + 1];
-    zReader->lese(buffer, len);
+    zReader->read(buffer, len);
     buffer[len] = 0;
     message = buffer;
     delete[] buffer;
     char channelLen;
-    zReader->lese(&channelLen, 1);
+    zReader->read(&channelLen, 1);
     buffer = new char[channelLen + 1];
-    zReader->lese(buffer, channelLen);
+    zReader->read(buffer, channelLen);
     buffer[(int)channelLen] = 0;
     channel = buffer;
     delete[] buffer;
-    zReader->lese(&channelLen, 1);
+    zReader->read(&channelLen, 1);
     buffer = new char[channelLen + 1];
-    zReader->lese(buffer, channelLen);
+    zReader->read(buffer, channelLen);
     buffer[(int)channelLen] = 0;
     targetPlayerName = buffer;
     delete[] buffer;
@@ -62,14 +62,14 @@ Framework::Text ChatMessage::getTargetPlayerName() const
 
 void ChatMessage::writeTo(Framework::StreamWriter* zWriter) const
 {
-    zWriter->schreibe((char*)&time, 8);
+    zWriter->write((char*)&time, 8);
     short mLen = (short)message.getLength();
-    zWriter->schreibe((char*)&mLen, 2);
-    zWriter->schreibe(message.getText(), mLen);
+    zWriter->write((char*)&mLen, 2);
+    zWriter->write(message.getText(), mLen);
     char len = (char)channel.getLength();
-    zWriter->schreibe(&len, 1);
-    zWriter->schreibe(channel.getText(), len);
+    zWriter->write(&len, 1);
+    zWriter->write(channel.getText(), len);
     len = (char)targetPlayerName.getLength();
-    zWriter->schreibe(&len, 1);
-    zWriter->schreibe(targetPlayerName.getText(), len);
+    zWriter->write(&len, 1);
+    zWriter->write(targetPlayerName.getText(), len);
 }

FactoryCraft/ChatObserver.cpp

@@ -1,6 +1,6 @@
 #include "ChatObserver.h"
 
-#include <Datei.h>
+#include <File.h>
 
 #include "Chat.h"
 #include "Game.h"
@@ -10,29 +10,29 @@ ChatObserver::ChatObserver(int entityId)
     : ReferenceCounter(),
       entityId(entityId)
 {
-    Framework::Datei config;
-    config.setDatei(Game::INSTANCE->getWorldDirectory() + "/chat/observer/"
+    Framework::File config;
+    config.setFile(Game::INSTANCE->getWorldDirectory() + "/chat/observer/"
                     + entityId + ".observer");
-    if (config.existiert() && config.open(Framework::Datei::Style::lesen))
+    if (config.exists() && config.open(Framework::File::Style::read))
     {
         int count;
-        config.lese((char*)&count, sizeof(int));
+        config.read((char*)&count, sizeof(int));
         for (int i = 0; i < count; i++)
         {
             char len;
-            config.lese(&len, 1);
+            config.read(&len, 1);
             char* buffer = new char[len + 1];
-            config.lese(buffer, len);
+            config.read(buffer, len);
             buffer[(int)len] = 0;
             channel.add(new Framework::Text(buffer));
         }
-        config.lese((char*)&count, sizeof(int));
+        config.read((char*)&count, sizeof(int));
         for (int i = 0; i < count; i++)
         {
             char len;
-            config.lese(&len, 1);
+            config.read(&len, 1);
             char* buffer = new char[len + 1];
-            config.lese(buffer, len);
+            config.read(buffer, len);
             buffer[(int)len] = 0;
             ignoredPlayers.add(new Framework::Text(buffer));
         }
@@ -55,7 +55,7 @@ void ChatObserver::removeChannel(Framework::Text channel)
 {
     for (auto it = this->channel.begin(); it;)
     {
-        if (it->istGleich(channel))
+        if (it->isEqual(channel))
         {
             it.remove();
             continue;
@@ -66,11 +66,11 @@ void ChatObserver::removeChannel(Framework::Text channel)
 
 bool ChatObserver::isSubscribedTo(Framework::Text channel)
 {
-    if (channel.hatAt(0, Chat::getPlayerChannelName("")))
+    if (channel.hasAt(0, Chat::getPlayerChannelName("")))
     {
         for (Framework::Text* ignored : ignoredPlayers)
         {
-            if (channel.istGleich(Chat::getPlayerChannelName(*ignored)))
+            if (channel.isEqual(Chat::getPlayerChannelName(*ignored)))
                 return 0;
         }
         return 1;
@@ -79,7 +79,7 @@ bool ChatObserver::isSubscribedTo(Framework::Text channel)
     {
         for (Framework::Text* c : this->channel)
         {
-            if (channel.istGleich(*c)) return 1;
+            if (channel.isEqual(*c)) return 1;
         }
         return 0;
     }
@@ -94,7 +94,7 @@ void ChatObserver::removeIgnoredPlayer(Framework::Text playerName)
 {
     for (auto it = this->ignoredPlayers.begin(); it;)
     {
-        if (it->istGleich(playerName))
+        if (it->isEqual(playerName))
         {
             it.remove();
             continue;
@@ -110,11 +110,11 @@ int ChatObserver::getEntityId() const
 
 void ChatObserver::save() const
 {
-    Framework::Datei config;
-    config.setDatei(Game::INSTANCE->getWorldDirectory() + "/chat/observer/"
+    Framework::File config;
+    config.setFile(Game::INSTANCE->getWorldDirectory() + "/chat/observer/"
                     + entityId + ".observer");
-    config.erstellen();
-    if (config.open(Framework::Datei::Style::schreiben))
+    config.create();
+    if (config.open(Framework::File::Style::write))
     {
         writeTo(&config);
         config.close();
@@ -123,21 +123,21 @@ void ChatObserver::save() const
 
 void ChatObserver::writeTo(Framework::StreamWriter* zWriter) const
 {
-    int count = channel.getEintragAnzahl();
-    zWriter->schreibe((char*)&count, sizeof(int));
+    int count = channel.getEntryCount();
+    zWriter->write((char*)&count, sizeof(int));
     for (Framework::Text* c : channel)
     {
         char len = (char)c->getLength();
-        zWriter->schreibe(&len, 1);
-        zWriter->schreibe(c->getText(), len);
+        zWriter->write(&len, 1);
+        zWriter->write(c->getText(), len);
     }
-    count = ignoredPlayers.getEintragAnzahl();
-    zWriter->schreibe((char*)&count, sizeof(int));
+    count = ignoredPlayers.getEntryCount();
+    zWriter->write((char*)&count, sizeof(int));
     for (Framework::Text* ignored : ignoredPlayers)
     {
         char len = (char)ignored->getLength();
-        zWriter->schreibe(&len, 1);
-        zWriter->schreibe(ignored->getText(), len);
+        zWriter->write(&len, 1);
+        zWriter->write(ignored->getText(), len);
     }
 }
 

FactoryCraft/Chunk.cpp

@@ -12,7 +12,7 @@
 #include "Game.h"
 #include "WorldGenerator.h"
 
-Chunk::Chunk(Framework::Punkt location, int dimensionId)
+Chunk::Chunk(Framework::Point location, int dimensionId)
     : ReferenceCounter(),
       dimensionId(dimensionId),
       location(location),
@@ -32,7 +32,7 @@ Chunk::Chunk(Framework::Punkt location, int dimensionId)
     zNeighbours[3] = 0;
 }
 
-Chunk::Chunk(Framework::Punkt location,
+Chunk::Chunk(Framework::Point location,
     int dimensionId,
     Framework::StreamReader* zReader)
     : Chunk(location, dimensionId)
@@ -138,8 +138,8 @@ void Chunk::sendToClient(Framework::StreamWriter* zWriter, bool* instanceMap)
                     instanceMap[mI + CHUNK_SIZE * WORLD_HEIGHT] = 1;
                     instanceMap[mI + (CHUNK_SIZE + 2) * WORLD_HEIGHT] = 1;
                     assert(blockIds[z]);
-                    zWriter->schreibe((char*)&blockIds[z][index], 2);
-                    zWriter->schreibe((char*)&mI, 4);
+                    zWriter->write((char*)&blockIds[z][index], 2);
+                    zWriter->write((char*)&mI, 4);
                     char state = 0;
                     if (type->isFluid())
                     {
@@ -151,7 +151,7 @@ void Chunk::sendToClient(Framework::StreamWriter* zWriter, bool* instanceMap)
                     {
                         state |= 2;
                     }
-                    zWriter->schreibe((char*)&state, 1);
+                    zWriter->write((char*)&state, 1);
                     if ((state | 1) == state)
                     {
                         FluidBlock* fluidBlock
@@ -160,10 +160,10 @@ void Chunk::sendToClient(Framework::StreamWriter* zWriter, bool* instanceMap)
                                 : 0;
                         char data
                             = fluidBlock ? fluidBlock->getFlowOptions() : 0;
-                        zWriter->schreibe(&data, 1);
+                        zWriter->write(&data, 1);
                         data = fluidBlock ? fluidBlock->getDistanceToSource()
                                           : 0;
-                        zWriter->schreibe(&data, 1);
+                        zWriter->write(&data, 1);
                     }
                     if ((state | 2) == state)
                     {
@@ -171,14 +171,14 @@ void Chunk::sendToClient(Framework::StreamWriter* zWriter, bool* instanceMap)
                             = blocks[z] && blocks[z][index]
                                 ? blocks[z][index]->getSpeedModifier()
                                 : type->zDefault()->getSpeedModifier();
-                        zWriter->schreibe((char*)&speedModifier, 4);
+                        zWriter->write((char*)&speedModifier, 4);
                     }
                 }
             }
         }
     }
     unsigned short end = 0;
-    zWriter->schreibe((char*)&end, 2);
+    zWriter->write((char*)&end, 2);
 }
 
 void Chunk::sendLightToClient(
@@ -289,8 +289,8 @@ void Chunk::sendLightToClient(
                     if (x >= 0 && x < CHUNK_SIZE && y >= 0 && y < CHUNK_SIZE)
                     {
                         int index = Chunk::index(x, y) * WORLD_HEIGHT + z;
-                        zWriter->schreibe((char*)&index, 4);
-                        zWriter->schreibe((char*)(lightData + index * 6), 6);
+                        zWriter->write((char*)&index, 4);
+                        zWriter->write((char*)(lightData + index * 6), 6);
                     }
                     else
                     {
@@ -321,11 +321,11 @@ void Chunk::sendLightToClient(
                         if (zNeighbours[dir])
                         {
                             int i = -1;
-                            zWriter->schreibe((char*)&i, 4);
-                            zWriter->schreibe((char*)&x, 4);
-                            zWriter->schreibe((char*)&y, 4);
-                            zWriter->schreibe((char*)&z, 4);
-                            zWriter->schreibe(
+                            zWriter->write((char*)&i, 4);
+                            zWriter->write((char*)&x, 4);
+                            zWriter->write((char*)&y, 4);
+                            zWriter->write((char*)&z, 4);
+                            zWriter->write(
                                 (char*)(zNeighbours[dir]->lightData
                                         + index * 6),
                                 6);
@@ -336,7 +336,7 @@ void Chunk::sendLightToClient(
         }
     }
     int end = -2;
-    zWriter->schreibe((char*)&end, 4);
+    zWriter->write((char*)&end, 4);
     for (int i = 0; i < 4; i++)
     {
         if (zNeighbours[i])
@@ -471,9 +471,9 @@ void Chunk::addObserver(Entity* zEntity, DoLaterHandler& laterHandler)
     observers.add(observer);
     laterHandler.addTodo([this, id]() {
         Framework::InMemoryBuffer buffer;
-        buffer.schreibe("\4", 1);
-        buffer.schreibe((char*)&location.x, 4);
-        buffer.schreibe((char*)&location.y, 4);
+        buffer.write("\4", 1);
+        buffer.write((char*)&location.x, 4);
+        buffer.write((char*)&location.y, 4);
         bool instanceMap[(CHUNK_SIZE + 2) * (CHUNK_SIZE + 2) * WORLD_HEIGHT];
         memset(instanceMap, 0, sizeof(instanceMap));
         sendToClient(&buffer, instanceMap);
@@ -486,7 +486,7 @@ void Chunk::addObserver(Entity* zEntity, DoLaterHandler& laterHandler)
             << buffer.getSize() << "b";
 #endif
         char* message = new char[buffer.getSize()];
-        buffer.lese(message, (int)buffer.getSize());
+        buffer.read(message, (int)buffer.getSize());
         msg->setMessage(message, (int)buffer.getSize());
         msg->setUseBackground();
         Entity* e = Game::INSTANCE->zEntity(id);
@@ -537,7 +537,7 @@ void Chunk::api(Framework::StreamReader* zRequest,
     DoLaterHandler& laterHandler)
 {
     char type;
-    zRequest->lese(&type, 1);
+    zRequest->read(&type, 1);
     switch (type)
     {
     case 0:
@@ -1055,7 +1055,7 @@ void Chunk::load(Framework::StreamReader* zReader)
     for (int index = 0; index < WORLD_HEIGHT * CHUNK_SIZE * CHUNK_SIZE; index++)
     {
         unsigned short blockType;
-        zReader->lese((char*)&blockType, 2);
+        zReader->read((char*)&blockType, 2);
         if (blockType)
         {
             Framework::Vec3<int> pos
@@ -1063,7 +1063,7 @@ void Chunk::load(Framework::StreamReader* zReader)
                     (index / WORLD_HEIGHT) % CHUNK_SIZE,
                     index % WORLD_HEIGHT);
             bool d;
-            zReader->lese((char*)&d, 1);
+            zReader->read((char*)&d, 1);
             if (d)
             {
                 putBlockAt(pos,
@@ -1083,20 +1083,20 @@ void Chunk::load(Framework::StreamReader* zReader)
     }
     initializeLightning();
     unsigned short entityCount;
-    zReader->lese((char*)&entityCount, 2);
-    lastSavedEntityIds.leeren();
-    entitiesInChunk.leeren();
+    zReader->read((char*)&entityCount, 2);
+    lastSavedEntityIds.clear();
+    entitiesInChunk.clear();
     for (int i = 0; i < entityCount; i++)
     {
         int type;
-        zReader->lese((char*)&type, 4);
+        zReader->read((char*)&type, 4);
         Entity* entity = Game::INSTANCE->zEntityType(type)->loadEntity(zReader);
         addGeneratedEntity(entity);
     }
 }
 
 void Chunk::save(Framework::StreamWriter* zWriter,
-    Framework::Array<Framework::Punkt>& otherChunksToSave)
+    Framework::Array<Framework::Point>& otherChunksToSave)
 {
     for (int id : lastSavedEntityIds)
     {
@@ -1117,20 +1117,20 @@ void Chunk::save(Framework::StreamWriter* zWriter,
         for (int z = 0; z < WORLD_HEIGHT; z++)
         {
             unsigned short blockType = blockIds[z] ? blockIds[z][index] : 0;
-            zWriter->schreibe((char*)&blockType, 2);
+            zWriter->write((char*)&blockType, 2);
             if (blockType)
             {
                 if (blocks[z] && blocks[z][index])
                 {
                     bool d = 1;
-                    zWriter->schreibe((char*)&d, 1);
+                    zWriter->write((char*)&d, 1);
                     Game::INSTANCE->zBlockType(blockType)->saveBlock(
                         blocks[z][index], zWriter);
                 }
                 else
                 {
                     bool d = 0;
-                    zWriter->schreibe((char*)&d, 1);
+                    zWriter->write((char*)&d, 1);
                 }
             }
         }
@@ -1143,24 +1143,24 @@ void Chunk::save(Framework::StreamWriter* zWriter,
             len++;
         }
     }
-    zWriter->schreibe((char*)&len, 2);
+    zWriter->write((char*)&len, 2);
     for (Entity* entity : entitiesInChunk)
     {
         if (entity->zType()->getId() != EntityTypeEnum::PLAYER)
         {
             int type = entity->zType()->getId();
-            zWriter->schreibe((char*)&type, 4);
+            zWriter->write((char*)&type, 4);
             entity->zType()->saveEntity(entity, zWriter);
-            if (lastSavedEntityIds.getWertIndex(entity->getId()) < 0)
+            if (lastSavedEntityIds.getValueIndex(entity->getId()) < 0)
             {
                 entity->getLastSavedChunkCenter().ifPresent(
                     [&otherChunksToSave](
-                        Framework::Punkt p) { otherChunksToSave.add(p); });
+                        Framework::Point p) { otherChunksToSave.add(p); });
             }
             entity->setLastSavedChunkCenter(getCenter());
         }
     }
-    lastSavedEntityIds.leeren();
+    lastSavedEntityIds.clear();
     for (Entity* entity : entitiesInChunk)
     {
         if (entity->zType()->getId() != EntityTypeEnum::PLAYER)
@@ -1218,7 +1218,7 @@ void Chunk::onUnloaded()
     }
 }
 
-Framework::Punkt Chunk::getCenter() const
+Framework::Point Chunk::getCenter() const
 {
     return location;
 }
@@ -1261,7 +1261,7 @@ void Chunk::setAdded()
 
 bool Chunk::hasObservers() const
 {
-    return observers.getEintragAnzahl() > 0 || currentlyLoading;
+    return observers.getEntryCount() > 0 || currentlyLoading;
 }
 
 unsigned char* Chunk::getLightData(Framework::Vec3<int> location) const

FactoryCraft/Chunk.h

@@ -2,7 +2,7 @@
 
 #include <Array.h>
 #include <Either.h>
-#include <Punkt.h>
+#include <Point.h>
 #include <Vec3.h>
 
 #include "Block.h"
@@ -19,7 +19,7 @@ class Chunk : public virtual Framework::ReferenceCounter,
 {
 private:
     int dimensionId;
-    Framework::Punkt location;
+    Framework::Point location;
     Block*** blocks;
     Chunk* zNeighbours[4];
     unsigned short** blockIds;
@@ -46,8 +46,8 @@ private:
     bool isVisible(int z, int index) const;
 
 public:
-    Chunk(Framework::Punkt location, int dimensionId);
-    Chunk(Framework::Punkt location,
+    Chunk(Framework::Point location, int dimensionId);
+    Chunk(Framework::Point location,
         int dimensionId,
         Framework::StreamReader* zReader);
     ~Chunk();
@@ -80,12 +80,12 @@ public:
     Chunk* zNeighbor(Direction dir) const;
     void load(Framework::StreamReader* zReader);
     void save(Framework::StreamWriter* zWriter,
-        Framework::Array<Framework::Punkt>& otherChunksToSave);
+        Framework::Array<Framework::Point>& otherChunksToSave);
     void removeUnusedBlocks();
     int getDimensionId() const;
     void onLoaded();
     void onUnloaded();
-    Framework::Punkt getCenter() const;
+    Framework::Point getCenter() const;
     Framework::Vec3<int> getMin() const;
     Framework::Vec3<int> getMax() const;
     void prepareRemove();

FactoryCraft/ChunkMap.cpp

@@ -3,7 +3,7 @@
 #include "Chunk.h"
 #include "Constants.h"
 
-ChunkMap::ChunkMap(Framework::Punkt chunkCenter)
+ChunkMap::ChunkMap(Framework::Point chunkCenter)
     : ReferenceCounter(),
       chunkCenter(chunkCenter)
 {
@@ -69,17 +69,17 @@ ChunkMap::ChunkMap(Chunk* zChunk)
 ChunkMap::ChunkMap(Framework::StreamReader* zReader)
     : ReferenceCounter()
 {
-    zReader->lese((char*)&chunkCenter.x, 4);
-    zReader->lese((char*)&chunkCenter.y, 4);
+    zReader->read((char*)&chunkCenter.x, 4);
+    zReader->read((char*)&chunkCenter.y, 4);
     pixels = new MapPixel[CHUNK_SIZE * CHUNK_SIZE];
     memset(pixels, 0, sizeof(MapPixel) * CHUNK_SIZE * CHUNK_SIZE);
     for (int i = 0; i < CHUNK_SIZE * CHUNK_SIZE; i++)
     {
-        zReader->lese((char*)&pixels[i].len, 1);
+        zReader->read((char*)&pixels[i].len, 1);
         if (pixels[i].len > 0)
         {
             pixels[i].blocks = new MapBlock[pixels[i].len];
-            zReader->lese(
+            zReader->read(
                 (char*)pixels[i].blocks, (int)sizeof(MapBlock) * pixels[i].len);
         }
     }
@@ -161,20 +161,20 @@ bool ChunkMap::update(
 
 void ChunkMap::writeTo(Framework::StreamWriter* zWriter) const
 {
-    zWriter->schreibe((char*)&chunkCenter.x, 4);
-    zWriter->schreibe((char*)&chunkCenter.y, 4);
+    zWriter->write((char*)&chunkCenter.x, 4);
+    zWriter->write((char*)&chunkCenter.y, 4);
     for (int i = 0; i < CHUNK_SIZE * CHUNK_SIZE; i++)
     {
-        zWriter->schreibe((char*)&pixels[i].len, 1);
+        zWriter->write((char*)&pixels[i].len, 1);
         if (pixels[i].len > 0)
         {
-            zWriter->schreibe(
+            zWriter->write(
                 (char*)pixels[i].blocks, (int)sizeof(MapBlock) * pixels[i].len);
         }
     }
 }
 
-Framework::Punkt ChunkMap::getChunkCenter() const
+Framework::Point ChunkMap::getChunkCenter() const
 {
     return chunkCenter;
 }

FactoryCraft/ChunkMap.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#include <Punkt.h>
+#include <Point.h>
 #include <Reader.h>
 #include <Writer.h>
 #include <ReferenceCounter.h>
@@ -31,12 +31,12 @@ class Chunk;
 class ChunkMap : public Framework::ReferenceCounter
 {
 private:
-    Framework::Punkt chunkCenter;
+    Framework::Point chunkCenter;
     MapPixel* pixels;
     Framework::Critical cs;
 
 public:
-    ChunkMap(Framework::Punkt chunkCenter);
+    ChunkMap(Framework::Point chunkCenter);
     ChunkMap(Chunk* zChunk);
     ChunkMap(Framework::StreamReader* zReader);
     ~ChunkMap();
@@ -52,5 +52,5 @@ public:
     bool update(char x, char y, unsigned char height, int color1, int color2);
 
     void writeTo(Framework::StreamWriter* zWriter) const;
-    Framework::Punkt getChunkCenter() const;
+    Framework::Point getChunkCenter() const;
 };

FactoryCraft/CraftingStorage.cpp

@@ -37,7 +37,7 @@ BasicShapedCrafter::BasicShapedCrafter(
         onChange
         = [this, recipieList](
               ItemSlot* zSlot, Direction dir, const Item* zItem, int count) {
-              if (!zSlot->getName().istGleich("CraftingGrid")) return;
+              if (!zSlot->getName().isEqual("CraftingGrid")) return;
               calculateOutputPreview();
           };
     zInventory->registerAfterPullStackCall(onChange);
@@ -67,25 +67,25 @@ void BasicShapedCrafter::getOutputPreview(NetworkMessage* zMessage)
         {
             count++;
             int itemCount = slot.count;
-            buffer.schreibe((char*)&itemCount, 4);
+            buffer.write((char*)&itemCount, 4);
             if (itemCount > 0)
             {
                 float f = slot.hp;
-                buffer.schreibe((char*)&f, 4);
+                buffer.write((char*)&f, 4);
                 f = slot.maxHp;
-                buffer.schreibe((char*)&f, 4);
+                buffer.write((char*)&f, 4);
                 f = slot.durability;
-                buffer.schreibe((char*)&f, 4);
+                buffer.write((char*)&f, 4);
                 f = slot.maxDurability;
-                buffer.schreibe((char*)&f, 4);
+                buffer.write((char*)&f, 4);
                 int id = slot.type;
-                buffer.schreibe((char*)&id, 4);
+                buffer.write((char*)&id, 4);
             }
         }
         char* msg = new char[5 + buffer.getSize()];
         msg[0] = 100; // set crafting result
         *(int*)(msg + 1) = count;
-        buffer.lese(msg + 5, (int)buffer.getSize());
+        buffer.read(msg + 5, (int)buffer.getSize());
         zMessage->setMessage(msg, 5 + (int)buffer.getSize());
     }
     else
@@ -161,7 +161,7 @@ bool BasicShapedCrafter::consume(
     int beginY = this->height;
     SourceSlotBlacklistFilter otherSlotsSource;
     TargetSlotBlacklistFilter otherSlotsTarget;
-    for (int i = 0; i < craftingInput.getEintragAnzahl(); i++)
+    for (int i = 0; i < craftingInput.getEntryCount(); i++)
     {
         if (!craftingInput.get(i)->isEmpty())
         {
@@ -272,16 +272,16 @@ void BasicShapedCrafter::consume(Framework::RCArray<RecipieInput>& inputs)
 {
     SourceSlotBlacklistFilter otherSlotsSource;
     TargetSlotBlacklistFilter otherSlotsTarget;
-    for (int i = 0; i < craftingInput.getEintragAnzahl(); i++)
+    for (int i = 0; i < craftingInput.getEntryCount(); i++)
     {
         otherSlotsSource.addBlackListSlotId(craftingInput.get(i)->getId());
         otherSlotsTarget.addBlackListSlotId(craftingInput.get(i)->getId());
     }
-    bool* used = new bool[craftingInput.getEintragAnzahl()];
-    memset(used, 0, sizeof(bool) * craftingInput.getEintragAnzahl());
-    for (int i = 0; i < inputs.getEintragAnzahl(); i++)
+    bool* used = new bool[craftingInput.getEntryCount()];
+    memset(used, 0, sizeof(bool) * craftingInput.getEntryCount());
+    for (int i = 0; i < inputs.getEntryCount(); i++)
     {
-        for (int j = 0; j < craftingInput.getEintragAnzahl(); j++)
+        for (int j = 0; j < craftingInput.getEntryCount(); j++)
         {
             if (used[j]) continue;
             ItemSlot* target = craftingInput.get(j);
@@ -385,7 +385,7 @@ void BasicShapedCrafter::consume(Framework::RCArray<RecipieInput>& inputs)
 void BasicShapedCrafter::addCraftingResult(ItemStack* zStack)
 {
     TargetSlotBlacklistFilter otherSlotsTarget;
-    for (int i = 0; i < craftingInput.getEintragAnzahl(); i++)
+    for (int i = 0; i < craftingInput.getEntryCount(); i++)
         otherSlotsTarget.addBlackListSlotId(craftingInput.get(i)->getId());
     zInventory->unsaveAddItem(zStack, NO_DIRECTION, &otherSlotsTarget);
 }

FactoryCraft/Dimension.cpp

@@ -5,7 +5,7 @@
 
 #include "ChunkMap.h"
 #include "Constants.h"
-#include "Datei.h"
+#include "File.h"
 #include "DimensionMap.h"
 #include "Entity.h"
 #include "EntityType.h"
@@ -32,14 +32,14 @@ Dimension::Dimension(int id)
       nightTransitionDuration(30.0),
       dayDuration(600.0)
 {
-    Datei d;
-    d.setDatei(
+    File d;
+    d.setFile(
         Game::INSTANCE->getWorldDirectory() + "/dim/" + Text(id) + "/meta.dim");
-    if (d.existiert())
+    if (d.exists())
     {
-        d.open(Datei::Style::lesen);
-        d.lese((char*)&nextStructureId, 8);
-        d.lese((char*)&currentDayTime, 8);
+        d.open(File::Style::read);
+        d.read((char*)&nextStructureId, 8);
+        d.read((char*)&currentDayTime, 8);
         d.close();
     }
     start();
@@ -68,14 +68,14 @@ void Dimension::api(Framework::InMemoryBuffer* zRequest,
 {
     DoLaterHandler laterHandler;
     char type;
-    zRequest->lese(&type, 1);
+    zRequest->read(&type, 1);
     switch (type)
     {
     case 0: // chunk message
         {
-            Punkt center;
-            zRequest->lese((char*)&center.x, 4);
-            zRequest->lese((char*)&center.y, 4);
+            Point center;
+            zRequest->read((char*)&center.x, 4);
+            zRequest->read((char*)&center.y, 4);
             cs.lock();
             Chunk* cC = zChunk(Game::getChunkCenter(center.x, center.y));
             if (!cC)
@@ -101,9 +101,9 @@ void Dimension::api(Framework::InMemoryBuffer* zRequest,
     case 1: // block message
         {
             Vec3<int> location;
-            zRequest->lese((char*)&location.x, 4);
-            zRequest->lese((char*)&location.y, 4);
-            zRequest->lese((char*)&location.z, 4);
+            zRequest->read((char*)&location.x, 4);
+            zRequest->read((char*)&location.y, 4);
+            zRequest->read((char*)&location.z, 4);
             Framework::Either<Block*, int> block = zBlock(location, 0);
             if (block.isA())
             {
@@ -134,8 +134,8 @@ void Dimension::thread()
 {
     // light calculation
     int index = 0;
-    ZeitMesser messer;
-    messer.messungStart();
+    Timer messer;
+    messer.measureStart();
     double time = 0;
     bool isForeground = 0;
     Framework::Array<Framework::Vec3<int>> internalLightUpdateQueue;
@@ -143,7 +143,7 @@ void Dimension::thread()
     while (!stop)
     {
         Vec3<int> position;
-        if (internalLightUpdateQueue.getEintragAnzahl())
+        if (internalLightUpdateQueue.getEntryCount())
         {
             position = internalLightUpdateQueue.get(0);
             internalLightUpdateQueue.remove(0);
@@ -151,21 +151,21 @@ void Dimension::thread()
         else
         {
             removedChunksCs.lock();
-            if (removedChunks.getEintragAnzahl() > 0)
+            if (removedChunks.getEntryCount() > 0)
             {
                 Chunk* removedChunk = removedChunks.z(0);
                 removedChunksCs.unlock();
-                Array<Framework::Punkt> chunksToSave;
+                Array<Framework::Point> chunksToSave;
                 Text filePath = Game::INSTANCE->getWorldDirectory() + "/dim/"
                               + getDimensionId() + "/";
                 filePath.appendHex(removedChunk->getCenter().x);
                 filePath += "_";
                 filePath.appendHex(removedChunk->getCenter().y);
                 filePath += ".chunk";
-                Datei d;
-                d.setDatei(filePath);
-                d.erstellen();
-                d.open(Datei::Style::schreiben);
+                File d;
+                d.setFile(filePath);
+                d.create();
+                d.open(File::Style::write);
                 removedChunk->save(&d, chunksToSave);
                 char addr[8];
                 getAddrOfWorld(removedChunk->getCenter(), addr);
@@ -173,9 +173,9 @@ void Dimension::thread()
                 d.close();
                 removedChunksCs.lock();
                 removedChunks.remove(0);
-                while (chunksToSave.getEintragAnzahl() > 0)
+                while (chunksToSave.getEntryCount() > 0)
                 {
-                    Punkt cPos = chunksToSave.get(0);
+                    Point cPos = chunksToSave.get(0);
                     chunksToSave.remove(0);
                     Chunk* c = zChunk(cPos);
                     if (c)
@@ -186,17 +186,17 @@ void Dimension::thread()
                         filePath += "_";
                         filePath.appendHex(cPos.y);
                         filePath += ".chunk";
-                        Datei d;
-                        d.setDatei(filePath);
-                        d.erstellen();
-                        d.open(Datei::Style::schreiben);
+                        File d;
+                        d.setFile(filePath);
+                        d.create();
+                        d.open(File::Style::write);
                         c->save(&d, chunksToSave);
                         d.close();
                     }
                 }
             }
             removedChunksCs.unlock();
-            if (priorizedLightUpdateQueue.getEintragAnzahl())
+            if (priorizedLightUpdateQueue.getEntryCount())
             {
                 prioLightCs.lock();
                 position = priorizedLightUpdateQueue.get(0);
@@ -206,12 +206,12 @@ void Dimension::thread()
             }
             else
             {
-                if (!lightUpdateQueue.getEintragAnzahl())
+                if (!lightUpdateQueue.getEntryCount())
                 {
-                    messer.messungEnde();
+                    messer.measureEnd();
                     time += messer.getSekunden();
                     Sleep(500);
-                    messer.messungStart();
+                    messer.measureStart();
                     continue;
                 }
                 lightCs.lock();
@@ -292,26 +292,26 @@ void Dimension::thread()
         index++;
         if (index > 100000)
         {
-            messer.messungEnde();
+            messer.measureEnd();
             time += messer.getSekunden();
             Logging::debug()
                 << "100000 light updates needed " << time << " seconds";
             time = 0;
             index = 0;
-            messer.messungStart();
+            messer.measureStart();
         }
     }
     Logging::info() << Text("Dimension ") + this->getDimensionId()
                            + " update Thread exited.";
 }
 
-void Dimension::getAddrOf(Punkt cPos, char* addr) const
+void Dimension::getAddrOf(Point cPos, char* addr) const
 {
     *(int*)addr = cPos.x;
     *((int*)addr + 1) = cPos.y;
 }
 
-void Dimension::getAddrOfWorld(Punkt wPos, char* addr) const
+void Dimension::getAddrOfWorld(Point wPos, char* addr) const
 {
     if (wPos.x < 0) wPos.x -= CHUNK_SIZE;
     if (wPos.y < 0) // needed because otherwise would (-8, -8) have the same
@@ -328,15 +328,15 @@ void Dimension::saveStructure(MultiblockStructure* zStructure) const
 
 void Dimension::entityTickLoop()
 {
-    ZeitMesser zm;
+    Timer zm;
     double ausgleich = 0.0;
-    zm.messungStart();
+    zm.measureStart();
     Sleep(16);
     while (!stop)
     {
-        zm.messungEnde();
+        zm.measureEnd();
         double seconds = zm.getSekunden();
-        zm.messungStart();
+        zm.measureStart();
         entityCs.lock();
         chunkCs.lock();
         auto iterator = entities->begin();
@@ -376,7 +376,7 @@ void Dimension::entityTickLoop()
     }
 }
 
-Chunk* Dimension::zChunk(Punkt wPos) const
+Chunk* Dimension::zChunk(Point wPos) const
 {
     char addr[8];
     getAddrOfWorld(wPos, addr);
@@ -472,7 +472,7 @@ void Dimension::addEntity(Entity* entity)
     entityCs.unlock();
 }
 
-void Dimension::setChunk(Chunk* chunk, Punkt center)
+void Dimension::setChunk(Chunk* chunk, Point center)
 {
     char addr[8];
     getAddrOfWorld(center, addr);
@@ -483,7 +483,7 @@ void Dimension::setChunk(Chunk* chunk, Punkt center)
     {
         Game::INSTANCE->zTickOrganizer()->removeTickSource(old);
         old->prepareRemove();
-        for (int i = 0; i < chunkList.getEintragAnzahl(); i++)
+        for (int i = 0; i < chunkList.getEntryCount(); i++)
         {
             if (chunkList.get(i) == old)
             {
@@ -501,7 +501,7 @@ void Dimension::setChunk(Chunk* chunk, Punkt center)
     {
         chunkList.add(chunk);
     }
-    getAddrOfWorld(center + Punkt(CHUNK_SIZE, 0), addr);
+    getAddrOfWorld(center + Point(CHUNK_SIZE, 0), addr);
     Chunk* zChunk = chunks->z(addr, 8);
     if (zChunk)
     {
@@ -512,7 +512,7 @@ void Dimension::setChunk(Chunk* chunk, Punkt center)
             Game::INSTANCE->zGenerator()->postprocessChunk(zChunk);
         }
     }
-    getAddrOfWorld(center + Punkt(-CHUNK_SIZE, 0), addr);
+    getAddrOfWorld(center + Point(-CHUNK_SIZE, 0), addr);
     zChunk = chunks->z(addr, 8);
     if (zChunk)
     {
@@ -523,7 +523,7 @@ void Dimension::setChunk(Chunk* chunk, Punkt center)
             Game::INSTANCE->zGenerator()->postprocessChunk(zChunk);
         }
     }
-    getAddrOfWorld(center + Punkt(0, CHUNK_SIZE), addr);
+    getAddrOfWorld(center + Point(0, CHUNK_SIZE), addr);
     zChunk = chunks->z(addr, 8);
     if (zChunk)
     {
@@ -534,7 +534,7 @@ void Dimension::setChunk(Chunk* chunk, Punkt center)
             Game::INSTANCE->zGenerator()->postprocessChunk(zChunk);
         }
     }
-    getAddrOfWorld(center + Punkt(0, -CHUNK_SIZE), addr);
+    getAddrOfWorld(center + Point(0, -CHUNK_SIZE), addr);
     zChunk = chunks->z(addr, 8);
     if (zChunk)
     {
@@ -605,26 +605,26 @@ void Dimension::setChunk(Chunk* chunk, Punkt center)
 
 void Dimension::save(Text worldDir) const
 {
-    Datei d;
-    d.setDatei(Game::INSTANCE->getWorldDirectory() + "/dim/" + Text(dimensionId)
+    File d;
+    d.setFile(Game::INSTANCE->getWorldDirectory() + "/dim/" + Text(dimensionId)
                + "/meta.dim");
-    d.erstellen();
-    d.open(Datei::Style::schreiben);
-    d.schreibe((char*)&nextStructureId, 8);
-    d.schreibe((char*)&currentDayTime, 8);
+    d.create();
+    d.open(File::Style::write);
+    d.write((char*)&nextStructureId, 8);
+    d.write((char*)&currentDayTime, 8);
     d.close();
-    Array<Framework::Punkt> otherChunks;
+    Array<Framework::Point> otherChunks;
     for (auto chunk = chunkList.begin(); chunk; chunk++)
     {
         if (!chunk._) continue;
-        Datei* file = new Datei();
+        File* file = new File();
         Text filePath = worldDir + "/dim/" + dimensionId + "/";
         filePath.appendHex(chunk->getCenter().x);
         filePath += "_";
         filePath.appendHex(chunk->getCenter().y);
         filePath += ".chunk";
-        file->setDatei(filePath);
-        if (file->open(Datei::Style::schreiben)) chunk->save(file, otherChunks);
+        file->setFile(filePath);
+        if (file->open(File::Style::write)) chunk->save(file, otherChunks);
         file->close();
         file->release();
         char addr[8];
@@ -637,12 +637,12 @@ void Dimension::save(Text worldDir) const
     {
         if (entity->zType()->getId() == EntityTypeEnum::PLAYER)
         {
-            Datei pFile;
-            pFile.setDatei(
+            File pFile;
+            pFile.setFile(
                 worldDir + "/player/"
                 + Game::INSTANCE->getPlayerId(((Player*)entity)->getName()));
-            pFile.erstellen();
-            if (pFile.open(Datei::Style::schreiben))
+            pFile.create();
+            if (pFile.open(File::Style::write))
             {
                 Game::INSTANCE->zEntityType(EntityTypeEnum::PLAYER)
                     ->saveEntity(entity, &pFile);
@@ -664,7 +664,7 @@ int Dimension::getDimensionId() const
 
 bool Dimension::hasChunck(int x, int y) const
 {
-    if (zChunk(Punkt(x, y))) return 1;
+    if (zChunk(Point(x, y))) return 1;
     removedChunksCs.lock();
     for (Chunk* c : removedChunks)
     {
@@ -681,7 +681,7 @@ bool Dimension::hasChunck(int x, int y) const
 bool Dimension::reviveChunk(int x, int y)
 {
     chunkCs.lock();
-    if (zChunk(Punkt(x, y)))
+    if (zChunk(Point(x, y)))
     {
         chunkCs.unlock();
         return 1;
@@ -692,7 +692,7 @@ bool Dimension::reviveChunk(int x, int y)
     {
         if (i->getCenter().x == x && i->getCenter().y == y)
         {
-            setChunk(dynamic_cast<Chunk*>(i->getThis()), Punkt(x, y));
+            setChunk(dynamic_cast<Chunk*>(i->getThis()), Point(x, y));
             if (index > 0) i.remove();
             removedChunksCs.unlock();
             chunkCs.unlock();
@@ -750,7 +750,7 @@ Entity* Dimension::zTarget(Framework::Vec3<float> pos,
     for (auto entity : *entities)
     {
         if (!entity->isRemoved()
-            && entity->getPosition().abstandSq(pos) <= maxDistanceSq)
+            && entity->getPosition().distanceSq(pos) <= maxDistanceSq)
         {
             double dist = entity->getHitDistance(pos, direction);
             if (!isnan(dist))
@@ -792,7 +792,7 @@ Entity* Dimension::zNearestEntity(
     {
         if (!entity->isRemoved() && filter(entity))
         {
-            float d = pos.abstandSq(entity->getPosition());
+            float d = pos.distanceSq(entity->getPosition());
             if (!result || d < sqDist)
             {
                 result = entity;
@@ -843,16 +843,16 @@ void Dimension::updateLightningWithoutWait(Framework::Vec3<int> location)
 
 void Dimension::updateLightAtChunkBorders(Chunk* zChunk)
 {
-    if (lightUpdateQueue.getEintragAnzahl() > 300000)
+    if (lightUpdateQueue.getEntryCount() > 300000)
     {
         Logging::warning()
             << "light calculation queue is over 300000 blocks long";
     }
-    Punkt center = zChunk->getCenter();
-    Chunk* xn = this->zChunk(center - Punkt(CHUNK_SIZE, 0));
-    Chunk* xp = this->zChunk(center + Punkt(CHUNK_SIZE, 0));
-    Chunk* yn = this->zChunk(center - Punkt(0, CHUNK_SIZE));
-    Chunk* yp = this->zChunk(center + Punkt(0, CHUNK_SIZE));
+    Point center = zChunk->getCenter();
+    Chunk* xn = this->zChunk(center - Point(CHUNK_SIZE, 0));
+    Chunk* xp = this->zChunk(center + Point(CHUNK_SIZE, 0));
+    Chunk* yn = this->zChunk(center - Point(0, CHUNK_SIZE));
+    Chunk* yp = this->zChunk(center + Point(0, CHUNK_SIZE));
     for (int i = WORLD_HEIGHT - 1; i >= 0; i--)
     {
         for (int j = 0; j < CHUNK_SIZE; j++)
@@ -977,7 +977,7 @@ MultiblockStructure* Dimension::zStructureById(__int64 id)
 void Dimension::requestStopAndWait()
 {
     stop = 1;
-    warteAufThread(1000000);
+    waitForThread(1000000);
 }
 
 void Dimension::updateMap(int x, int y, int height)
@@ -1009,7 +1009,7 @@ void Dimension::updateMap(int x, int y, int height)
                                                             : 0;
     }
     char addr[8];
-    Punkt center = Game::INSTANCE->getChunkCenter(x, y);
+    Point center = Game::INSTANCE->getChunkCenter(x, y);
     getAddrOfWorld(center, addr);
     ChunkMap* cMap = map->getMap(addr, 8, center);
     if (cMap)
@@ -1035,7 +1035,7 @@ void Dimension::updateMap(int x, int y, int height)
 
 int Dimension::getChunkCount() const
 {
-    return chunkList.getEintragAnzahl();
+    return chunkList.getEntryCount();
 }
 
 double Dimension::getCurrentDayTime() const

FactoryCraft/Dimension.h

@@ -3,7 +3,7 @@
 #include <Critical.h>
 #include <Either.h>
 #include <InMemoryBuffer.h>
-#include <Punkt.h>
+#include <Point.h>
 #include <Thread.h>
 #include <Trie.h>
 
@@ -25,7 +25,7 @@ public:
 struct RequestQueue
 {
     Framework::InMemoryBuffer* request;
-    Framework::Punkt chunkCenter;
+    Framework::Point chunkCenter;
     int sourceId;
 };
 
@@ -58,8 +58,8 @@ private:
     double nightTransitionDuration;
     double dayDuration;
 
-    void getAddrOf(Framework::Punkt cPos, char* addr) const;
-    void getAddrOfWorld(Framework::Punkt wPos, char* addr) const;
+    void getAddrOf(Framework::Point cPos, char* addr) const;
+    void getAddrOfWorld(Framework::Point wPos, char* addr) const;
     void saveStructure(MultiblockStructure* zStructure) const;
     void entityTickLoop();
 
@@ -86,12 +86,12 @@ public:
         Framework::Vec3<int> location, Framework::Either<Block*, int> block);
     void sendBlockInfo(Framework::Vec3<int> location);
     void addEntity(Entity* entity);
-    void setChunk(Chunk* chunk, Framework::Punkt center);
+    void setChunk(Chunk* chunk, Framework::Point center);
     void save(Framework::Text worldDir) const;
     int getDimensionId() const;
     bool hasChunck(int x, int y) const;
     bool reviveChunk(int x, int y);
-    Chunk* zChunk(Framework::Punkt wPos) const;
+    Chunk* zChunk(Framework::Point wPos) const;
     float getGravity() const;
     void removeOldChunks();
     Entity* zTarget(Framework::Vec3<float> pos,

FactoryCraft/DimensionGenerator.cpp

@@ -277,11 +277,11 @@ Chunk* BiomedCavedDimensionGenerator::generateChunk(int centerX, int centerY)
     double structureTime = 0;
     double caveTime = 0;
     double blockGenTime = 0;
-    Framework::ZeitMesser zm;
-    Framework::ZeitMesser zmGlobal;
-    Framework::ZeitMesser entityGenTime;
-    zm.messungStart();
-    zmGlobal.messungStart();
+    Framework::Timer zm;
+    Framework::Timer zmGlobal;
+    Framework::Timer entityGenTime;
+    zm.measureStart();
+    zmGlobal.measureStart();
 #endif
     Framework::RCArray<GeneratedStructure>* structures
         = getGeneratedStructoresForArea(
@@ -291,18 +291,18 @@ Chunk* BiomedCavedDimensionGenerator::generateChunk(int centerX, int centerY)
                 centerY + CHUNK_SIZE / 2,
                 WORLD_HEIGHT - 1));
 #ifdef CHUNK_GENERATION_DEBUG_LOG
-    zm.messungEnde();
+    zm.measureEnd();
     structureTime += zm.getSekunden();
-    zm.messungStart();
+    zm.measureStart();
 #endif
     CaveChunkGenerator* caveGen
         = caveGenerator->getGeneratorForChunk(centerX, centerY);
 #ifdef CHUNK_GENERATION_DEBUG_LOG
-    zm.messungEnde();
+    zm.measureEnd();
     caveTime += zm.getSekunden();
 #endif
     Chunk* chunk
-        = new Chunk(Framework::Punkt(centerX, centerY), getDimensionId());
+        = new Chunk(Framework::Point(centerX, centerY), getDimensionId());
     zMemory()->setCurrentChunk(dynamic_cast<Chunk*>(chunk->getThis()));
     for (int x = -CHUNK_SIZE / 2; x < CHUNK_SIZE / 2; x++)
     {
@@ -343,7 +343,7 @@ Chunk* BiomedCavedDimensionGenerator::generateChunk(int centerX, int centerY)
                     {
                         // generate biom block
 #ifdef CHUNK_GENERATION_DEBUG_LOG
-                        zm.messungStart();
+                        zm.measureStart();
 #endif
                         generated = biom->generateBlock(x + centerX,
                             y + centerY,
@@ -351,7 +351,7 @@ Chunk* BiomedCavedDimensionGenerator::generateChunk(int centerX, int centerY)
                             getDimensionId(),
                             chunk);
 #ifdef CHUNK_GENERATION_DEBUG_LOG
-                        zm.messungEnde();
+                        zm.measureEnd();
                         blockGenTime += zm.getSekunden();
 #endif
                     }
@@ -496,7 +496,7 @@ Chunk* BiomedCavedDimensionGenerator::generateChunk(int centerX, int centerY)
     caveGen->release();
     structures->release();
 #ifdef CHUNK_GENERATION_DEBUG_LOG
-    entityGenTime.messungStart();
+    entityGenTime.measureStart();
 #endif
     *xPos = (float)chunk->getCenter().x;
     *yPos = (float)chunk->getCenter().y;
@@ -525,8 +525,8 @@ Chunk* BiomedCavedDimensionGenerator::generateChunk(int centerX, int centerY)
         }
     }
 #ifdef CHUNK_GENERATION_DEBUG_LOG
-    entityGenTime.messungEnde();
-    zmGlobal.messungEnde();
+    entityGenTime.measureEnd();
+    zmGlobal.measureEnd();
     Framework::Logging::trace() << "structureGenerationTime: " << structureTime;
     Framework::Logging::trace() << "caveGenerationTime: " << caveTime;
     Framework::Logging::trace() << "blockGenTime: " << blockGenTime;
@@ -698,7 +698,7 @@ Framework::Either<Block*, int> BiomedCavedDimensionGenerator::generateBlock(
     }
     structures->release();
 
-    Framework::Punkt chunkCenter = Game::getChunkCenter(location.x, location.y);
+    Framework::Point chunkCenter = Game::getChunkCenter(location.x, location.y);
     CaveChunkGenerator* caveGen
         = caveGenerator->getGeneratorForChunk(chunkCenter.x, chunkCenter.y);
     if (caveGen->isInCave(location.x, location.y, location.z))
@@ -779,7 +779,7 @@ void BiomedCavedDimensionGenerator::addBiomGenerator(
     BiomGenerator* biomGenerator)
 {
     biomGenerators.add(biomGenerator);
-    if (biomGenerators.getEintragAnzahl() == 1)
+    if (biomGenerators.getEntryCount() == 1)
     {
         minStructureOffset = biomGenerator->getMinStructureOffset();
         maxStructureOffset = biomGenerator->getMaxStructureOffset();

FactoryCraft/DimensionMap.cpp

@@ -1,6 +1,6 @@
 #include "DimensionMap.h"
 
-#include <Datei.h>
+#include <File.h>
 #include <Logging.h>
 
 #include "Chat.h"
@@ -28,14 +28,14 @@ void DimensionMap::api(Framework::InMemoryBuffer* zRequest,
     Dimension* zDimension)
 {
     char type;
-    zRequest->lese(&type, 1);
+    zRequest->read(&type, 1);
     switch (type)
     {
     case 0: // request chunk
         {
-            Framework::Punkt location;
-            zRequest->lese((char*)&location.x, 4);
-            zRequest->lese((char*)&location.y, 4);
+            Framework::Point location;
+            zRequest->read((char*)&location.x, 4);
+            zRequest->read((char*)&location.y, 4);
             location = Game::getChunkCenter(location.x, location.y);
             char addr[8];
             zDimension->getAddrOfWorld(location, addr);
@@ -71,35 +71,35 @@ void DimensionMap::api(Framework::InMemoryBuffer* zRequest,
                 {
                     Player* p = dynamic_cast<Player*>(entity);
                     char len = (char)Framework::textLength(p->getName());
-                    buff.schreibe(&len, 1);
-                    buff.schreibe(p->getName(), len);
+                    buff.write(&len, 1);
+                    buff.write(p->getName(), len);
                     Framework::Vec3<float> pos = p->getPosition();
-                    buff.schreibe((char*)&pos.x, 4);
-                    buff.schreibe((char*)&pos.y, 4);
-                    buff.schreibe((char*)&pos.z, 4);
+                    buff.write((char*)&pos.x, 4);
+                    buff.write((char*)&pos.y, 4);
+                    buff.write((char*)&pos.z, 4);
                     count++;
                 }
             }
             char* msg = new char[4 + buff.getSize()];
             *(int*)msg = count;
-            buff.lese(msg + 4, (int)buff.getSize());
+            buff.read(msg + 4, (int)buff.getSize());
             zResponse->sendPlayerPositions(msg, 4 + (int)buff.getSize());
             break;
         }
     }
 }
 
-ChunkMap* DimensionMap::load(Framework::Punkt chunkCenter)
+ChunkMap* DimensionMap::load(Framework::Point chunkCenter)
 {
-    Framework::Datei file;
+    Framework::File file;
     Framework::Text filePath
         = Game::INSTANCE->getWorldDirectory() + "/dim/" + dimensionId + "/map/";
     filePath.appendHex(chunkCenter.x);
     filePath += "_";
     filePath.appendHex(chunkCenter.y);
     filePath += ".map";
-    file.setDatei(filePath);
-    if (file.open(Framework::Datei::Style::lesen))
+    file.setFile(filePath);
+    if (file.open(Framework::File::Style::read))
     {
         ChunkMap* map = new ChunkMap(&file);
         file.close();
@@ -175,16 +175,16 @@ void DimensionMap::saveMap(char* addr, int addrLen)
     ChunkMap* map = chunks->z(addr, addrLen);
     if (map)
     {
-        Framework::Datei file;
+        Framework::File file;
         Framework::Text filePath = Game::INSTANCE->getWorldDirectory() + "/dim/"
                                  + dimensionId + "/map/";
         filePath.appendHex(map->getChunkCenter().x);
         filePath += "_";
         filePath.appendHex(map->getChunkCenter().y);
         filePath += ".map";
-        file.setDatei(filePath);
-        file.erstellen();
-        if (file.open(Framework::Datei::Style::schreiben))
+        file.setFile(filePath);
+        file.create();
+        if (file.open(Framework::File::Style::write))
         {
             map->writeTo(&file);
             file.close();
@@ -212,7 +212,7 @@ void DimensionMap::removeMap(char* addr, int addrLen)
 }
 
 ChunkMap* DimensionMap::getMap(
-    char* addr, int addrLen, Framework::Punkt chunkCenter)
+    char* addr, int addrLen, Framework::Point chunkCenter)
 {
     cs.lock();
     ChunkMap* map = chunks->get(addr, addrLen);

FactoryCraft/DimensionMap.h

@@ -5,7 +5,7 @@
 #include <ReferenceCounter.h>
 #include <Trie.h>
 #include <Critical.h>
-#include <Punkt.h>
+#include <Point.h>
 
 class Dimension;
 class NetworkMessage;
@@ -21,7 +21,7 @@ private:
     Framework::Array<int> observers;
     int dimensionId;
 
-    ChunkMap* load(Framework::Punkt chunkCenter);
+    ChunkMap* load(Framework::Point chunkCenter);
 
 public:
     DimensionMap(int dimensionId);
@@ -36,5 +36,5 @@ public:
     void onMapUpdated(char* addr, int addrLen);
     void saveMap(char* addr, int addrLen);
     void removeMap(char* addr, int addrLen);
-    ChunkMap* getMap(char* addr, int addrLen, Framework::Punkt chunkCenter);
+    ChunkMap* getMap(char* addr, int addrLen, Framework::Point chunkCenter);
 };

FactoryCraft/DropConditionOperator.cpp

@@ -123,7 +123,7 @@ DropConditionOperator* DropConditionOperatorFactory::fromJson(
     Framework::JSON::JSONObject* zJson) const
 {
     DropConditionOperator* result = new DropConditionOperator(
-        zJson->zValue("operator")->asString()->getString().istGleich("AND")
+        zJson->zValue("operator")->asString()->getString().isEqual("AND")
             ? AND
             : OR);
     for (Framework::JSON::JSONValue* value :

FactoryCraft/Entity.cpp

@@ -201,44 +201,44 @@ void ActionTarget::save(ActionTarget* zTarget, Framework::StreamWriter* zWriter)
         if (zTarget->entityId >= 0)
         {
             char b = 1;
-            zWriter->schreibe(&b, 1);
-            zWriter->schreibe((char*)&zTarget->entityId, 4);
+            zWriter->write(&b, 1);
+            zWriter->write((char*)&zTarget->entityId, 4);
         }
         else
         {
             char b = 2;
-            zWriter->schreibe(&b, 1);
-            zWriter->schreibe((char*)&zTarget->blockPos.x, 4);
-            zWriter->schreibe((char*)&zTarget->blockPos.y, 4);
-            zWriter->schreibe((char*)&zTarget->blockPos.z, 4);
-            zWriter->schreibe((char*)&zTarget->targetBlockSide, 4);
+            zWriter->write(&b, 1);
+            zWriter->write((char*)&zTarget->blockPos.x, 4);
+            zWriter->write((char*)&zTarget->blockPos.y, 4);
+            zWriter->write((char*)&zTarget->blockPos.z, 4);
+            zWriter->write((char*)&zTarget->targetBlockSide, 4);
         }
     }
     else
     {
         char b = 0;
-        zWriter->schreibe(&b, 1);
+        zWriter->write(&b, 1);
     }
 }
 
 ActionTarget* ActionTarget::load(Framework::StreamReader* zReader)
 {
     char b;
-    zReader->lese(&b, 1);
+    zReader->read(&b, 1);
     if (b == 1)
     {
         int id;
-        zReader->lese((char*)&id, 4);
+        zReader->read((char*)&id, 4);
         return new ActionTarget(id);
     }
     else if (b == 2)
     {
         Framework::Vec3<int> pos;
         Direction side;
-        zReader->lese((char*)&pos.x, 4);
-        zReader->lese((char*)&pos.y, 4);
-        zReader->lese((char*)&pos.z, 4);
-        zReader->lese((char*)&side, 4);
+        zReader->read((char*)&pos.x, 4);
+        zReader->read((char*)&pos.y, 4);
+        zReader->read((char*)&pos.z, 4);
+        zReader->read((char*)&side, 4);
         return new ActionTarget(pos, side);
     }
     return 0;
@@ -249,7 +249,7 @@ Entity::Entity(
     : Inventory(location, dimensionId, true),
       chatSecurityLevel(0),
       lastChunkCenter(0, 0),
-      lastSavedChunkCenter(Framework::Maybe<Framework::Punkt>::empty()),
+      lastSavedChunkCenter(Framework::Maybe<Framework::Point>::empty()),
       lastDimensionId(-1),
       maxMovementSpeed(0.f),
       speed(0, 0, 0),
@@ -555,7 +555,7 @@ void Entity::calculateTarget(const Item* zItem)
         break;
     }
     float distSq = Framework::Vec3<float>((float)px, (float)py, (float)pz)
-                       .abstandSq(headPosition);
+                       .distanceSq(headPosition);
     Entity* zte = Game::INSTANCE->zDimension(dimensionId)
                       ->zTarget(headPosition, direction, distSq);
     if (zte)
@@ -1211,7 +1211,7 @@ void Entity::tick(const Dimension* zDimension, double seconds)
             }
         }
     }
-    Framework::Punkt chunkCenter
+    Framework::Point chunkCenter
         = Game::INSTANCE->getChunkCenter((int)location.x, (int)location.y);
     Chunk* zCurrentChunk = 0;
     if (dimensionId != lastDimensionId || chunkCenter != lastChunkCenter)
@@ -1261,18 +1261,18 @@ void Entity::api(Framework::StreamReader* zRequest,
     Entity* zSource)
 {
     char type;
-    zRequest->lese(&type, 1);
+    zRequest->read(&type, 1);
     switch (type)
     {
     case 0: // request status bar state
         {
             char len;
-            zRequest->lese(&len, 1);
+            zRequest->read(&len, 1);
             char* guiId = new char[(int)len + 1];
-            zRequest->lese(guiId, len);
+            zRequest->read(guiId, len);
             guiId[(int)len] = 0;
             int processor;
-            zRequest->lese((char*)&processor, 4);
+            zRequest->read((char*)&processor, 4);
             zResponse->addressUIElement(guiId, processor);
             statusBarObservable.addObserver(zSource, guiId, processor);
             char* msg = new char[33];
@@ -1292,12 +1292,12 @@ void Entity::api(Framework::StreamReader* zRequest,
     case 1: // remove status bar observer
         {
             char len;
-            zRequest->lese(&len, 1);
+            zRequest->read(&len, 1);
             char* guiId = new char[(int)len + 1];
-            zRequest->lese(guiId, len);
+            zRequest->read(guiId, len);
             guiId[(int)len] = 0;
             int processor;
-            zRequest->lese((char*)&processor, 4);
+            zRequest->read((char*)&processor, 4);
             statusBarObservable.removeObserver(zSource, guiId, processor);
             delete[] guiId;
             break;
@@ -1519,17 +1519,17 @@ int Entity::getChatSecurityLevel() const
     return chatSecurityLevel;
 }
 
-Framework::Maybe<Framework::Punkt> Entity::getLastSavedChunkCenter() const
+Framework::Maybe<Framework::Point> Entity::getLastSavedChunkCenter() const
 {
     return lastSavedChunkCenter;
 }
 
-void Entity::setLastSavedChunkCenter(Framework::Punkt pos)
+void Entity::setLastSavedChunkCenter(Framework::Point pos)
 {
-    lastSavedChunkCenter = Framework::Maybe<Framework::Punkt>::of(pos);
+    lastSavedChunkCenter = Framework::Maybe<Framework::Point>::of(pos);
 }
 
-void Entity::setLastChunk(int dimensionId, Framework::Punkt chankCenter)
+void Entity::setLastChunk(int dimensionId, Framework::Point chankCenter)
 {
     lastDimensionId = dimensionId;
     lastChunkCenter = chankCenter;

FactoryCraft/Entity.h

@@ -3,7 +3,7 @@
 #include <Maybe.h>
 #include <Vec3.h>
 #include <Writer.h>
-#include <Zeit.h>
+#include <Timer.h>
 
 #include "Inventory.h"
 #include "ItemSkill.h"
@@ -66,9 +66,9 @@ private:
     float currentHP;
     float thirst;
     int chatSecurityLevel;
-    Framework::Punkt lastChunkCenter;
+    Framework::Point lastChunkCenter;
     int lastDimensionId;
-    Framework::Maybe<Framework::Punkt> lastSavedChunkCenter;
+    Framework::Maybe<Framework::Point> lastSavedChunkCenter;
 
 protected:
     float maxHP;
@@ -155,9 +155,9 @@ public:
     float getMaxSpeed() const;
     bool isMoving() const;
     int getChatSecurityLevel() const;
-    Framework::Maybe<Framework::Punkt> getLastSavedChunkCenter() const;
-    void setLastSavedChunkCenter(Framework::Punkt pos);
-    void setLastChunk(int dimensionId, Framework::Punkt chankCenter);
+    Framework::Maybe<Framework::Point> getLastSavedChunkCenter() const;
+    void setLastSavedChunkCenter(Framework::Point pos);
+    void setLastChunk(int dimensionId, Framework::Point chankCenter);
     void setRemoved();
     double getHitDistance(Framework::Vec3<float> rayOrigin,
         Framework::Vec3<float> rayDirection) const;

FactoryCraft/EntityType.cpp

@@ -20,37 +20,37 @@ void EntityType::loadSuperEntity(
     Entity* zEntity, Framework::StreamReader* zReader) const
 {
     zEntity->loadInventory(zReader);
-    zReader->lese((char*)&zEntity->id, 4);
-    zReader->lese((char*)&zEntity->maxHP, 4);
-    zReader->lese((char*)&zEntity->currentHP, 4);
-    zReader->lese((char*)&zEntity->stamina, 4);
-    zReader->lese((char*)&zEntity->maxStamina, 4);
-    zReader->lese((char*)&zEntity->hunger, 4);
-    zReader->lese((char*)&zEntity->maxHunger, 4);
-    zReader->lese((char*)&zEntity->thirst, 4);
-    zReader->lese((char*)&zEntity->chatSecurityLevel, 4);
-    zReader->lese((char*)&zEntity->maxThirst, 4);
-    zReader->lese((char*)&zEntity->speed.x, 4);
-    zReader->lese((char*)&zEntity->speed.y, 4);
-    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->dimensionId, 4);
-    zReader->lese((char*)&zEntity->location.x, 4);
-    zReader->lese((char*)&zEntity->location.y, 4);
-    zReader->lese((char*)&zEntity->location.z, 4);
-    zReader->lese((char*)&zEntity->gravityMultiplier, 4);
-    zReader->lese((char*)&zEntity->jumpSpeed, 4);
+    zReader->read((char*)&zEntity->id, 4);
+    zReader->read((char*)&zEntity->maxHP, 4);
+    zReader->read((char*)&zEntity->currentHP, 4);
+    zReader->read((char*)&zEntity->stamina, 4);
+    zReader->read((char*)&zEntity->maxStamina, 4);
+    zReader->read((char*)&zEntity->hunger, 4);
+    zReader->read((char*)&zEntity->maxHunger, 4);
+    zReader->read((char*)&zEntity->thirst, 4);
+    zReader->read((char*)&zEntity->chatSecurityLevel, 4);
+    zReader->read((char*)&zEntity->maxThirst, 4);
+    zReader->read((char*)&zEntity->speed.x, 4);
+    zReader->read((char*)&zEntity->speed.y, 4);
+    zReader->read((char*)&zEntity->speed.z, 4);
+    zReader->read((char*)&zEntity->faceDir.x, 4);
+    zReader->read((char*)&zEntity->faceDir.y, 4);
+    zReader->read((char*)&zEntity->dimensionId, 4);
+    zReader->read((char*)&zEntity->location.x, 4);
+    zReader->read((char*)&zEntity->location.y, 4);
+    zReader->read((char*)&zEntity->location.z, 4);
+    zReader->read((char*)&zEntity->gravityMultiplier, 4);
+    zReader->read((char*)&zEntity->jumpSpeed, 4);
     if (zEntity->target) delete zEntity->target;
     zEntity->target = ActionTarget::load(zReader);
     // load item skills
-    zEntity->skills.leeren();
+    zEntity->skills.clear();
     int skillCount;
-    zReader->lese((char*)&skillCount, 4);
+    zReader->read((char*)&skillCount, 4);
     for (int i = 0; i < skillCount; i++)
     {
         int type;
-        zReader->lese((char*)&type, 4);
+        zReader->read((char*)&type, 4);
         ItemSkill* skill
             = Game::INSTANCE->zItemType(type)->createDefaultItemSkill();
         skill->load(zReader);
@@ -62,35 +62,35 @@ void EntityType::saveSuperEntity(
     Entity* zEntity, Framework::StreamWriter* zWriter) const
 {
     zEntity->saveInventory(zWriter);
-    zWriter->schreibe((char*)&zEntity->id, 4);
-    zWriter->schreibe((char*)&zEntity->maxHP, 4);
-    zWriter->schreibe((char*)&zEntity->currentHP, 4);
-    zWriter->schreibe((char*)&zEntity->stamina, 4);
-    zWriter->schreibe((char*)&zEntity->maxStamina, 4);
-    zWriter->schreibe((char*)&zEntity->hunger, 4);
-    zWriter->schreibe((char*)&zEntity->maxHunger, 4);
-    zWriter->schreibe((char*)&zEntity->thirst, 4);
-    zWriter->schreibe((char*)&zEntity->chatSecurityLevel, 4);
-    zWriter->schreibe((char*)&zEntity->maxThirst, 4);
-    zWriter->schreibe((char*)&zEntity->speed.x, 4);
-    zWriter->schreibe((char*)&zEntity->speed.y, 4);
-    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->dimensionId, 4);
-    zWriter->schreibe((char*)&zEntity->location.x, 4);
-    zWriter->schreibe((char*)&zEntity->location.y, 4);
-    zWriter->schreibe((char*)&zEntity->location.z, 4);
-    zWriter->schreibe((char*)&zEntity->gravityMultiplier, 4);
-    zWriter->schreibe((char*)&zEntity->jumpSpeed, 4);
+    zWriter->write((char*)&zEntity->id, 4);
+    zWriter->write((char*)&zEntity->maxHP, 4);
+    zWriter->write((char*)&zEntity->currentHP, 4);
+    zWriter->write((char*)&zEntity->stamina, 4);
+    zWriter->write((char*)&zEntity->maxStamina, 4);
+    zWriter->write((char*)&zEntity->hunger, 4);
+    zWriter->write((char*)&zEntity->maxHunger, 4);
+    zWriter->write((char*)&zEntity->thirst, 4);
+    zWriter->write((char*)&zEntity->chatSecurityLevel, 4);
+    zWriter->write((char*)&zEntity->maxThirst, 4);
+    zWriter->write((char*)&zEntity->speed.x, 4);
+    zWriter->write((char*)&zEntity->speed.y, 4);
+    zWriter->write((char*)&zEntity->speed.z, 4);
+    zWriter->write((char*)&zEntity->faceDir.x, 4);
+    zWriter->write((char*)&zEntity->faceDir.y, 4);
+    zWriter->write((char*)&zEntity->dimensionId, 4);
+    zWriter->write((char*)&zEntity->location.x, 4);
+    zWriter->write((char*)&zEntity->location.y, 4);
+    zWriter->write((char*)&zEntity->location.z, 4);
+    zWriter->write((char*)&zEntity->gravityMultiplier, 4);
+    zWriter->write((char*)&zEntity->jumpSpeed, 4);
     ActionTarget::save(zEntity->target, zWriter);
     // save item skills
-    int skillCount = zEntity->skills.getEintragAnzahl();
-    zWriter->schreibe((char*)&skillCount, 4);
+    int skillCount = zEntity->skills.getEntryCount();
+    zWriter->write((char*)&skillCount, 4);
     for (ItemSkill* skill : zEntity->skills)
     {
         int type = skill->getItemTypeId();
-        zWriter->schreibe((char*)&type, 4);
+        zWriter->write((char*)&type, 4);
         skill->save(zWriter);
     }
 }

FactoryCraft/FireBasedProcessingBlockComponent.cpp

@@ -51,12 +51,12 @@ bool FireBasedProcessingBlockComponent::consumeFuel()
         if (slot->zStack())
         {
             if (!burning && !fireStartingSlot
-                && slot->getName().istGleich(fireStartingInventorySlotName)
+                && slot->getName().isEqual(fireStartingInventorySlotName)
                 && fireStartingItemFilter->matchItem(slot->zStack()->zItem()))
             {
                 fireStartingSlot = slot;
             }
-            if (!fuelSlot && slot->getName().istGleich(fuelInventorySlotName)
+            if (!fuelSlot && slot->getName().isEqual(fuelInventorySlotName)
                 && fuelItemFilter->matchItem(slot->zStack()->zItem()))
             {
                 fuelSlot = slot;
@@ -265,18 +265,18 @@ void FireBasedProcessingBlockComponent::api(Framework::StreamReader* zRequest,
     Entity* zSource)
 {
     char type;
-    zRequest->lese(&type, 1);
+    zRequest->read(&type, 1);
     switch (type)
     {
     case 0: // subscribe to fuel
         {
             char idLen;
-            zRequest->lese(&idLen, 1);
+            zRequest->read(&idLen, 1);
             char* id = new char[idLen + 1];
-            zRequest->lese(id, idLen);
+            zRequest->read(id, idLen);
             id[(int)idLen] = 0;
             int processor;
-            zRequest->lese((char*)&processor, 4);
+            zRequest->read((char*)&processor, 4);
             fuelObservable.addObserver(zSource, id, processor);
             createFuelMessage(zResponse);
             zResponse->addressUIElement(id, processor);
@@ -285,12 +285,12 @@ void FireBasedProcessingBlockComponent::api(Framework::StreamReader* zRequest,
     case 1: // subscribe to progress
         {
             char idLen;
-            zRequest->lese(&idLen, 1);
+            zRequest->read(&idLen, 1);
             char* id = new char[idLen + 1];
-            zRequest->lese(id, idLen);
+            zRequest->read(id, idLen);
             id[(int)idLen] = 0;
             int processor;
-            zRequest->lese((char*)&processor, 4);
+            zRequest->read((char*)&processor, 4);
             progressObservable.addObserver(zSource, id, processor);
             createProgressMessage(zResponse);
             zResponse->addressUIElement(id, processor);
@@ -299,24 +299,24 @@ void FireBasedProcessingBlockComponent::api(Framework::StreamReader* zRequest,
     case 2: // unsubscribe to fuel
         {
             char idLen;
-            zRequest->lese(&idLen, 1);
+            zRequest->read(&idLen, 1);
             char* id = new char[idLen + 1];
-            zRequest->lese(id, idLen);
+            zRequest->read(id, idLen);
             id[(int)idLen] = 0;
             int processor;
-            zRequest->lese((char*)&processor, 4);
+            zRequest->read((char*)&processor, 4);
             fuelObservable.removeObserver(zSource, id, processor);
             break;
         }
     case 3: // unsubscribe to progress
         {
             char idLen;
-            zRequest->lese(&idLen, 1);
+            zRequest->read(&idLen, 1);
             char* id = new char[idLen + 1];
-            zRequest->lese(id, idLen);
+            zRequest->read(id, idLen);
             id[(int)idLen] = 0;
             int processor;
-            zRequest->lese((char*)&processor, 4);
+            zRequest->read((char*)&processor, 4);
             progressObservable.removeObserver(zSource, id, processor);
             break;
         }
@@ -391,12 +391,12 @@ int FireBasedProcessingBlockComponent::getStorageDimensionId() const
 void FireBasedProcessingBlockComponent::loadComponent(
     Framework::StreamReader* zReader)
 {
-    zReader->lese((char*)&ticksNeeded, 4);
-    zReader->lese((char*)&maxFuelBuffer, 4);
-    zReader->lese((char*)&fuelBuffer, 4);
-    zReader->lese((char*)&burning, 1);
+    zReader->read((char*)&ticksNeeded, 4);
+    zReader->read((char*)&maxFuelBuffer, 4);
+    zReader->read((char*)&fuelBuffer, 4);
+    zReader->read((char*)&burning, 1);
     int index = 0;
-    zReader->lese((char*)&index, 4);
+    zReader->read((char*)&index, 4);
     if (index >= 0)
     {
         // TODO: add unique recipie ids to enshure correct loading after
@@ -413,10 +413,10 @@ void FireBasedProcessingBlockComponent::loadComponent(
 void FireBasedProcessingBlockComponent::saveComponent(
     Framework::StreamWriter* zWriter) const
 {
-    zWriter->schreibe((char*)&ticksNeeded, 4);
-    zWriter->schreibe((char*)&maxFuelBuffer, 4);
-    zWriter->schreibe((char*)&fuelBuffer, 4);
-    zWriter->schreibe((char*)&burning, 1);
+    zWriter->write((char*)&ticksNeeded, 4);
+    zWriter->write((char*)&maxFuelBuffer, 4);
+    zWriter->write((char*)&fuelBuffer, 4);
+    zWriter->write((char*)&burning, 1);
     int index = -1;
     if (currentRecipie)
     {
@@ -429,7 +429,7 @@ void FireBasedProcessingBlockComponent::saveComponent(
             index = recipies->getRecipieIndex(currentRecipie);
         }
     }
-    zWriter->schreibe((char*)&index, 4);
+    zWriter->write((char*)&index, 4);
 }
 
 bool FireBasedProcessingBlockComponent::isLightSource() const

FactoryCraft/FluidBlock.cpp

@@ -214,8 +214,8 @@ void FluidBlockType::loadSuperBlock(
     Block* zBlock, Framework::StreamReader* zReader, int dimensionId) const
 {
     FluidBlock* block = dynamic_cast<FluidBlock*>(zBlock);
-    zReader->lese(&block->flowOptions, 1);
-    zReader->lese(&block->distanceToSource, 1);
+    zReader->read(&block->flowOptions, 1);
+    zReader->read(&block->distanceToSource, 1);
     block->nextFlow = ticktsToFlow;
     block->maxFlowDistance = flowDistance;
     BlockType::loadSuperBlock(zBlock, zReader, dimensionId);
@@ -225,8 +225,8 @@ void FluidBlockType::saveSuperBlock(
     Block* zBlock, Framework::StreamWriter* zWriter) const
 {
     FluidBlock* block = dynamic_cast<FluidBlock*>(zBlock);
-    zWriter->schreibe(&block->flowOptions, 1);
-    zWriter->schreibe(&block->distanceToSource, 1);
+    zWriter->write(&block->flowOptions, 1);
+    zWriter->write(&block->distanceToSource, 1);
     BlockType::saveSuperBlock(zBlock, zWriter);
 }
 

FactoryCraft/FluidContainer.cpp

@@ -558,8 +558,8 @@ void FluidContainerItemType::loadSuperItem(
     FluidContainerItem* item = dynamic_cast<FluidContainerItem*>(zItem);
     if (item)
     {
-        zReader->lese((char*)&item->fluidTypeId, 4);
-        zReader->lese((char*)&item->fluidAmount, 4);
+        zReader->read((char*)&item->fluidTypeId, 4);
+        zReader->read((char*)&item->fluidAmount, 4);
     }
     else
     {
@@ -576,8 +576,8 @@ void FluidContainerItemType::saveSuperItem(
         = dynamic_cast<const FluidContainerItem*>(zItem);
     if (item)
     {
-        zWriter->schreibe((char*)&item->fluidTypeId, 4);
-        zWriter->schreibe((char*)&item->fluidAmount, 4);
+        zWriter->write((char*)&item->fluidTypeId, 4);
+        zWriter->write((char*)&item->fluidAmount, 4);
     }
     else
     {
@@ -614,7 +614,7 @@ void FluidContainerItemType::setItemAttribute(
                "zItem is not a FluidContainerItem";
         return;
     }
-    if (name.istGleich("fluidType"))
+    if (name.isEqual("fluidType"))
     {
         if (zValue->getType() == Framework::AbstractType::STRING)
         {
@@ -637,7 +637,7 @@ void FluidContainerItemType::setItemAttribute(
                    "'fluidType' is not a string or string";
         }
     }
-    else if (name.istGleich("fluidAmount"))
+    else if (name.isEqual("fluidAmount"))
     {
         if (zValue->getType() == Framework::AbstractType::NUMBER)
         {

FactoryCraft/Game.cpp

@@ -1,6 +1,6 @@
 #include "Game.h"
 
-#include <Datei.h>
+#include <File.h>
 #include <Logging.h>
 
 #include "Chat.h"
@@ -21,7 +21,7 @@
 #include "UIController.h"
 #include "WorldGenerator.h"
 #include "WorldLoader.h"
-#include "Zeit.h"
+#include "Timer.h"
 
 using namespace Framework;
 
@@ -67,13 +67,13 @@ Game::Game(Framework::Text name, Framework::Text worldsDir)
     typeRegistry->registerType(
         ItemTypeNameFactory::TYPE_ID, itemTypeNameFactory);
 
-    if (!DateiExistiert(path)) DateiPfadErstellen(path + "/");
-    Datei d;
-    d.setDatei(path + "/eid");
-    if (d.existiert())
+    if (!FileExists(path)) FilePathCreate(path + "/");
+    File d;
+    d.setFile(path + "/eid");
+    if (d.exists())
     {
-        d.open(Datei::Style::lesen);
-        d.lese((char*)&nextEntityId, 4);
+        d.open(File::Style::read);
+        d.read((char*)&nextEntityId, 4);
         d.close();
     }
     start();
@@ -150,9 +150,9 @@ void Game::initialize()
             }
         });
     validator->release();
-    Framework::Logging::info() << "Loaded " << blockTypeArray.getEintragAnzahl()
+    Framework::Logging::info() << "Loaded " << blockTypeArray.getEntryCount()
                                << " block types from data/blocks";
-    blockTypes = new BlockType*[2 + blockTypeArray.getEintragAnzahl()];
+    blockTypes = new BlockType*[2 + blockTypeArray.getEntryCount()];
     blockTypes[0] = new NoBlockBlockType(
         dynamic_cast<Block*>(NoBlock::INSTANCE.getThis()),
         "__not_yet_generated");
@@ -205,10 +205,10 @@ void Game::initialize()
             }
         });
     validator->release();
-    Framework::Logging::info() << "Loaded " << itemTypeArray.getEintragAnzahl()
+    Framework::Logging::info() << "Loaded " << itemTypeArray.getEntryCount()
                                << " item types from data/items";
     itemTypes
-        = new ItemType*[blockTypeCount + itemTypeArray.getEintragAnzahl()];
+        = new ItemType*[blockTypeCount + itemTypeArray.getEntryCount()];
     itemTypes[0] = new PlayerHandItemType();
     itemTypeCount = 1;
     for (int i = 0; i < blockTypeCount; i++)
@@ -266,9 +266,9 @@ void Game::initialize()
         });
     validator->release();
     Framework::Logging::info()
-        << "Loaded " << entityTypeArray.getEintragAnzahl()
+        << "Loaded " << entityTypeArray.getEntryCount()
         << " entity types from data/entities";
-    entityTypes = new EntityType*[2 + entityTypeArray.getEintragAnzahl()];
+    entityTypes = new EntityType*[2 + entityTypeArray.getEntryCount()];
     entityTypes[0] = new PlayerEntityType();
     entityTypes[1] = new ItemEntityType();
     entityTypeCount = 2;
@@ -343,7 +343,7 @@ void Game::initialize()
     multiblockStructureTypes[0] = new MultiblockTreeStructureType();
     multiblockStructureTypeCount = 1;
     // save syntax info
-    Framework::DateiRemove("data/syntax");
+    Framework::FileRemove("data/syntax");
     // typeRegistry->writeSyntaxInfo("data/syntax");
 
     validator
@@ -351,11 +351,11 @@ void Game::initialize()
               ->addAcceptedTypeInArray(typeRegistry->getValidator<BlockType>())
               ->finishArray();
     Framework::JSON::JSONObject* schema = validator->getJsonSchema();
-    Framework::Datei syntaxFile;
-    syntaxFile.setDatei("data/syntax/schema/blocks.json");
-    syntaxFile.erstellen();
-    syntaxFile.open(Framework::Datei::Style::schreiben);
-    syntaxFile.schreibe(schema->toString(), schema->toString().getLength());
+    Framework::File syntaxFile;
+    syntaxFile.setFile("data/syntax/schema/blocks.json");
+    syntaxFile.create();
+    syntaxFile.open(Framework::File::Style::write);
+    syntaxFile.write(schema->toString(), schema->toString().getLength());
     syntaxFile.close();
     schema->release();
     validator->release();
@@ -365,10 +365,10 @@ void Game::initialize()
               ->addAcceptedTypeInArray(typeRegistry->getValidator<ItemType>())
               ->finishArray();
     schema = validator->getJsonSchema();
-    syntaxFile.setDatei("data/syntax/schema/items.json");
-    syntaxFile.erstellen();
-    syntaxFile.open(Framework::Datei::Style::schreiben);
-    syntaxFile.schreibe(schema->toString(), schema->toString().getLength());
+    syntaxFile.setFile("data/syntax/schema/items.json");
+    syntaxFile.create();
+    syntaxFile.open(Framework::File::Style::write);
+    syntaxFile.write(schema->toString(), schema->toString().getLength());
     syntaxFile.close();
     schema->release();
     validator->release();
@@ -377,10 +377,10 @@ void Game::initialize()
               ->addAcceptedTypeInArray(typeRegistry->getValidator<EntityType>())
               ->finishArray();
     schema = validator->getJsonSchema();
-    syntaxFile.setDatei("data/syntax/schema/entities.json");
-    syntaxFile.erstellen();
-    syntaxFile.open(Framework::Datei::Style::schreiben);
-    syntaxFile.schreibe(schema->toString(), schema->toString().getLength());
+    syntaxFile.setFile("data/syntax/schema/entities.json");
+    syntaxFile.create();
+    syntaxFile.open(Framework::File::Style::write);
+    syntaxFile.write(schema->toString(), schema->toString().getLength());
     syntaxFile.close();
     schema->release();
     validator->release();
@@ -402,13 +402,13 @@ void Game::initialize()
 
 void Game::thread()
 {
-    ZeitMesser waitForLock;
-    ZeitMesser removeOldClients;
-    ZeitMesser clientReply;
-    ZeitMesser removeOldChunks;
-    ZeitMesser m;
-    ZeitMesser total;
-    total.messungStart();
+    Timer waitForLock;
+    Timer removeOldClients;
+    Timer clientReply;
+    Timer removeOldChunks;
+    Timer m;
+    Timer total;
+    total.measureStart();
     double tickTime = 0;
     double sleepTime = 0;
     int nextTimeSync = MAX_TICKS_PER_SECOND;
@@ -421,10 +421,10 @@ void Game::thread()
             questManager->processEvent(new QuestEventTimeUpdate());
             ticktToNextUpdate = MAX_TICKS_PER_SECOND * 5;
         }
-        m.messungStart();
+        m.measureStart();
         ticker->nextTick();
         actionsCs.lock();
-        while (actions.getEintragAnzahl() > 0)
+        while (actions.getEntryCount() > 0)
         {
             actions.get(0)();
             actions.remove(0);
@@ -432,11 +432,11 @@ void Game::thread()
         actionsCs.unlock();
         Array<int> removed;
         double waitTotal = 0;
-        waitForLock.messungStart();
+        waitForLock.measureStart();
         cs.lock();
-        waitForLock.messungEnde();
+        waitForLock.measureEnd();
         waitTotal += waitForLock.getSekunden();
-        removeOldClients.messungStart();
+        removeOldClients.measureStart();
         int index = 0;
         nextTimeSync--;
         for (auto player : *clients)
@@ -449,11 +449,11 @@ void Game::thread()
                     Framework::Text(player->zEntity()->getName())
                         + " left the game.",
                     Chat::CHANNEL_INFO);
-                Datei pFile;
-                pFile.setDatei(path + "/player/"
+                File pFile;
+                pFile.setFile(path + "/player/"
                                + getPlayerId(player->zEntity()->getName()));
-                pFile.erstellen();
-                if (pFile.open(Datei::Style::schreiben))
+                pFile.create();
+                if (pFile.open(File::Style::write))
                 {
                     zEntityType(EntityTypeEnum::PLAYER)
                         ->saveEntity(player->zEntity(), &pFile);
@@ -498,26 +498,26 @@ void Game::thread()
         }
         for (auto i : removed)
             clients->remove(i);
-        removeOldClients.messungEnde();
+        removeOldClients.measureEnd();
         for (Dimension* dim : *dimensions)
         {
             dim->tick();
         }
         cs.unlock();
-        clientReply.messungStart();
+        clientReply.measureStart();
         for (auto client : *clients)
             client->reply();
-        clientReply.messungEnde();
-        waitForLock.messungStart();
+        clientReply.measureEnd();
+        waitForLock.measureStart();
         cs.lock();
-        waitForLock.messungEnde();
+        waitForLock.measureEnd();
         waitTotal += waitForLock.getSekunden();
-        removeOldChunks.messungStart();
+        removeOldChunks.measureStart();
         for (auto dim : *dimensions)
             dim->removeOldChunks();
-        removeOldChunks.messungEnde();
+        removeOldChunks.measureEnd();
         cs.unlock();
-        m.messungEnde();
+        m.measureEnd();
         double sec = m.getSekunden();
         tickCounter++;
         totalTickTime += sec;
@@ -526,8 +526,8 @@ void Game::thread()
         {
             Sleep((int)(sleepTime * 1000));
         }
-        total.messungEnde();
-        total.messungStart();
+        total.measureEnd();
+        total.measureStart();
         tickTime = total.getSekunden();
         totalTime += tickTime;
         if (totalTime >= 1)
@@ -562,7 +562,7 @@ void Game::thread()
 void Game::api(Framework::InMemoryBuffer* zRequest, GameClient* zOrigin)
 {
     char type;
-    zRequest->lese(&type, 1);
+    zRequest->read(&type, 1);
     NetworkMessage* response = new NetworkMessage();
     switch (type)
     {
@@ -592,7 +592,7 @@ void Game::api(Framework::InMemoryBuffer* zRequest, GameClient* zOrigin)
     case 3: // entity
         {
             int id;
-            zRequest->lese((char*)&id, 4);
+            zRequest->read((char*)&id, 4);
             for (Dimension* dim : *dimensions)
             {
                 Entity* entity = dim->zEntity(id);
@@ -607,22 +607,22 @@ void Game::api(Framework::InMemoryBuffer* zRequest, GameClient* zOrigin)
     case 4:
         { // inventory
             bool isEntity;
-            zRequest->lese((char*)&isEntity, 1);
+            zRequest->read((char*)&isEntity, 1);
             Inventory* target;
             if (isEntity)
             {
                 int id;
-                zRequest->lese((char*)&id, 4);
+                zRequest->read((char*)&id, 4);
                 target = zEntity(id);
             }
             else
             {
                 int dim;
                 Vec3<int> pos;
-                zRequest->lese((char*)&dim, 4);
-                zRequest->lese((char*)&pos.x, 4);
-                zRequest->lese((char*)&pos.y, 4);
-                zRequest->lese((char*)&pos.z, 4);
+                zRequest->read((char*)&dim, 4);
+                zRequest->read((char*)&pos.x, 4);
+                zRequest->read((char*)&pos.y, 4);
+                zRequest->read((char*)&pos.z, 4);
                 target = zBlockAt(pos, dim, 0);
             }
             if (target)
@@ -632,7 +632,7 @@ void Game::api(Framework::InMemoryBuffer* zRequest, GameClient* zOrigin)
     case 5:
         { // crafting uiml request
             int id;
-            zRequest->lese((char*)&id, 4);
+            zRequest->read((char*)&id, 4);
             Framework::XML::Element* uiml = recipies->getCrafingUIML(id);
             Text dialogId = "crafting_";
             dialogId += id;
@@ -648,7 +648,7 @@ void Game::api(Framework::InMemoryBuffer* zRequest, GameClient* zOrigin)
     case 7: // other dimension
         {
             int dimensionId;
-            zRequest->lese((char*)&dimensionId, 4);
+            zRequest->read((char*)&dimensionId, 4);
             Dimension* dim = zDimension(dimensionId);
             if (dim)
             {
@@ -738,11 +738,11 @@ GameClient* Game::addPlayer(FCKlient* client, Framework::Text name)
 {
     cs.lock();
     int id = playerRegister->getPlayerId(name);
-    Datei pFile;
-    pFile.setDatei(path + "/player/" + id);
+    File pFile;
+    pFile.setFile(path + "/player/" + id);
     Player* player;
     bool isNew = 0;
-    if (!pFile.existiert() || !pFile.open(Datei::Style::lesen))
+    if (!pFile.exists() || !pFile.open(File::Style::read))
     {
         player = (Player*)zEntityType(EntityTypeEnum::PLAYER)
                      ->createEntityAt(
@@ -784,12 +784,12 @@ GameClient* Game::addPlayer(FCKlient* client, Framework::Text name)
     // subscribe the new player as an observer of the new chunk
     Dimension* dim = zDimension(player->getDimensionId());
     InMemoryBuffer* buffer = new InMemoryBuffer();
-    buffer->schreibe("\0", 1);
-    Punkt center = getChunkCenter(
+    buffer->write("\0", 1);
+    Point center = getChunkCenter(
         (int)player->getPosition().x, (int)player->getPosition().y);
-    buffer->schreibe((char*)&center.x, 4);
-    buffer->schreibe((char*)&center.y, 4);
-    buffer->schreibe("\0", 1);
+    buffer->write((char*)&center.x, 4);
+    buffer->write((char*)&center.y, 4);
+    buffer->write("\0", 1);
     dim->api(buffer, 0, player);
     buffer->release();
     while (!dim->zChunk(getChunkCenter(
@@ -886,7 +886,7 @@ void Game::spawnItem(
     Dimension* dim = zDimension(dimensionId);
     if (dim)
     {
-        Punkt center = Game::getChunkCenter(
+        Point center = Game::getChunkCenter(
             (int)itemEntity->getLocation().x, (int)itemEntity->getLocation().y);
         dim->zChunk(center)
             ->onEntityEnters(itemEntity, 0);
@@ -943,15 +943,15 @@ Dimension* Game::zDimension(int id) const
     return 0;
 }
 
-Framework::Punkt Game::getChunkCenter(int x, int y)
+Framework::Point Game::getChunkCenter(int x, int y)
 {
-    return Punkt(((x < 0 ? x + 1 : x) / CHUNK_SIZE) * CHUNK_SIZE
+    return Point(((x < 0 ? x + 1 : x) / CHUNK_SIZE) * CHUNK_SIZE
                      + (x < 0 ? -CHUNK_SIZE : CHUNK_SIZE) / 2,
         ((y < 0 ? y + 1 : y) / CHUNK_SIZE) * CHUNK_SIZE
             + (y < 0 ? -CHUNK_SIZE : CHUNK_SIZE) / 2);
 }
 
-Area Game::getChunckArea(Punkt center) const
+Area Game::getChunckArea(Point center) const
 {
     return {center.x - CHUNK_SIZE / 2,
         center.y - CHUNK_SIZE / 2,
@@ -974,10 +974,10 @@ void Game::requestArea(Area area)
 void Game::save() const
 {
     questManager->saveQuests();
-    Datei d;
-    d.setDatei(path + "/eid");
-    d.open(Datei::Style::schreiben);
-    d.schreibe((char*)&nextEntityId, 4);
+    File d;
+    d.setFile(path + "/eid");
+    d.open(File::Style::write);
+    d.write((char*)&nextEntityId, 4);
     d.close();
     playerRegister->save();
     for (auto dim : *dimensions)
@@ -989,7 +989,7 @@ void Game::save() const
 void Game::requestStop()
 {
     stop = 1;
-    warteAufThread(1000000);
+    waitForThread(1000000);
 }
 
 void Game::addDimension(Dimension* d)
@@ -1129,7 +1129,7 @@ int Game::getTicksPerSecond() const
 
 int Game::getPlayerCount() const
 {
-    return clients->getEintragAnzahl();
+    return clients->getEntryCount();
 }
 
 int Game::getChunkCount() const
@@ -1162,7 +1162,7 @@ int Game::getEntityTypeId(const char* name) const
     for (int i = 0; i < entityTypeCount; i++)
     {
         if (entityTypes[i]
-            && Framework::Text(entityTypes[i]->getName()).istGleich(name))
+            && Framework::Text(entityTypes[i]->getName()).isEqual(name))
         {
             return i;
         }
@@ -1177,7 +1177,7 @@ int Game::getBlockTypeId(const char* name) const
     for (int i = 0; i < blockTypeCount; i++)
     {
         if (blockTypes[i]
-            && Framework::Text(blockTypes[i]->getName()).istGleich(name))
+            && Framework::Text(blockTypes[i]->getName()).isEqual(name))
         {
             return i;
         }
@@ -1192,7 +1192,7 @@ int Game::getItemTypeId(const char* name) const
     for (int i = 0; i < itemTypeCount; i++)
     {
         if (itemTypes[i]
-            && Framework::Text(itemTypes[i]->getName()).istGleich(name))
+            && Framework::Text(itemTypes[i]->getName()).isEqual(name))
         {
             return i;
         }

FactoryCraft/Game.h

@@ -4,7 +4,7 @@
 #include <Critical.h>
 #include <Either.h>
 #include <InMemoryBuffer.h>
-#include <Punkt.h>
+#include <Point.h>
 #include <Text.h>
 #include <Thread.h>
 
@@ -106,8 +106,8 @@ public:
         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;
+    static Framework::Point getChunkCenter(int x, int y);
+    Area getChunckArea(Framework::Point center) const;
     Framework::Text getWorldDirectory() const;
     void requestArea(Area area);
     void save() const;

FactoryCraft/GameClient.cpp

@@ -40,7 +40,7 @@ void GameClient::thread()
         while (online)
         {
             queueCs.lock();
-            if (backgroundQueue.hat(0))
+            if (backgroundQueue.has(0))
             {
                 NetworkMessage* message = backgroundQueue.get(0);
                 backgroundQueue.remove(0);
@@ -65,7 +65,7 @@ void GameClient::thread()
     while (online)
     {
         queueCs.lock();
-        if (foregroundQueue.hat(0))
+        if (foregroundQueue.has(0))
         {
             NetworkMessage* message = foregroundQueue.get(0);
             foregroundQueue.remove(0);
@@ -93,17 +93,17 @@ void GameClient::reply()
     other.lock();
     for (auto req : requests)
         Game::INSTANCE->api(req, this);
-    requests.leeren();
+    requests.clear();
     other.unlock();
     if (first)
     {
         foreground.lock();
         int id = zPlayer->getId();
-        client->zForegroundWriter()->schreibe(
+        client->zForegroundWriter()->write(
             (char*)&Message::POSITION_UPDATE, 1);
-        client->zForegroundWriter()->schreibe((char*)&id, 4);
+        client->zForegroundWriter()->write((char*)&id, 4);
         id = zPlayer->getDimensionId();
-        client->zForegroundWriter()->schreibe((char*)&id, 4);
+        client->zForegroundWriter()->write((char*)&id, 4);
         foreground.unlock();
         first = 0;
     }
@@ -121,11 +121,11 @@ void GameClient::logout()
 void GameClient::addMessage(StreamReader* reader)
 {
     short len = 0;
-    reader->lese((char*)&len, 2);
+    reader->read((char*)&len, 2);
     InMemoryBuffer* buffer = new InMemoryBuffer();
     char* tmp = new char[len];
-    reader->lese(tmp, len);
-    buffer->schreibe(tmp, len);
+    reader->read(tmp, len);
+    buffer->write(tmp, len);
     delete[] tmp;
     other.lock();
     requests.add(buffer);
@@ -142,7 +142,7 @@ void GameClient::sendResponse(NetworkMessage* response)
     queueCs.lock();
     if (response->isUseBackground())
     {
-        if (backgroundQueue.getEintragAnzahl() > 20)
+        if (backgroundQueue.getEntryCount() > 20)
         {
             queueCs.unlock();
             while (!emptyBackgroundQueueSync.wait(1000))
@@ -157,20 +157,20 @@ void GameClient::sendResponse(NetworkMessage* response)
     }
     else
     {
-        if (foregroundQueue.getEintragAnzahl() > 100)
+        if (foregroundQueue.getEntryCount() > 100)
         {
             queueCs.unlock();
             Framework::Logging::warning()
                 << "Game paused because nework connection to "
                 << zPlayer->getName() << " is to slow.";
-            ZeitMesser m;
-            m.messungStart();
-            while (foregroundQueue.getEintragAnzahl() > 0)
+            Timer m;
+            m.measureStart();
+            while (foregroundQueue.getEntryCount() > 0)
             {
                 foregroundQueueSync.notify();
                 emptyForegroundQueueSync.wait(100);
             }
-            m.messungEnde();
+            m.measureEnd();
             Framework::Logging::warning()
                 << "Game resumed after " << m.getSekunden() << " seconds.";
             queueCs.lock();
@@ -194,7 +194,7 @@ void GameClient::sendTypes()
     {
         if (Game::INSTANCE->zBlockType(i)) count++;
     }
-    client->zForegroundWriter()->schreibe((char*)&count, 4);
+    client->zForegroundWriter()->write((char*)&count, 4);
     for (int i = 0; i < Game::INSTANCE->getBlockTypeCount(); i++)
     {
         const BlockType* t = Game::INSTANCE->zBlockType(i);
@@ -208,23 +208,23 @@ void GameClient::sendTypes()
     {
         if (Game::INSTANCE->zItemType(i)) count++;
     }
-    client->zForegroundWriter()->schreibe((char*)&count, 4);
+    client->zForegroundWriter()->write((char*)&count, 4);
     for (int i = 0; i < Game::INSTANCE->getItemTypeCount(); i++)
     {
         const ItemType* t = Game::INSTANCE->zItemType(i);
         if (t)
         {
             int id = t->getId();
-            client->zForegroundWriter()->schreibe((char*)&id, 4);
+            client->zForegroundWriter()->write((char*)&id, 4);
             char len = (char)t->getName().getLength();
-            client->zForegroundWriter()->schreibe((char*)&len, 1);
-            client->zForegroundWriter()->schreibe(t->getName().getText(), len);
+            client->zForegroundWriter()->write((char*)&len, 1);
+            client->zForegroundWriter()->write(t->getName().getText(), len);
             Framework::XML::Element* tooltip = t->getTooltipUIML();
             Framework::Text tooltipText
                 = tooltip ? tooltip->toString() : Framework::Text("");
             short tlen = (short)tooltipText.getLength();
-            client->zForegroundWriter()->schreibe((char*)&tlen, 2);
-            client->zForegroundWriter()->schreibe(tooltipText.getText(), tlen);
+            client->zForegroundWriter()->write((char*)&tlen, 2);
+            client->zForegroundWriter()->write(tooltipText.getText(), tlen);
             tooltip->release();
             if (t->zModel())
             {
@@ -242,12 +242,12 @@ void GameClient::sendTypes()
     {
         if (Game::INSTANCE->zEntityType(i)) count++;
     }
-    client->zForegroundWriter()->schreibe((char*)&count, 4);
+    client->zForegroundWriter()->write((char*)&count, 4);
     for (int i = 0; i < count; i++)
     {
         const EntityType* t = Game::INSTANCE->zEntityType(i);
         int id = t->getId();
-        client->zForegroundWriter()->schreibe((char*)&id, 4);
+        client->zForegroundWriter()->write((char*)&id, 4);
         if (t->zModel())
         {
             t->zModel()->writeTo(client->zForegroundWriter());

FactoryCraft/GrowingPlant.cpp

@@ -101,7 +101,7 @@ void GrowingPlantBlock::sendModelInfo(NetworkMessage* zMessage)
         current->zModel()->writeTo(&buffer);
         char* msg = new char[(int)buffer.getSize() + 1];
         msg[0] = 1; // hmodel change
-        buffer.lese(msg + 1, (int)buffer.getSize());
+        buffer.read(msg + 1, (int)buffer.getSize());
         zMessage->setMessage(msg, (int)buffer.getSize() + 1);
     }
 }
@@ -164,7 +164,7 @@ void GrowingPlantBlockType::loadSuperBlock(
 {
     BlockType::loadSuperBlock(zBlock, zReader, dimensionId);
     GrowingPlantBlock* block = dynamic_cast<GrowingPlantBlock*>(zBlock);
-    zReader->lese((char*)&block->seblingTicks, 4);
+    zReader->read((char*)&block->seblingTicks, 4);
 }
 
 void GrowingPlantBlockType::saveSuperBlock(
@@ -172,7 +172,7 @@ void GrowingPlantBlockType::saveSuperBlock(
 {
     BlockType::saveSuperBlock(zBlock, zWriter);
     GrowingPlantBlock* block = dynamic_cast<GrowingPlantBlock*>(zBlock);
-    zWriter->schreibe((char*)&block->seblingTicks, 4);
+    zWriter->write((char*)&block->seblingTicks, 4);
 }
 
 Item* GrowingPlantBlockType::createItem() const

FactoryCraft/InformationObserver.cpp

@@ -11,7 +11,7 @@ InformationObserver::InformationObserver(int entityId)
 InformationObserver::~InformationObserver()
 {
     cs.lock();
-    waitingMessages.leeren();
+    waitingMessages.clear();
     cs.unlock();
 }
 
@@ -59,6 +59,6 @@ void InformationObserver::setReady()
                 dynamic_cast<NetworkMessage*>(msg->getThis()), e);
         }
     }
-    waitingMessages.leeren();
+    waitingMessages.clear();
     cs.unlock();
 }

FactoryCraft/Inventory.cpp

@@ -419,11 +419,11 @@ void Inventory::loadInventory(Framework::StreamReader* zReader)
         for (auto stack : *pushSlotsOrder)
         {
             int size = 0;
-            zReader->lese((char*)&size, 4);
+            zReader->read((char*)&size, 4);
             if (size != 0)
             {
                 int id = 0;
-                zReader->lese((char*)&id, 4);
+                zReader->read((char*)&id, 4);
                 Item* item = Game::INSTANCE->zItemType(id)->loadItem(zReader);
                 stack->addItems(new ItemStack(item, size), NO_DIRECTION);
             }
@@ -441,14 +441,14 @@ void Inventory::saveInventory(Framework::StreamWriter* zWriter)
             int value = 0;
             if (!stack || !stack->zItem())
             {
-                zWriter->schreibe((char*)&value, 4);
+                zWriter->write((char*)&value, 4);
             }
             else
             {
                 value = stack->getSize();
-                zWriter->schreibe((char*)&value, 4);
+                zWriter->write((char*)&value, 4);
                 value = stack->zItem()->zItemType()->getId();
-                zWriter->schreibe((char*)&value, 4);
+                zWriter->write((char*)&value, 4);
                 stack->zItem()->zItemType()->saveItem(stack->zItem(), zWriter);
             }
         }
@@ -672,7 +672,7 @@ int Inventory::numberOfAddableItems(
     int count = 0;
     for (auto targetSlot = pushSlotsOrder->begin(); targetSlot; targetSlot++)
     {
-        if (targetSlot->getName().istGleich(slotName))
+        if (targetSlot->getName().isEqual(slotName))
         {
             int maxCount = targetSlot->numberOfAddableItems(zItem, dir);
             int allowed = maxCount;
@@ -686,17 +686,17 @@ int Inventory::numberOfAddableItems(
 bool Inventory::isAllAvailable(Framework::RCArray<RecipieInput>& inputs,
     const Framework::Text& slotName) const
 {
-    int* used = new int[pullSlotsOrder->getEintragAnzahl()];
-    memset(used, 0, sizeof(int) * pullSlotsOrder->getEintragAnzahl());
+    int* used = new int[pullSlotsOrder->getEntryCount()];
+    memset(used, 0, sizeof(int) * pullSlotsOrder->getEntryCount());
     for (RecipieInput* input : inputs)
     {
         int found = 0;
-        for (int i = 0; i < pullSlotsOrder->getEintragAnzahl(); i++)
+        for (int i = 0; i < pullSlotsOrder->getEntryCount(); i++)
         {
             ItemSlot* slot = pullSlotsOrder->get(i);
             if (slot && slot->zStack() && slot->zStack()->zItem()
                 && slot->getNumberOfItems() > used[i]
-                && slot->getName().istGleich(slotName)
+                && slot->getName().isEqual(slotName)
                 && input->zFilter()->matchItem(slot->zStack()->zItem()))
             {
                 int usable = slot->getNumberOfItems() - used[i];
@@ -729,11 +729,11 @@ void Inventory::consume(
     for (RecipieInput* input : inputs)
     {
         int consumed = 0;
-        for (int i = 0; i < pullSlotsOrder->getEintragAnzahl(); i++)
+        for (int i = 0; i < pullSlotsOrder->getEntryCount(); i++)
         {
             ItemSlot* slot = pullSlotsOrder->get(i);
             if (slot && slot->zStack() && slot->zStack()->zItem()
-                && slot->getName().istGleich(slotName)
+                && slot->getName().isEqual(slotName)
                 && input->zFilter()->matchItem(slot->zStack()->zItem()))
             {
                 if (consumed + slot->getNumberOfItems() >= input->getAmount())
@@ -770,55 +770,55 @@ void Inventory::inventoryApi(Framework::StreamReader* zRequest,
     Entity* zSource)
 {
     char type;
-    zRequest->lese(&type, 1);
+    zRequest->read(&type, 1);
     switch (type)
     {
     case 0: // request inventory
         {
             char idLen;
-            zRequest->lese(&idLen, 1);
+            zRequest->read(&idLen, 1);
             char* id = new char[idLen + 1];
-            zRequest->lese(id, idLen);
+            zRequest->read(id, idLen);
             id[(int)idLen] = 0;
             int processor;
-            zRequest->lese((char*)&processor, 4);
+            zRequest->read((char*)&processor, 4);
             zResponse->addressUIElement(id, processor);
             observable.addObserver(zSource, id, processor);
             delete[] id;
             char filterLen;
-            zRequest->lese(&filterLen, 1);
+            zRequest->read(&filterLen, 1);
             char* filter = new char[filterLen + 1];
-            if (filterLen) zRequest->lese(filter, filterLen);
+            if (filterLen) zRequest->read(filter, filterLen);
             filter[(int)filterLen] = 0;
             InMemoryBuffer buffer;
             int count = 0;
             for (ItemSlot* slot : *this)
             {
-                if (filterLen == 0 || slot->getName().istGleich(filter))
+                if (filterLen == 0 || slot->getName().isEqual(filter))
                 {
                     count++;
                     int id = slot->getId();
-                    buffer.schreibe((char*)&id, 4);
+                    buffer.write((char*)&id, 4);
                     int itemCount = slot->getNumberOfItems();
-                    buffer.schreibe((char*)&itemCount, 4);
+                    buffer.write((char*)&itemCount, 4);
                     if (itemCount > 0)
                     {
                         float f = slot->zStack()->zItem()->getHp();
-                        buffer.schreibe((char*)&f, 4);
+                        buffer.write((char*)&f, 4);
                         f = slot->zStack()->zItem()->getMaxHp();
-                        buffer.schreibe((char*)&f, 4);
+                        buffer.write((char*)&f, 4);
                         f = slot->zStack()->zItem()->getDurability();
-                        buffer.schreibe((char*)&f, 4);
+                        buffer.write((char*)&f, 4);
                         f = slot->zStack()->zItem()->getMaxDurability();
-                        buffer.schreibe((char*)&f, 4);
+                        buffer.write((char*)&f, 4);
                         int id = slot->zStack()->zItem()->zItemType()->getId();
-                        buffer.schreibe((char*)&id, 4);
+                        buffer.write((char*)&id, 4);
                         char len = (char)slot->zStack()
                                        ->zItem()
                                        ->getName()
                                        .getLength();
-                        buffer.schreibe((char*)&len, 1);
-                        buffer.schreibe(
+                        buffer.write((char*)&len, 1);
+                        buffer.write(
                             slot->zStack()->zItem()->getName().getText(),
                             slot->zStack()->zItem()->getName().getLength());
                     }
@@ -828,19 +828,19 @@ void Inventory::inventoryApi(Framework::StreamReader* zRequest,
             char* msg = new char[5 + buffer.getSize()];
             msg[0] = 0;
             *(int*)(msg + 1) = count;
-            buffer.lese(msg + 5, (int)buffer.getSize());
+            buffer.read(msg + 5, (int)buffer.getSize());
             zResponse->setMessage(msg, 5 + (int)buffer.getSize());
             break;
         }
     case 1: // remove Observer
         {
             char idLen;
-            zRequest->lese(&idLen, 1);
+            zRequest->read(&idLen, 1);
             char* id = new char[idLen + 1];
-            zRequest->lese(id, idLen);
+            zRequest->read(id, idLen);
             id[(int)idLen] = 0;
             int processor;
-            zRequest->lese((char*)&processor, 4);
+            zRequest->read((char*)&processor, 4);
             observable.removeObserver(zSource, id, processor);
             delete[] id;
             break;
@@ -848,16 +848,16 @@ void Inventory::inventoryApi(Framework::StreamReader* zRequest,
     case 2: // request item tooltip
         {
             char idLen;
-            zRequest->lese(&idLen, 1);
+            zRequest->read(&idLen, 1);
             char* id = new char[idLen + 1];
-            zRequest->lese(id, idLen);
+            zRequest->read(id, idLen);
             id[(int)idLen] = 0;
             int processor;
-            zRequest->lese((char*)&processor, 4);
+            zRequest->read((char*)&processor, 4);
             zResponse->addressUIElement(id, processor);
             delete[] id;
             int slotId;
-            zRequest->lese((char*)&slotId, 4);
+            zRequest->read((char*)&slotId, 4);
             Text uiml;
             for (ItemSlot* slot : *pullSlotsOrder)
             {

FactoryCraft/Item.cpp

@@ -130,7 +130,7 @@ bool Item::canBeStackedWith(const Item* zItem) const
         && zItem->durability == zItem->durability && maxHp == zItem->maxHp
         && eatable == zItem->eatable && placeable == zItem->placeable
         && equippable == zItem->eatable && solid == zItem->solid
-        && usable == zItem->usable && name.istGleich(zItem->name);
+        && usable == zItem->usable && name.isEqual(zItem->name);
 }
 
 bool Item::canBePlacedAt(int dimensionId, Framework::Vec3<int> worldPos) const
@@ -183,7 +183,7 @@ Item* ItemJsonType::fromJson(Framework::JSON::JSONObject* zJson) const
     for (auto attribute = zJson->asObject()->getFields(); attribute;
         attribute++)
     {
-        if (attribute.val().istGleich("type")) continue;
+        if (attribute.val().isEqual("type")) continue;
         type->setItemAttribute(
             result, attribute, zJson->asObject()->zValue(attribute));
     }

FactoryCraft/ItemEntity.cpp

@@ -78,7 +78,7 @@ void ItemEntity::tick(const Dimension* zDimension, double seconds)
         });
     if (zOther)
     {
-        float d = location.abstand(zOther->getPosition());
+        float d = location.distance(zOther->getPosition());
         if (d < 0.5f)
         {
             // add items of this entity to the other entity

FactoryCraft/ItemFilter.cpp

@@ -41,7 +41,7 @@ CombinedItemFilter::CombinedItemFilter(
 bool CombinedItemFilter::matchItem(const Item* zItem) const
 {
     bool result = false;
-    for (int i = 0; i < filters.getEintragAnzahl(); i++)
+    for (int i = 0; i < filters.getEntryCount(); i++)
     {
         if (i == 0)
             result = filters.z(i)->matchItem(zItem);
@@ -54,7 +54,7 @@ bool CombinedItemFilter::matchItem(const Item* zItem) const
 bool CombinedItemFilter::matchSourceSlot(ItemSlot* zSlot) const
 {
     bool result = false;
-    for (int i = 0; i < filters.getEintragAnzahl(); i++)
+    for (int i = 0; i < filters.getEntryCount(); i++)
     {
         if (i == 0)
             result = filters.z(i)->matchSourceSlot(zSlot);
@@ -67,7 +67,7 @@ bool CombinedItemFilter::matchSourceSlot(ItemSlot* zSlot) const
 bool CombinedItemFilter::matchTargetSlot(ItemSlot* zSlot) const
 {
     bool result = false;
-    for (int i = 0; i < filters.getEintragAnzahl(); i++)
+    for (int i = 0; i < filters.getEntryCount(); i++)
     {
         if (i == 0)
             result = filters.z(i)->matchTargetSlot(zSlot);
@@ -79,19 +79,19 @@ bool CombinedItemFilter::matchTargetSlot(ItemSlot* zSlot) const
 
 UIMLItemFilterBuilder* CombinedItemFilter::getUIML() const
 {
-    if (filters.getEintragAnzahl() == 0)
+    if (filters.getEntryCount() == 0)
     {
         throw std::runtime_error(
             "Cannot build UIML for CombinedItemFilter with no filters");
     }
-    if (filters.getEintragAnzahl() == 1)
+    if (filters.getEntryCount() == 1)
     {
         return filters.z(0)->getUIML();
     }
     else
     {
         UIMLItemFilterBuilder* builder = 0;
-        for (int i = 0; i < filters.getEintragAnzahl(); i++)
+        for (int i = 0; i < filters.getEntryCount(); i++)
         {
             if (builder == 0)
             {
@@ -139,63 +139,63 @@ CombinedItemFilter* CombinedItemFilterFactory::fromJson(
     CombinedItemFilter* result = new CombinedItemFilter();
     std::function<bool(bool, bool)> func;
     Framework::Text op = zJson->zValue("operator")->asString()->getString();
-    if (op.istGleich("or"))
+    if (op.isEqual("or"))
     {
         func = [](bool a, bool b) { return a || b; };
     }
-    else if (op.istGleich("and"))
+    else if (op.isEqual("and"))
     {
         func = [](bool a, bool b) { return a && b; };
     }
-    else if (op.istGleich("xor"))
+    else if (op.isEqual("xor"))
     {
         func = [](bool a, bool b) { return (!a || !b) && (a || b); };
     }
-    else if (op.istGleich("nor"))
+    else if (op.isEqual("nor"))
     {
         func = [](bool a, bool b) { return !(a || b); };
     }
-    else if (op.istGleich("nand"))
+    else if (op.isEqual("nand"))
     {
         func = [](bool a, bool b) { return !(a && b); };
     }
-    else if (op.istGleich("left"))
+    else if (op.isEqual("left"))
     {
         func = [](bool a, bool b) { return a; };
     }
-    else if (op.istGleich("right"))
+    else if (op.isEqual("right"))
     {
         func = [](bool a, bool b) { return b; };
     }
-    else if (op.istGleich("onlyLeft"))
+    else if (op.isEqual("onlyLeft"))
     {
         func = [](bool a, bool b) { return a && !b; };
     }
-    else if (op.istGleich("onlyRight"))
+    else if (op.isEqual("onlyRight"))
     {
         func = [](bool a, bool b) { return !a && b; };
     }
-    else if (op.istGleich("notLeft"))
+    else if (op.isEqual("notLeft"))
     {
         func = [](bool a, bool b) { return !a; };
     }
-    else if (op.istGleich("notRight"))
+    else if (op.isEqual("notRight"))
     {
         func = [](bool a, bool b) { return !b; };
     }
-    else if (op.istGleich("eq"))
+    else if (op.isEqual("eq"))
     {
         func = [](bool a, bool b) { return a == b; };
     }
-    else if (op.istGleich("leftOrEq"))
+    else if (op.isEqual("leftOrEq"))
     {
         func = [](bool a, bool b) { return a || (a == b); };
     }
-    else if (op.istGleich("rightOrEq"))
+    else if (op.isEqual("rightOrEq"))
     {
         func = [](bool a, bool b) { return b || (a == b); };
     }
-    else if (op.istGleich("true"))
+    else if (op.isEqual("true"))
     {
         func = [](bool a, bool b) { return true; };
     }
@@ -558,7 +558,7 @@ bool GroupItemFilter::matchItem(const Item* zItem) const
     {
         for (Framework::Text* typeGroup : zItem->zItemType()->getGroups())
         {
-            if (typeGroup->istGleich(*group)) return true;
+            if (typeGroup->isEqual(*group)) return true;
         }
     }
     return false;
@@ -577,7 +577,7 @@ UIMLItemFilterBuilder* GroupItemFilter::getUIML() const
                 for (Framework::Text* typeGroup :
                     Game::INSTANCE->zItemType(i)->getGroups())
                 {
-                    if (typeGroup->istGleich(*group))
+                    if (typeGroup->isEqual(*group))
                     {
                         found = true;
                         break;
@@ -663,7 +663,7 @@ bool TargetSlotNameItemFilter::matchSourceSlot(ItemSlot* zSlot) const
 
 bool TargetSlotNameItemFilter::matchTargetSlot(ItemSlot* zSlot) const
 {
-    return zSlot->getName().istGleich(slotName);
+    return zSlot->getName().isEqual(slotName);
 }
 
 UIMLItemFilterBuilder* TargetSlotNameItemFilter::getUIML() const
@@ -679,7 +679,7 @@ SourceSlotNameItemFilter::SourceSlotNameItemFilter(
 
 bool SourceSlotNameItemFilter::matchSourceSlot(ItemSlot* zSlot) const
 {
-    return zSlot->getName().istGleich(slotName);
+    return zSlot->getName().isEqual(slotName);
 }
 
 bool SourceSlotNameItemFilter::matchTargetSlot(ItemSlot* zSlot) const

FactoryCraft/ItemModifier.cpp

@@ -129,7 +129,7 @@ AttributeItemModifier* AttributeItemModifierFactory::fromJson(
     auto value = zJson->getValues();
     while (attribute, value)
     {
-        if (!attribute.val().istGleich("type"))
+        if (!attribute.val().isEqual("type"))
         {
             result->addAttribute(attribute.val(), value);
         }

FactoryCraft/ItemSkill.cpp

@@ -13,18 +13,18 @@ ItemSkill::ItemSkill()
 
 void ItemSkill::load(Framework::StreamReader* zReader)
 {
-    zReader->lese((char*)&xp, 4);
-    zReader->lese((char*)&maxXP, 4);
-    zReader->lese((char*)&level, 4);
-    zReader->lese((char*)&itemTypeId, 4);
+    zReader->read((char*)&xp, 4);
+    zReader->read((char*)&maxXP, 4);
+    zReader->read((char*)&level, 4);
+    zReader->read((char*)&itemTypeId, 4);
 }
 
 void ItemSkill::save(Framework::StreamWriter* zWriter)
 {
-    zWriter->schreibe((char*)&xp, 4);
-    zWriter->schreibe((char*)&maxXP, 4);
-    zWriter->schreibe((char*)&level, 4);
-    zWriter->schreibe((char*)&itemTypeId, 4);
+    zWriter->write((char*)&xp, 4);
+    zWriter->write((char*)&maxXP, 4);
+    zWriter->write((char*)&level, 4);
+    zWriter->write((char*)&itemTypeId, 4);
 }
 
 bool ItemSkill::interact(Entity* zActor, Item* zUsedItem, Block* zTarget)

FactoryCraft/ItemSlot.cpp

@@ -205,27 +205,27 @@ ItemSlot* ItemSlotFactory::fromJson(Framework::JSON::JSONObject* zJson) const
         *zJson->zValue("allowedPullSides")->asArray())
     {
         Framework::Text sideText = side->asString()->getString();
-        if (sideText.istGleich("TOP"))
+        if (sideText.isEqual("TOP"))
         {
             allowedPullSides |= TOP;
         }
-        else if (sideText.istGleich("BOTTOM"))
+        else if (sideText.isEqual("BOTTOM"))
         {
             allowedPullSides |= BOTTOM;
         }
-        else if (sideText.istGleich("NORTH"))
+        else if (sideText.isEqual("NORTH"))
         {
             allowedPullSides |= NORTH;
         }
-        else if (sideText.istGleich("EAST"))
+        else if (sideText.isEqual("EAST"))
         {
             allowedPullSides |= EAST;
         }
-        else if (sideText.istGleich("SOUTH"))
+        else if (sideText.isEqual("SOUTH"))
         {
             allowedPullSides |= SOUTH;
         }
-        else if (sideText.istGleich("WEST"))
+        else if (sideText.isEqual("WEST"))
         {
             allowedPullSides |= WEST;
         }
@@ -234,27 +234,27 @@ ItemSlot* ItemSlotFactory::fromJson(Framework::JSON::JSONObject* zJson) const
         *zJson->zValue("allowedPushSides")->asArray())
     {
         Framework::Text sideText = side->asString()->getString();
-        if (sideText.istGleich("TOP"))
+        if (sideText.isEqual("TOP"))
         {
             allowedPushSides |= TOP;
         }
-        else if (sideText.istGleich("BOTTOM"))
+        else if (sideText.isEqual("BOTTOM"))
         {
             allowedPushSides |= BOTTOM;
         }
-        else if (sideText.istGleich("NORTH"))
+        else if (sideText.isEqual("NORTH"))
         {
             allowedPushSides |= NORTH;
         }
-        else if (sideText.istGleich("EAST"))
+        else if (sideText.isEqual("EAST"))
         {
             allowedPushSides |= EAST;
         }
-        else if (sideText.istGleich("SOUTH"))
+        else if (sideText.isEqual("SOUTH"))
         {
             allowedPushSides |= SOUTH;
         }
-        else if (sideText.istGleich("WEST"))
+        else if (sideText.isEqual("WEST"))
         {
             allowedPushSides |= WEST;
         }

FactoryCraft/ItemType.cpp

@@ -27,38 +27,38 @@ ItemType::~ItemType()
 void ItemType::loadSuperItem(
     Item* zItem, Framework::StreamReader* zReader) const
 {
-    zReader->lese((char*)&zItem->hp, 4);
-    zReader->lese((char*)&zItem->maxHp, 4);
-    zReader->lese((char*)&zItem->durability, 4);
-    zReader->lese((char*)&zItem->maxDurability, 4);
+    zReader->read((char*)&zItem->hp, 4);
+    zReader->read((char*)&zItem->maxHp, 4);
+    zReader->read((char*)&zItem->durability, 4);
+    zReader->read((char*)&zItem->maxDurability, 4);
     unsigned char flags = 0;
-    zReader->lese((char*)&flags, 1);
+    zReader->read((char*)&flags, 1);
     zItem->eatable = (flags | 1) == flags;
     zItem->placeable = (flags | 2) == flags;
     zItem->equippable = (flags | 4) == flags;
     zItem->solid = (flags | 8) == flags;
     zItem->usable = (flags | 16) == flags;
     unsigned char len = 0;
-    zReader->lese((char*)&len, 1);
+    zReader->read((char*)&len, 1);
     zItem->name.fillText(' ', len);
-    zReader->lese((char*)zItem->name.getText(), len);
+    zReader->read((char*)zItem->name.getText(), len);
 }
 
 void ItemType::saveSuperItem(
     const Item* zItem, Framework::StreamWriter* zWriter) const
 {
-    zWriter->schreibe((char*)&zItem->hp, 4);
-    zWriter->schreibe((char*)&zItem->maxHp, 4);
-    zWriter->schreibe((char*)&zItem->durability, 4);
-    zWriter->schreibe((char*)&zItem->maxDurability, 4);
+    zWriter->write((char*)&zItem->hp, 4);
+    zWriter->write((char*)&zItem->maxHp, 4);
+    zWriter->write((char*)&zItem->durability, 4);
+    zWriter->write((char*)&zItem->maxDurability, 4);
     unsigned char flags
         = (unsigned char)((zItem->usable << 4) | (zItem->solid << 3)
                           | (zItem->equippable << 2) | (zItem->placeable << 1)
                           | (int)zItem->eatable);
-    zWriter->schreibe((char*)&flags, 1);
+    zWriter->write((char*)&flags, 1);
     unsigned char len = (unsigned char)zItem->name.getLength();
-    zWriter->schreibe((char*)&len, 1);
-    zWriter->schreibe(zItem->name, len);
+    zWriter->write((char*)&len, 1);
+    zWriter->write(zItem->name, len);
 }
 
 bool ItemType::initialize(Game* zGame)
@@ -116,20 +116,20 @@ void ItemType::setItemAttribute(
     bool ok = true;
     if (zValue->getType() == Framework::AbstractType::NUMBER)
     {
-        if (name.istGleich("hp"))
+        if (name.isEqual("hp"))
             zItem->hp = (float)zValue->asNumber()->getNumber();
-        else if (name.istGleich("maxHp"))
+        else if (name.isEqual("maxHp"))
             zItem->maxHp = (float)zValue->asNumber()->getNumber();
-        else if (name.istGleich("durability"))
+        else if (name.isEqual("durability"))
             zItem->durability = (float)zValue->asNumber()->getNumber();
-        else if (name.istGleich("maxDurability"))
+        else if (name.isEqual("maxDurability"))
             zItem->maxDurability = (float)zValue->asNumber()->getNumber();
         else
             ok = false;
     }
     else if (zValue->getType() == Framework::AbstractType::STRING)
     {
-        if (name.istGleich("name"))
+        if (name.isEqual("name"))
             zItem->name = zValue->asString()->getString();
         else
             ok = false;
@@ -258,7 +258,7 @@ int ItemType::getTypeId(const char* name)
     for (int i = 0; i < Game::INSTANCE->getItemTypeCount(); i++)
     {
         if (Game::INSTANCE->zItemType(i)
-            && Game::INSTANCE->zItemType(i)->getName().istGleich(name))
+            && Game::INSTANCE->zItemType(i)->getName().isEqual(name))
             return Game::INSTANCE->zItemType(i)->getId();
     }
     return 0;
@@ -269,7 +269,7 @@ const ItemType* ItemType::zByName(const char* name)
     for (int i = 0; i < Game::INSTANCE->getItemTypeCount(); i++)
     {
         if (Game::INSTANCE->zItemType(i)
-            && Game::INSTANCE->zItemType(i)->getName().istGleich(name))
+            && Game::INSTANCE->zItemType(i)->getName().isEqual(name))
             return Game::INSTANCE->zItemType(i);
     }
     return 0;

FactoryCraft/JNoise.cpp

@@ -14,7 +14,7 @@ using namespace Framework;
 Noise* JNoise::parseNoise(JSON::JSONValue* zConfig, JExpressionMemory* zMemory)
 {
     Text type = zConfig->asObject()->zValue("type")->asString()->getString();
-    if (type.istGleich("random"))
+    if (type.isEqual("random"))
     {
         JFloatExpression* seedExpression
             = Game::INSTANCE->zTypeRegistry()->fromJson<JFloatExpression>(
@@ -24,7 +24,7 @@ Noise* JNoise::parseNoise(JSON::JSONValue* zConfig, JExpressionMemory* zMemory)
         seedExpression->release();
         return new RandNoise((int)(round(seed)));
     }
-    else if (type.istGleich("factorize"))
+    else if (type.isEqual("factorize"))
     {
         double factor
             = zConfig->asObject()->zValue("factorA")->asNumber()->getNumber();
@@ -32,19 +32,19 @@ Noise* JNoise::parseNoise(JSON::JSONValue* zConfig, JExpressionMemory* zMemory)
         Noise* b = parseNoise(zConfig->asObject()->zValue("noiseB"), zMemory);
         return new FactorizeNoise(a, b, factor);
     }
-    else if (type.istGleich("multiply"))
+    else if (type.isEqual("multiply"))
     {
         Noise* a = parseNoise(zConfig->asObject()->zValue("base"), zMemory);
         Noise* b
             = parseNoise(zConfig->asObject()->zValue("multiplier"), zMemory);
         return new MultiplyNoise(a, b);
     }
-    else if (type.istGleich("negate"))
+    else if (type.isEqual("negate"))
     {
         Noise* a = parseNoise(zConfig->asObject()->zValue("noise"), zMemory);
         return new NegateNoise(a);
     }
-    else if (type.istGleich("flatten"))
+    else if (type.isEqual("flatten"))
     {
         Noise* a = parseNoise(zConfig->asObject()->zValue("noise"), zMemory);
         double factor
@@ -53,7 +53,7 @@ Noise* JNoise::parseNoise(JSON::JSONValue* zConfig, JExpressionMemory* zMemory)
             = zConfig->asObject()->zValue("addition")->asNumber()->getNumber();
         return new FlattenNoise(a, factor, addition);
     }
-    else if (type.istGleich("scale"))
+    else if (type.isEqual("scale"))
     {
         Noise* a = parseNoise(zConfig->asObject()->zValue("noise"), zMemory);
         double factor
@@ -69,19 +69,19 @@ Noise* JNoise::parseNoise(JSON::JSONValue* zConfig, JExpressionMemory* zMemory)
         float seed = seedExpression->getValue();
         seedExpression->release();
         FastNoiseLite* noise = new FastNoiseLite((int)(round(seed)));
-        if (type.istGleich("Cellular"))
+        if (type.isEqual("Cellular"))
             noise->SetNoiseType(FastNoiseLite::NoiseType::NoiseType_Cellular);
-        else if (type.istGleich("ValueCubic"))
+        else if (type.isEqual("ValueCubic"))
             noise->SetNoiseType(FastNoiseLite::NoiseType::NoiseType_ValueCubic);
-        else if (type.istGleich("Perlin"))
+        else if (type.isEqual("Perlin"))
             noise->SetNoiseType(FastNoiseLite::NoiseType::NoiseType_Perlin);
-        else if (type.istGleich("OpenSimplex2S"))
+        else if (type.isEqual("OpenSimplex2S"))
             noise->SetNoiseType(
                 FastNoiseLite::NoiseType::NoiseType_OpenSimplex2S);
-        else if (type.istGleich("OpenSimplex2"))
+        else if (type.isEqual("OpenSimplex2"))
             noise->SetNoiseType(
                 FastNoiseLite::NoiseType::NoiseType_OpenSimplex2);
-        else if (type.istGleich("Value"))
+        else if (type.isEqual("Value"))
             noise->SetNoiseType(FastNoiseLite::NoiseType::NoiseType_Value);
         if (zConfig->asObject()->hasValue("rotationType3D"))
         {
@@ -89,17 +89,17 @@ Noise* JNoise::parseNoise(JSON::JSONValue* zConfig, JExpressionMemory* zMemory)
                              ->zValue("rotationType3D")
                              ->asString()
                              ->getString();
-            if (value.istGleich("None"))
+            if (value.isEqual("None"))
             {
                 noise->SetRotationType3D(
                     FastNoiseLite::RotationType3D::RotationType3D_None);
             }
-            else if (value.istGleich("ImproveXYPlanes"))
+            else if (value.isEqual("ImproveXYPlanes"))
             {
                 noise->SetRotationType3D(FastNoiseLite::RotationType3D::
                         RotationType3D_ImproveXYPlanes);
             }
-            else if (value.istGleich("ImproveXZPlanes"))
+            else if (value.isEqual("ImproveXZPlanes"))
             {
                 noise->SetRotationType3D(FastNoiseLite::RotationType3D::
                         RotationType3D_ImproveXZPlanes);
@@ -118,32 +118,32 @@ Noise* JNoise::parseNoise(JSON::JSONValue* zConfig, JExpressionMemory* zMemory)
                              ->zValue("fractalType")
                              ->asString()
                              ->getString();
-            if (value.istGleich("None"))
+            if (value.isEqual("None"))
             {
                 noise->SetFractalType(
                     FastNoiseLite::FractalType::FractalType_None);
             }
-            else if (value.istGleich("FBm"))
+            else if (value.isEqual("FBm"))
             {
                 noise->SetFractalType(
                     FastNoiseLite::FractalType::FractalType_FBm);
             }
-            else if (value.istGleich("Ridged"))
+            else if (value.isEqual("Ridged"))
             {
                 noise->SetFractalType(
                     FastNoiseLite::FractalType::FractalType_Ridged);
             }
-            else if (value.istGleich("PingPong"))
+            else if (value.isEqual("PingPong"))
             {
                 noise->SetFractalType(
                     FastNoiseLite::FractalType::FractalType_PingPong);
             }
-            else if (value.istGleich("DomainWarpProgressive"))
+            else if (value.isEqual("DomainWarpProgressive"))
             {
                 noise->SetFractalType(FastNoiseLite::FractalType::
                         FractalType_DomainWarpProgressive);
             }
-            else if (value.istGleich("DomainWarpIndependent"))
+            else if (value.isEqual("DomainWarpIndependent"))
             {
                 noise->SetFractalType(FastNoiseLite::FractalType::
                         FractalType_DomainWarpIndependent);
@@ -176,25 +176,25 @@ Noise* JNoise::parseNoise(JSON::JSONValue* zConfig, JExpressionMemory* zMemory)
                              ->zValue("cellularDistanceFunction")
                              ->asString()
                              ->getString();
-            if (value.istGleich("Hybrid"))
+            if (value.isEqual("Hybrid"))
             {
                 noise->SetCellularDistanceFunction(
                     FastNoiseLite::CellularDistanceFunction::
                         CellularDistanceFunction_Hybrid);
             }
-            else if (value.istGleich("Manhattan"))
+            else if (value.isEqual("Manhattan"))
             {
                 noise->SetCellularDistanceFunction(
                     FastNoiseLite::CellularDistanceFunction::
                         CellularDistanceFunction_Manhattan);
             }
-            else if (value.istGleich("EuclideanSq"))
+            else if (value.isEqual("EuclideanSq"))
             {
                 noise->SetCellularDistanceFunction(
                     FastNoiseLite::CellularDistanceFunction::
                         CellularDistanceFunction_EuclideanSq);
             }
-            else if (value.istGleich("Euclidean"))
+            else if (value.isEqual("Euclidean"))
             {
                 noise->SetCellularDistanceFunction(
                     FastNoiseLite::CellularDistanceFunction::
@@ -207,37 +207,37 @@ Noise* JNoise::parseNoise(JSON::JSONValue* zConfig, JExpressionMemory* zMemory)
                              ->zValue("cellularReturnType")
                              ->asString()
                              ->getString();
-            if (value.istGleich("CellValue"))
+            if (value.isEqual("CellValue"))
             {
                 noise->SetCellularReturnType(FastNoiseLite::CellularReturnType::
                         CellularReturnType_CellValue);
             }
-            else if (value.istGleich("Distance"))
+            else if (value.isEqual("Distance"))
             {
                 noise->SetCellularReturnType(FastNoiseLite::CellularReturnType::
                         CellularReturnType_Distance);
             }
-            else if (value.istGleich("Distance2"))
+            else if (value.isEqual("Distance2"))
             {
                 noise->SetCellularReturnType(FastNoiseLite::CellularReturnType::
                         CellularReturnType_Distance2);
             }
-            else if (value.istGleich("Distance2Add"))
+            else if (value.isEqual("Distance2Add"))
             {
                 noise->SetCellularReturnType(FastNoiseLite::CellularReturnType::
                         CellularReturnType_Distance2Add);
             }
-            else if (value.istGleich("Distance2Sub"))
+            else if (value.isEqual("Distance2Sub"))
             {
                 noise->SetCellularReturnType(FastNoiseLite::CellularReturnType::
                         CellularReturnType_Distance2Sub);
             }
-            else if (value.istGleich("Distance2Mul"))
+            else if (value.isEqual("Distance2Mul"))
             {
                 noise->SetCellularReturnType(FastNoiseLite::CellularReturnType::
                         CellularReturnType_Distance2Mul);
             }
-            else if (value.istGleich("Distance2Div"))
+            else if (value.isEqual("Distance2Div"))
             {
                 noise->SetCellularReturnType(FastNoiseLite::CellularReturnType::
                         CellularReturnType_Distance2Div);
@@ -256,17 +256,17 @@ Noise* JNoise::parseNoise(JSON::JSONValue* zConfig, JExpressionMemory* zMemory)
                              ->zValue("domainWarpType")
                              ->asString()
                              ->getString();
-            if (value.istGleich("OpenSimplex2Reduced"))
+            if (value.isEqual("OpenSimplex2Reduced"))
             {
                 noise->SetDomainWarpType(FastNoiseLite::DomainWarpType::
                         DomainWarpType_OpenSimplex2Reduced);
             }
-            else if (value.istGleich("OpenSimplex2"))
+            else if (value.isEqual("OpenSimplex2"))
             {
                 noise->SetDomainWarpType(
                     FastNoiseLite::DomainWarpType::DomainWarpType_OpenSimplex2);
             }
-            else if (value.istGleich("BasicGrid"))
+            else if (value.isEqual("BasicGrid"))
             {
                 noise->SetDomainWarpType(
                     FastNoiseLite::DomainWarpType::DomainWarpType_BasicGrid);

FactoryCraft/JsonExpression.cpp

@@ -524,7 +524,7 @@ Framework::Assembly::AssemblyBlock& JOperatorFloatExpression::buildAssembly(
     JExpressionMemory* zMemory)
 {
     bool first = 1;
-    if (!values.getEintragAnzahl())
+    if (!values.getEntryCount())
     {
         codeBlock.addMoveValue(Framework::Assembly::MM0, 0.f);
     }
@@ -559,28 +559,28 @@ Framework::Assembly::AssemblyBlock& JOperatorFloatExpression::buildAssembly(
                 {Framework::Assembly::SINGLE_FLOAT},
                 0,
                 0);
-            if (op.istGleich("+"))
+            if (op.isEqual("+"))
             {
                 codeBlock.addAddition(Framework::Assembly::MM0,
                     Framework::Assembly::MM1,
                     Framework::Assembly::SINGLE_FLOAT,
                     Framework::Assembly::X);
             }
-            else if (op.istGleich("-"))
+            else if (op.isEqual("-"))
             {
                 codeBlock.addSubtraction(Framework::Assembly::MM0,
                     Framework::Assembly::MM1,
                     Framework::Assembly::SINGLE_FLOAT,
                     Framework::Assembly::X);
             }
-            else if (op.istGleich("*"))
+            else if (op.isEqual("*"))
             {
                 codeBlock.addMultiplication(Framework::Assembly::MM0,
                     Framework::Assembly::MM1,
                     Framework::Assembly::SINGLE_FLOAT,
                     Framework::Assembly::X);
             }
-            else if (op.istGleich("/"))
+            else if (op.isEqual("/"))
             {
                 codeBlock.addDivision(Framework::Assembly::MM0,
                     Framework::Assembly::MM1,
@@ -673,7 +673,7 @@ Framework::Assembly::AssemblyBlock& JBoolOperatorBoolExpression::buildAssembly(
     JExpressionMemory* zMemory)
 {
     bool first = 1;
-    if (!values.getEintragAnzahl())
+    if (!values.getEntryCount())
     {
         codeBlock.addMoveValue(Framework::Assembly::RAX, (char)0);
     }
@@ -703,13 +703,13 @@ Framework::Assembly::AssemblyBlock& JBoolOperatorBoolExpression::buildAssembly(
             }
             codeBlock.addBlock(
                 &exprBlock, {Framework::Assembly::RAX}, {}, {}, 0, 0);
-            if (op.istGleich("&&"))
+            if (op.isEqual("&&"))
             {
                 codeBlock.addAnd(Framework::Assembly::RAX,
                     Framework::Assembly::RCX,
                     Framework::Assembly::LOWER8);
             }
-            else if (op.istGleich("||"))
+            else if (op.isEqual("||"))
             {
                 codeBlock.addOr(Framework::Assembly::RAX,
                     Framework::Assembly::RCX,
@@ -842,55 +842,55 @@ Framework::Assembly::AssemblyBlock& JFloatOperatorBoolExpression::buildAssembly(
                 0);
             Framework::Assembly::Operation jumpOp = Framework::Assembly::NOP;
             bool needConversion = false;
-            if (op.istGleich(">"))
+            if (op.isEqual(">"))
             {
                 jumpOp = Framework::Assembly::JBE; // jump if below or equal
             }
-            else if (op.istGleich("<"))
+            else if (op.isEqual("<"))
             {
                 jumpOp = Framework::Assembly::JNB; // jump if not below
             }
-            else if (op.istGleich(">="))
+            else if (op.isEqual(">="))
             {
                 jumpOp = Framework::Assembly::JB; // jump if below
             }
-            else if (op.istGleich("<="))
+            else if (op.isEqual("<="))
             {
                 jumpOp = Framework::Assembly::JA; // jump if above
             }
-            else if (op.istGleich("=="))
+            else if (op.isEqual("=="))
             {
                 jumpOp = Framework::Assembly::JNE; // jump if not equal
             }
-            else if (op.istGleich("!="))
+            else if (op.isEqual("!="))
             {
                 jumpOp = Framework::Assembly::JE; // jump if equal
             }
             else
             {
                 needConversion = true;
-                if (op.istGleich(">i"))
+                if (op.isEqual(">i"))
                 {
                     jumpOp = Framework::Assembly::JLE; // jump if less or equal
                 }
-                else if (op.istGleich("<i"))
+                else if (op.isEqual("<i"))
                 {
                     jumpOp = Framework::Assembly::JGE; // jump if greater or
                                                        // equal
                 }
-                else if (op.istGleich(">=i"))
+                else if (op.isEqual(">=i"))
                 {
                     jumpOp = Framework::Assembly::JL; // jump if less
                 }
-                else if (op.istGleich("<=i"))
+                else if (op.isEqual("<=i"))
                 {
                     jumpOp = Framework::Assembly::JG; // jump if greater
                 }
-                else if (op.istGleich("==i"))
+                else if (op.isEqual("==i"))
                 {
                     jumpOp = Framework::Assembly::JNE; // jump if not equal
                 }
-                else if (op.istGleich("!=i"))
+                else if (op.isEqual("!=i"))
                 {
                     jumpOp = Framework::Assembly::JE; // jump if equal
                 }

FactoryCraft/JsonUtils.cpp

@@ -1,22 +1,22 @@
 #include "JsonUtils.h"
 
 #include <Console.h>
-#include <Datei.h>
+#include <File.h>
 
 #include "Game.h"
 
 int countAllJsonsInDirectory(Framework::Text path)
 {
     int count = 0;
-    if (path.hatAt(path.getLength() - 1, "/")
-        || path.hatAt(path.getLength() - 1, "\\"))
+    if (path.hasAt(path.getLength() - 1, "/")
+        || path.hasAt(path.getLength() - 1, "\\"))
     {
         path.remove(path.getLength() - 1, path.getLength());
     }
-    Framework::Datei dir(path);
-    if (dir.istOrdner())
+    Framework::File dir(path);
+    if (dir.isDirectory())
     {
-        Framework::RCArray<Framework::Text>* list = dir.getDateiListe();
+        Framework::RCArray<Framework::Text>* list = dir.getFileList();
         for (Framework::Text* name : *list)
         {
             Framework::Text nextPath = path + "/" + *name;
@@ -24,7 +24,7 @@ int countAllJsonsInDirectory(Framework::Text path)
         }
         list->release();
     }
-    else if (path.hatAt(path.getLength() - 5, ".json") && dir.existiert())
+    else if (path.hasAt(path.getLength() - 5, ".json") && dir.exists())
     {
         count++;
     }
@@ -36,15 +36,15 @@ void internalLoadAllJsonsFromDirectory(Framework::Text path,
         Framework::JSON::JSONValue* zValue, Framework::Text path)> action,
     Framework::ConsoleProgressBar* progress)
 {
-    if (path.hatAt(path.getLength() - 1, "/")
-        || path.hatAt(path.getLength() - 1, "\\"))
+    if (path.hasAt(path.getLength() - 1, "/")
+        || path.hasAt(path.getLength() - 1, "\\"))
     {
         path.remove(path.getLength() - 1, path.getLength());
     }
-    Framework::Datei dir(path);
-    if (dir.istOrdner())
+    Framework::File dir(path);
+    if (dir.isDirectory())
     {
-        Framework::RCArray<Framework::Text>* list = dir.getDateiListe();
+        Framework::RCArray<Framework::Text>* list = dir.getFileList();
         for (Framework::Text* name : *list)
         {
             Framework::Text nextPath = path + "/" + *name;
@@ -52,7 +52,7 @@ void internalLoadAllJsonsFromDirectory(Framework::Text path,
         }
         list->release();
     }
-    else if (path.hatAt(path.getLength() - 5, ".json") && dir.existiert())
+    else if (path.hasAt(path.getLength() - 5, ".json") && dir.exists())
     {
         Framework::JSON::JSONValue* value
             = Framework::JSON::loadJSONFromFile(path);

FactoryCraft/LightSources.cpp

@@ -35,7 +35,7 @@ void LightSourceItemType::loadSuperItem(
     Item* zItem, Framework::StreamReader* zReader) const
 {
     LightSourceItem* item = dynamic_cast<LightSourceItem*>(zItem);
-    zReader->lese((char*)&item->color, 4);
+    zReader->read((char*)&item->color, 4);
     BasicBlockItemType::loadSuperItem(zItem, zReader);
 }
 
@@ -43,7 +43,7 @@ void LightSourceItemType::saveSuperItem(
     const Item* zItem, Framework::StreamWriter* zWriter) const
 {
     const LightSourceItem* item = dynamic_cast<const LightSourceItem*>(zItem);
-    zWriter->schreibe((char*)&item->color, 4);
+    zWriter->write((char*)&item->color, 4);
     BasicBlockItemType::saveSuperItem(zItem, zWriter);
 }
 
@@ -119,7 +119,7 @@ void BasicLightSourceBlockType::loadSuperBlock(
     if (!block)
         throw "BasicLightSourceBlockType::loadSuperBlock was called with a "
               "block witch is not an instance of BasicLightSource";
-    zReader->lese((char*)&block->lightEmisionColor, 4);
+    zReader->read((char*)&block->lightEmisionColor, 4);
 }
 
 void BasicLightSourceBlockType::saveSuperBlock(
@@ -130,7 +130,7 @@ void BasicLightSourceBlockType::saveSuperBlock(
     if (!block)
         throw "BasicLightSourceBlockType::saveSuperBlock was called with a "
               "block witch is not an instance of BasicLightSource";
-    zWriter->schreibe((char*)&block->lightEmisionColor, 4);
+    zWriter->write((char*)&block->lightEmisionColor, 4);
 }
 
 bool BasicLightSourceBlockType::initialize(Game* zGame)

FactoryCraft/ModelInfo.cpp

@@ -1,6 +1,6 @@
 #include "ModelInfo.h"
 
-#include <M3Datei.h>
+#include <M3File.h>
 #include <Model3D.h>
 
 using namespace Framework;
@@ -31,31 +31,31 @@ ModelInfo::ModelInfo(const char* modelPath,
 void ModelInfo::writeTo(Framework::StreamWriter* zWriter) const
 {
     char len = (char)modelPath.getLength();
-    zWriter->schreibe(&len, 1);
-    zWriter->schreibe(modelPath.getText(), (int)len);
-    short count = (short)texturePaths.getEintragAnzahl();
-    zWriter->schreibe((char*)&count, 2);
+    zWriter->write(&len, 1);
+    zWriter->write(modelPath.getText(), (int)len);
+    short count = (short)texturePaths.getEntryCount();
+    zWriter->write((char*)&count, 2);
     for (Text* t : texturePaths)
     {
         len = (char)t->getLength();
-        zWriter->schreibe(&len, 1);
-        zWriter->schreibe(t->getText(), (int)len);
+        zWriter->write(&len, 1);
+        zWriter->write(t->getText(), (int)len);
     }
-    zWriter->schreibe((char*)&transparent, 1);
-    zWriter->schreibe((char*)&size, 4);
+    zWriter->write((char*)&transparent, 1);
+    zWriter->write((char*)&size, 4);
 }
 
 void ModelInfo::setModelPath(Framework::Text path)
 {
     modelPath = path;
     bool loades = 0;
-    if (path.positionVon(".m3/") > 0)
+    if (path.positionOf(".m3/") > 0)
     {
-        int pos = path.positionVon(".m3/", path.anzahlVon(".m3/") - 1) + 3;
-        Framework::M3Datei m3File(path.getTeilText(0, pos));
-        m3File.leseDaten();
+        int pos = path.positionOf(".m3/", path.countOf(".m3/") - 1) + 3;
+        Framework::M3File m3File(path.getTeilText(0, pos));
+        m3File.readData();
         Model3DData* data
-            = m3File.ladeModel(path.getTeilText(pos + 1), 0, new Text());
+            = m3File.loadModel(path.getTeilText(pos + 1), 0, new Text());
         if (data)
         {
             auto tmp = data->getMaxPos();

FactoryCraft/MultiblockStructure.cpp

@@ -45,8 +45,8 @@ void MultiblockStructure::onBlockUnloaded(Block* zBlock)
 void MultiblockStructure::addMemberPosition(Framework::Vec3<int> blockPos)
 {
     memberBlockPositions.add(blockPos);
-    Punkt center = Game::INSTANCE->getChunkCenter(blockPos.x, blockPos.y);
-    for (const Punkt& p : affectedChunks)
+    Point center = Game::INSTANCE->getChunkCenter(blockPos.x, blockPos.y);
+    for (const Point& p : affectedChunks)
     {
         if (p == center) return;
     }
@@ -60,7 +60,7 @@ void MultiblockStructure::onBlockRemoved(
     {
         if (i.val() == zBlock->getPos())
         {
-            Punkt center = Game::INSTANCE->getChunkCenter(i.val().x, i.val().y);
+            Point center = Game::INSTANCE->getChunkCenter(i.val().x, i.val().y);
             i.remove();
             // check if other blocks in the same chunk exists
             for (Vec3<int> pos : memberBlockPositions)
@@ -90,12 +90,12 @@ void MultiblockStructure::onBlockReplaced(Entity* zActor,
 
 bool MultiblockStructure::isEmpty() const
 {
-    return memberBlockPositions.getEintragAnzahl() == 0 && !isLoading;
+    return memberBlockPositions.getEntryCount() == 0 && !isLoading;
 }
 
 bool MultiblockStructure::isFullyLoaded() const
 {
-    for (Punkt p : affectedChunks)
+    for (Point p : affectedChunks)
     {
         if (!Game::INSTANCE->isChunkLoaded(p.x, p.y, dimensionId)) return 0;
     }
@@ -105,7 +105,7 @@ bool MultiblockStructure::isFullyLoaded() const
 bool MultiblockStructure::isFullyUnloaded() const
 {
     if (isLoading) return 0;
-    for (Punkt p : affectedChunks)
+    for (Point p : affectedChunks)
     {
         if (Game::INSTANCE->isChunkLoaded(p.x, p.y, dimensionId)) return 0;
     }
@@ -146,16 +146,16 @@ MultiblockStructureType::~MultiblockStructureType() {}
 void MultiblockStructureType::loadSuperStructure(
     MultiblockStructure* zStructure, Framework::StreamReader* zReader) const
 {
-    zStructure->affectedChunks.leeren();
-    zStructure->memberBlockPositions.leeren();
+    zStructure->affectedChunks.clear();
+    zStructure->memberBlockPositions.clear();
     int blockCount;
-    zReader->lese((char*)&blockCount, 4);
+    zReader->read((char*)&blockCount, 4);
     for (int i = 0; i < blockCount; i++)
     {
         Framework::Vec3<int> pos;
-        zReader->lese((char*)&pos.x, 4);
-        zReader->lese((char*)&pos.y, 4);
-        zReader->lese((char*)&pos.z, 4);
+        zReader->read((char*)&pos.x, 4);
+        zReader->read((char*)&pos.y, 4);
+        zReader->read((char*)&pos.z, 4);
         zStructure->addMemberPosition(pos);
     }
 }
@@ -163,13 +163,13 @@ void MultiblockStructureType::loadSuperStructure(
 void MultiblockStructureType::saveSuperStructure(
     MultiblockStructure* zStructure, Framework::StreamWriter* zWriter) const
 {
-    int blockCount = zStructure->memberBlockPositions.getEintragAnzahl();
-    zWriter->schreibe((char*)&blockCount, 4);
+    int blockCount = zStructure->memberBlockPositions.getEntryCount();
+    zWriter->write((char*)&blockCount, 4);
     for (Framework::Vec3<int> pos : zStructure->memberBlockPositions)
     {
-        zWriter->schreibe((char*)&pos.x, 4);
-        zWriter->schreibe((char*)&pos.y, 4);
-        zWriter->schreibe((char*)&pos.z, 4);
+        zWriter->write((char*)&pos.x, 4);
+        zWriter->write((char*)&pos.y, 4);
+        zWriter->write((char*)&pos.z, 4);
     }
 }
 

FactoryCraft/MultiblockStructure.h

@@ -1,7 +1,7 @@
 #pragma once
 
 #include <Array.h>
-#include <Punkt.h>
+#include <Point.h>
 #include <ReferenceCounter.h>
 #include <Vec3.h>
 #include <Writer.h>
@@ -21,7 +21,7 @@ public:
 class MultiblockStructure : public virtual Framework::ReferenceCounter
 {
 private:
-    Framework::Array<Framework::Punkt> affectedChunks;
+    Framework::Array<Framework::Point> affectedChunks;
     Framework::Array<Framework::Vec3<int>> memberBlockPositions;
     Framework::Vec3<int> uniquePosition;
     int dimensionId;

FactoryCraft/MultiblockStructureManager.cpp

@@ -1,6 +1,6 @@
 #include "MultiblockStructureManager.h"
 
-#include <Datei.h>
+#include <File.h>
 #include <Logging.h>
 
 #include "Block.h"
@@ -11,8 +11,8 @@ MultiblockStructureManager::MultiblockStructureManager(int dimensionId)
 {
     Framework::Text path = Game::INSTANCE->getWorldDirectory() + "/dim/"
                          + Framework::Text(dimensionId) + "/structures";
-    Framework::Datei folder(path);
-    Framework::RCArray<Framework::Text>* files = folder.getDateiListe();
+    Framework::File folder(path);
+    Framework::RCArray<Framework::Text>* files = folder.getFileList();
     if (files)
     {
         Framework::Logging::info() << "Loading Multiblock Position Cache";
@@ -20,20 +20,20 @@ MultiblockStructureManager::MultiblockStructureManager(int dimensionId)
             = new Framework::ConsoleProgressBar();
         Game::consoleHandler->addContent(
             progressBar, Framework::ConsoleContentPosition::Top);
-        progressBar->setMaxProgress(files->getEintragAnzahl());
+        progressBar->setMaxProgress(files->getEntryCount());
         progressBar->triggerUpdate();
         char addr[12];
         for (Framework::Text* name : *files)
         {
-            Framework::Datei d(Framework::Text(folder.zPfad()->getText()) + "/"
+            Framework::File d(Framework::Text(folder.zPfad()->getText()) + "/"
                                + name->getText());
-            if (d.open(Framework::Datei::Style::lesen))
+            if (d.open(Framework::File::Style::read))
             {
-                d.lese(addr, 4);
-                d.lese(addr + 4, 4);
-                d.lese(addr + 8, 4);
+                d.read(addr, 4);
+                d.read(addr + 4, 4);
+                d.read(addr + 8, 4);
                 __int64 id;
-                d.lese((char*)&id, 8);
+                d.read((char*)&id, 8);
                 idCache.set(addr, 12, id);
                 d.close();
             }
@@ -51,17 +51,17 @@ MultiblockStructure* MultiblockStructureManager::loadStructure(__int64 id) const
                          + Framework::Text(dimensionId) + "/structures/";
     path.appendHex(id);
     path += ".str";
-    Framework::Datei d(path);
+    Framework::File d(path);
     Framework::Vec3<int> uPos;
-    if (d.open(Framework::Datei::Style::lesen))
+    if (d.open(Framework::File::Style::read))
     {
-        d.lese((char*)&uPos.x, 4);
-        d.lese((char*)&uPos.y, 4);
-        d.lese((char*)&uPos.z, 4);
+        d.read((char*)&uPos.x, 4);
+        d.read((char*)&uPos.y, 4);
+        d.read((char*)&uPos.z, 4);
         __int64 strId;
-        d.lese((char*)&strId, 8);
+        d.read((char*)&strId, 8);
         int type;
-        d.lese((char*)&type, 4);
+        d.read((char*)&type, 4);
         MultiblockStructure* str
             = Game::INSTANCE->zMultiblockStructureType(type)->loadStructure(
                 dimensionId, strId, uPos, &d);
@@ -85,22 +85,22 @@ __int64 MultiblockStructureManager::getStructureId(
 void MultiblockStructureManager::saveStructure(
     MultiblockStructure* zStructure) const
 {
-    Framework::Datei d;
+    Framework::File d;
     Framework::Text path = Game::INSTANCE->getWorldDirectory() + "/dim/"
                          + Framework::Text(dimensionId) + "/structures/";
     path.appendHex(zStructure->getStructureId());
     path += ".str";
-    d.setDatei(path);
-    d.erstellen();
-    d.open(Framework::Datei::Style::schreiben);
+    d.setFile(path);
+    d.create();
+    d.open(Framework::File::Style::write);
     auto uPos = zStructure->getUniquePosition();
-    d.schreibe((char*)&uPos.x, 4);
-    d.schreibe((char*)&uPos.y, 4);
-    d.schreibe((char*)&uPos.z, 4);
+    d.write((char*)&uPos.x, 4);
+    d.write((char*)&uPos.y, 4);
+    d.write((char*)&uPos.z, 4);
     __int64 strId = zStructure->getStructureId();
-    d.schreibe((char*)&strId, 8);
+    d.write((char*)&strId, 8);
     int typeId = zStructure->getStructureTypeId();
-    d.schreibe((char*)&typeId, 4);
+    d.write((char*)&typeId, 4);
     Game::INSTANCE->zMultiblockStructureType(zStructure->getStructureTypeId())
         ->saveStructure(zStructure, &d);
     d.close();

FactoryCraft/MultiblockTree.cpp

@@ -30,7 +30,7 @@ void MultiblockTree::onBlockRemoved(
                 0);
             Block* current = tmp.isA() ? tmp.getA() : 0;
             if (current && isBlockMember(current)) queue.add(current);
-            while (queue.getEintragAnzahl() > 0)
+            while (queue.getEntryCount() > 0)
             {
                 current = queue.get(0);
                 queue.remove(0);

FactoryCraft/NetworkMessage.cpp

@@ -44,7 +44,7 @@ void NetworkMessage::addressChunck(const Chunk* zChunk)
     address[0] = 1; // dimension response
     *(int*)(address + 1) = zChunk->getDimensionId();
     address[5] = 1; // chunck
-    Framework::Punkt center = zChunk->getCenter();
+    Framework::Point center = zChunk->getCenter();
     *(int*)(address + 6) = center.x;
     *(int*)(address + 10) = center.y;
 }
@@ -146,7 +146,7 @@ void NetworkMessage::sendChatMessage(ChatMessage* zMsg)
     Framework::InMemoryBuffer buffer;
     zMsg->writeTo(&buffer);
     char* msg = new char[buffer.getSize()];
-    buffer.lese(msg, (int)buffer.getSize());
+    buffer.read(msg, (int)buffer.getSize());
     setMessage(msg, (int)buffer.getSize());
 }
 
@@ -159,7 +159,7 @@ void NetworkMessage::sendChatOptions(ChatObserver* zOptions)
     Framework::InMemoryBuffer buffer;
     zOptions->writeTo(&buffer);
     char* msg = new char[buffer.getSize()];
-    buffer.lese(msg, (int)buffer.getSize());
+    buffer.read(msg, (int)buffer.getSize());
     setMessage(msg, (int)buffer.getSize());
 }
 
@@ -172,7 +172,7 @@ void NetworkMessage::sendMap(ChunkMap* zMap)
     Framework::InMemoryBuffer buffer;
     zMap->writeTo(&buffer);
     char* msg = new char[buffer.getSize()];
-    buffer.lese(msg, (int)buffer.getSize());
+    buffer.read(msg, (int)buffer.getSize());
     setMessage(msg, (int)buffer.getSize());
 }
 
@@ -196,7 +196,7 @@ void NetworkMessage::sendToAll()
 }
 
 void NetworkMessage::animateBlockBone(int dimensionId,
-    Framework::Punkt chunkCenter,
+    Framework::Point chunkCenter,
     int index,
     int boneId,
     double time,
@@ -249,20 +249,20 @@ void NetworkMessage::addEntityMessage(const Entity* zEntity)
         addressDimension(dim);
         Framework::InMemoryBuffer buffer;
         int id = zEntity->zType()->getId();
-        buffer.schreibe("\x7", 1); // add entity
-        buffer.schreibe((char*)&id, 4);
+        buffer.write("\x7", 1); // add entity
+        buffer.write((char*)&id, 4);
         id = zEntity->getId();
-        buffer.schreibe((char*)&id, 4);
+        buffer.write((char*)&id, 4);
         Framework::Vec3<float> pos = zEntity->getPosition();
-        buffer.schreibe((char*)&pos.x, 4);
-        buffer.schreibe((char*)&pos.y, 4);
-        buffer.schreibe((char*)&pos.z, 4);
+        buffer.write((char*)&pos.x, 4);
+        buffer.write((char*)&pos.y, 4);
+        buffer.write((char*)&pos.z, 4);
         bool special = !zEntity->hasDefaultModel();
-        buffer.schreibe((char*)&special, 1);
+        buffer.write((char*)&special, 1);
         if (special) zEntity->zSpecialModel()->writeTo(&buffer);
         msgLength = (int)buffer.getSize();
         message = new char[msgLength];
-        buffer.lese(message, (int)buffer.getSize());
+        buffer.read(message, (int)buffer.getSize());
     }
 }
 
@@ -298,10 +298,10 @@ void NetworkMessage::writeTo(Framework::StreamWriter* zWriter) const
     int total = msgLength + addressLength;
     if (total > 0)
     {
-        zWriter->schreibe((char*)&GameClient::Message::API_MESSAGE, 1);
-        zWriter->schreibe((char*)&total, 4);
-        zWriter->schreibe(address, addressLength);
-        zWriter->schreibe(message, msgLength);
+        zWriter->write((char*)&GameClient::Message::API_MESSAGE, 1);
+        zWriter->write((char*)&total, 4);
+        zWriter->write(address, addressLength);
+        zWriter->write(message, msgLength);
         if (onAfterSend) onAfterSend();
     }
     else

FactoryCraft/NetworkMessage.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#include <Punkt.h>
+#include <Point.h>
 #include <ReferenceCounter.h>
 #include <Vec3.h>
 #include <Writer.h>
@@ -45,7 +45,7 @@ public:
     void setUseBackground();
     void sendToAll();
     void animateBlockBone(int dimensionId,
-        Framework::Punkt chunkCenter,
+        Framework::Point chunkCenter,
         int index,
         int boneId,
         double time,

FactoryCraft/NoiseInterpolator.h

@@ -2,12 +2,12 @@
 
 #include "Cache.h"
 #include "Noise.h"
-#include "Punkt.h"
+#include "Point.h"
 #include "RCPointer.h"
 
 class NoiseInterpolator : public Noise
 {
-    Framework::Punkt noiseSize;
+    Framework::Point noiseSize;
     Framework::Cache<int, Framework::RCPointer<Noise>> cache;
     std::function<Noise*(int)> noiseSupplier;
     int seed;

FactoryCraft/PlaceableProof.cpp

@@ -267,42 +267,42 @@ PlaceableProofBlockFilter* PlaceableProofBlockFilterFactory::fromJson(
 {
     PlaceableProofBlockFilter* result = new PlaceableProofBlockFilter();
     Direction dir = NO_DIRECTION;
-    if (zJson->zValue("direction")->asString()->getString().istGleich("top"))
+    if (zJson->zValue("direction")->asString()->getString().isEqual("top"))
     {
         dir = TOP;
     }
     else if (zJson->zValue("direction")
                  ->asString()
                  ->getString()
-                 .istGleich("bottom"))
+                 .isEqual("bottom"))
     {
         dir = BOTTOM;
     }
     else if (zJson->zValue("direction")
                  ->asString()
                  ->getString()
-                 .istGleich("north"))
+                 .isEqual("north"))
     {
         dir = NORTH;
     }
     else if (zJson->zValue("direction")
                  ->asString()
                  ->getString()
-                 .istGleich("east"))
+                 .isEqual("east"))
     {
         dir = EAST;
     }
     else if (zJson->zValue("direction")
                  ->asString()
                  ->getString()
-                 .istGleich("south"))
+                 .isEqual("south"))
     {
         dir = SOUTH;
     }
     else if (zJson->zValue("direction")
                  ->asString()
                  ->getString()
-                 .istGleich("west"))
+                 .isEqual("west"))
     {
         dir = WEST;
     }

FactoryCraft/PlantConfig.cpp

@@ -187,16 +187,16 @@ PlantConfig* PlantConfigFactory::fromJson(
     {
         Framework::Text locationStr
             = zLocationsArray->zValue(i)->asString()->getString();
-        if (locationStr.istGleich("CAVE"))
+        if (locationStr.isEqual("CAVE"))
         {
             config->setLocations(config->getLocations() | PlantLocation::CAVE);
         }
-        else if (locationStr.istGleich("UNDERWATER"))
+        else if (locationStr.isEqual("UNDERWATER"))
         {
             config->setLocations(
                 config->getLocations() | PlantLocation::UNDERWATER);
         }
-        else if (locationStr.istGleich("SURFACE"))
+        else if (locationStr.isEqual("SURFACE"))
         {
             config->setLocations(
                 config->getLocations() | PlantLocation::SURFACE);

FactoryCraft/Player.cpp

@@ -209,12 +209,12 @@ void Player::playerApi(
     Framework::StreamReader* zRequest, NetworkMessage* zResponse)
 {
     char byte;
-    zRequest->lese(&byte, 1);
+    zRequest->read(&byte, 1);
     switch (byte)
     {
     case 0:
         // stop action
-        zRequest->lese(&byte, 1);
+        zRequest->read(&byte, 1);
         switch (byte)
         {
         case 8:
@@ -227,7 +227,7 @@ void Player::playerApi(
         break;
     case 1:
         // begin action
-        zRequest->lese(&byte, 1);
+        zRequest->read(&byte, 1);
         switch (byte)
         {
         case 8:
@@ -241,9 +241,9 @@ void Player::playerApi(
     case 2:
         // set face direction
         {
-            zRequest->lese((char*)&faceDir.x, 4);
-            zRequest->lese((char*)&faceDir.y, 4);
-            zRequest->lese((char*)&faceDir.z, 4);
+            zRequest->read((char*)&faceDir.x, 4);
+            zRequest->read((char*)&faceDir.y, 4);
+            zRequest->read((char*)&faceDir.z, 4);
             // TODO: calculate rotation and try to rotate without collision
             calculateTarget(
                 !itemBar.get(leftHandPosition)->isEmpty()
@@ -253,8 +253,8 @@ void Player::playerApi(
         }
     case 3:
         { // switch item bar position
-            zRequest->lese((char*)&leftHandPosition, 4);
-            leftHandPosition = leftHandPosition % itemBar.getEintragAnzahl();
+            zRequest->read((char*)&leftHandPosition, 4);
+            leftHandPosition = leftHandPosition % itemBar.getEntryCount();
             NetworkMessage* msg = new NetworkMessage();
             msg->addressUIElement("gui_item_bar", -1);
             char* message = new char[5];
@@ -288,48 +288,48 @@ void Player::playerApi(
     case 6:
         { // inventory transaction
             bool isEntity;
-            zRequest->lese((char*)&isEntity, 1);
+            zRequest->read((char*)&isEntity, 1);
             Inventory* source;
             if (isEntity)
             {
                 int id;
-                zRequest->lese((char*)&id, 4);
+                zRequest->read((char*)&id, 4);
                 source = Game::INSTANCE->zEntity(id, dimensionId);
             }
             else
             {
                 int dim;
                 Framework::Vec3<int> pos;
-                zRequest->lese((char*)&dim, 4);
-                zRequest->lese((char*)&pos.x, 4);
-                zRequest->lese((char*)&pos.y, 4);
-                zRequest->lese((char*)&pos.z, 4);
+                zRequest->read((char*)&dim, 4);
+                zRequest->read((char*)&pos.x, 4);
+                zRequest->read((char*)&pos.y, 4);
+                zRequest->read((char*)&pos.z, 4);
                 source = Game::INSTANCE->zBlockAt(pos, dim, 0);
             }
             int sourceSlotId;
-            zRequest->lese((char*)&sourceSlotId, 4);
-            zRequest->lese((char*)&isEntity, 1);
+            zRequest->read((char*)&sourceSlotId, 4);
+            zRequest->read((char*)&isEntity, 1);
             Inventory* target;
             if (isEntity)
             {
                 int id;
-                zRequest->lese((char*)&id, 4);
+                zRequest->read((char*)&id, 4);
                 target = Game::INSTANCE->zEntity(id, dimensionId);
             }
             else
             {
                 int dim;
                 Framework::Vec3<int> pos;
-                zRequest->lese((char*)&dim, 4);
-                zRequest->lese((char*)&pos.x, 4);
-                zRequest->lese((char*)&pos.y, 4);
-                zRequest->lese((char*)&pos.z, 4);
+                zRequest->read((char*)&dim, 4);
+                zRequest->read((char*)&pos.x, 4);
+                zRequest->read((char*)&pos.y, 4);
+                zRequest->read((char*)&pos.z, 4);
                 target = Game::INSTANCE->zBlockAt(pos, dim, 0);
             }
             if (source && target)
             {
                 int targetSlotId;
-                zRequest->lese((char*)&targetSlotId, 4);
+                zRequest->read((char*)&targetSlotId, 4);
                 SpecificSlotFilter filter(sourceSlotId, targetSlotId);
                 source->interactWith(target, Direction::NO_DIRECTION)
                     .pushItems(source->zSlot(sourceSlotId)->getNumberOfItems(),
@@ -340,12 +340,12 @@ void Player::playerApi(
     case 7: // craft action
         {
             bool isEntity;
-            zRequest->lese((char*)&isEntity, 1);
+            zRequest->read((char*)&isEntity, 1);
             BasicShapedCrafter* target;
             if (isEntity)
             {
                 int id;
-                zRequest->lese((char*)&id, 4);
+                zRequest->read((char*)&id, 4);
                 target = dynamic_cast<BasicShapedCrafter*>(
                     Game::INSTANCE->zEntity(id, dimensionId));
                 if (target) target->applyCurrentRecipie();
@@ -354,10 +354,10 @@ void Player::playerApi(
             {
                 int dim;
                 Framework::Vec3<int> pos;
-                zRequest->lese((char*)&dim, 4);
-                zRequest->lese((char*)&pos.x, 4);
-                zRequest->lese((char*)&pos.y, 4);
-                zRequest->lese((char*)&pos.z, 4);
+                zRequest->read((char*)&dim, 4);
+                zRequest->read((char*)&pos.x, 4);
+                zRequest->read((char*)&pos.y, 4);
+                zRequest->read((char*)&pos.z, 4);
                 target = dynamic_cast<BasicShapedCrafter*>(
                     Game::INSTANCE->zRealBlockInstance(pos, dim));
                 if (target)
@@ -371,7 +371,7 @@ void Player::playerApi(
                     if (block)
                     {
                         int index;
-                        zRequest->lese((char*)&index, 4);
+                        zRequest->read((char*)&index, 4);
                         block->zComponent(index);
                         target = dynamic_cast<BasicShapedCrafter*>(block);
                         if (target)
@@ -403,7 +403,7 @@ void Player::playerApi(
     case 10: // change movement flags
         {
             int flags;
-            zRequest->lese((char*)&flags, 4);
+            zRequest->read((char*)&flags, 4);
             flags &= 0xFFF; // only lower 12 bits are valid
             flags |= movementFlags & 0xFFFFF000;
             movementFlags = flags;
@@ -443,11 +443,11 @@ void PlayerEntityType::loadSuperEntity(
     if (!zPlayer)
         throw "PlayerEntityType::loadSuperEntity was called with an entity "
               "witch is not an instance of Player";
-    zReader->lese((char*)&zPlayer->leftHandPosition, 4);
+    zReader->read((char*)&zPlayer->leftHandPosition, 4);
     char len;
-    zReader->lese(&len, 1);
+    zReader->read(&len, 1);
     char* name = new char[(int)len + 1];
-    zReader->lese(name, (int)len);
+    zReader->read(name, (int)len);
     name[(int)len] = 0;
     zPlayer->name = name;
     delete[] name;
@@ -461,10 +461,10 @@ void PlayerEntityType::saveSuperEntity(
     if (!zPlayer)
         throw "PlayerEntityType::saveSuperEntity was called with an entity "
               "witch is not an instance of Player";
-    zWriter->schreibe((char*)&zPlayer->leftHandPosition, 4);
+    zWriter->write((char*)&zPlayer->leftHandPosition, 4);
     char len = (char)Framework::textLength(zPlayer->getName());
-    zWriter->schreibe(&len, 1);
-    zWriter->schreibe(zPlayer->getName(), (int)len);
+    zWriter->write(&len, 1);
+    zWriter->write(zPlayer->getName(), (int)len);
     EntityType::saveSuperEntity(zEntity, zWriter);
 }
 

FactoryCraft/PlayerRegister.cpp

@@ -1,6 +1,6 @@
 #include "PlayerRegister.h"
 
-#include <Datei.h>
+#include <File.h>
 
 Framework::Text randomSecret()
 {
@@ -24,18 +24,18 @@ RegisteredPlayer::RegisteredPlayer(int id, Framework::Text name)
 RegisteredPlayer::RegisteredPlayer(Framework::StreamReader* zReader)
     : Framework::ReferenceCounter()
 {
-    zReader->lese((char*)&id, 4);
+    zReader->read((char*)&id, 4);
     char len;
-    zReader->lese(&len, 1);
+    zReader->read(&len, 1);
     char* buffer = new char[len + 1];
-    zReader->lese(buffer, len);
+    zReader->read(buffer, len);
     buffer[(int)len] = 0;
     name = buffer;
     delete[] buffer;
     short sLen;
-    zReader->lese((char*)&sLen, 2);
+    zReader->read((char*)&sLen, 2);
     buffer = new char[sLen + 1];
-    zReader->lese(buffer, sLen);
+    zReader->read(buffer, sLen);
     buffer[sLen] = 0;
     secret = buffer;
     delete[] buffer;
@@ -58,27 +58,27 @@ Framework::Text RegisteredPlayer::getSecret() const
 
 void RegisteredPlayer::save(Framework::StreamWriter* zWriter) const
 {
-    zWriter->schreibe((char*)&id, 4);
+    zWriter->write((char*)&id, 4);
     char len = (char)name.getLength();
-    zWriter->schreibe(&len, 1);
-    zWriter->schreibe(name.getText(), len);
+    zWriter->write(&len, 1);
+    zWriter->write(name.getText(), len);
     short sLen = (short)secret.getLength();
-    zWriter->schreibe((char*)&sLen, 2);
-    zWriter->schreibe(secret.getText(), sLen);
+    zWriter->write((char*)&sLen, 2);
+    zWriter->write(secret.getText(), sLen);
 }
 
 PlayerRegister::PlayerRegister(Framework::Text worldPath)
     : Framework::ReferenceCounter(),
       path(worldPath + "/player/players.reg")
 {
-    Framework::Datei regDat;
-    regDat.setDatei(path);
-    if (!regDat.existiert())
+    Framework::File regDat;
+    regDat.setFile(path);
+    if (!regDat.exists())
     {
-        regDat.erstellen();
+        regDat.create();
     }
-    regDat.open(Framework::Datei::Style::lesen);
-    while (!regDat.istEnde())
+    regDat.open(Framework::File::Style::read);
+    while (!regDat.isEnd())
     {
         RegisteredPlayer* p = new RegisteredPlayer(&regDat);
         players.add(p);
@@ -93,7 +93,7 @@ Framework::Text PlayerRegister::addPlayer(Framework::Text name)
     for (RegisteredPlayer* player : players)
     {
         nextId = MAX(nextId, player->getId() + 1);
-        if (player->getName().istGleich(name))
+        if (player->getName().isEqual(name))
         {
             cs.unlock();
             return "";
@@ -111,7 +111,7 @@ bool PlayerRegister::hasPlayer(Framework::Text name)
     cs.lock();
     for (RegisteredPlayer* player : players)
     {
-        if (player->getName().istGleich(name))
+        if (player->getName().isEqual(name))
         {
             cs.unlock();
             return 1;
@@ -126,7 +126,7 @@ int PlayerRegister::getPlayerId(Framework::Text name)
     cs.lock();
     for (RegisteredPlayer* player : players)
     {
-        if (player->getName().istGleich(name))
+        if (player->getName().isEqual(name))
         {
             cs.unlock();
             return player->getId();
@@ -141,10 +141,10 @@ bool PlayerRegister::checkSecret(Framework::Text name, Framework::Text secret)
     cs.lock();
     for (RegisteredPlayer* player : players)
     {
-        if (player->getName().istGleich(name))
+        if (player->getName().isEqual(name))
         {
             cs.unlock();
-            return player->getSecret().istGleich(secret);
+            return player->getSecret().isEqual(secret);
         }
     }
     cs.unlock();
@@ -154,13 +154,13 @@ bool PlayerRegister::checkSecret(Framework::Text name, Framework::Text secret)
 void PlayerRegister::save()
 {
     cs.lock();
-    Framework::Datei regDat;
-    regDat.setDatei(path);
-    if (!regDat.existiert())
+    Framework::File regDat;
+    regDat.setFile(path);
+    if (!regDat.exists())
     {
-        regDat.erstellen();
+        regDat.create();
     }
-    regDat.open(Framework::Datei::Style::schreiben);
+    regDat.open(Framework::File::Style::write);
     for (RegisteredPlayer* player : players)
     {
         player->save(&regDat);

FactoryCraft/Quest.cpp

@@ -1,6 +1,6 @@
 #include "Quest.h"
 
-#include <Datei.h>
+#include <File.h>
 #include <Logging.h>
 
 #include "Game.h"
@@ -102,7 +102,7 @@ QuestRequirementStorage* QuestStorage::zStorage(Framework::Text requirementId)
 {
     for (QuestRequirementStorage* storage : requirements)
     {
-        if (storage->getRequirementId().istGleich(requirementId))
+        if (storage->getRequirementId().isEqual(requirementId))
         {
             return storage;
         }
@@ -240,19 +240,19 @@ void QuestParty::removeMember(int memberEntityId)
 
 bool QuestParty::isMember(int memberEntityId) const
 {
-    return memberEntityIds.hat(memberEntityId);
+    return memberEntityIds.has(memberEntityId);
 }
 
 bool QuestParty::isEmpty() const
 {
-    return memberEntityIds.getEintragAnzahl() == 0;
+    return memberEntityIds.getEntryCount() == 0;
 }
 
 QuestStorage* QuestParty::zQuestStorage(Framework::Text questId)
 {
     for (QuestStorage* storage : questStorage)
     {
-        if (storage->getQuestId().istGleich(questId))
+        if (storage->getQuestId().isEqual(questId))
         {
             return storage;
         }
@@ -368,7 +368,7 @@ bool Quest::isVisible(QuestParty* zParty, QuestManager* zManager)
     {
         return 1;
     }
-    bool visible = requiredQuestsIds.getEintragAnzahl() == 0;
+    bool visible = requiredQuestsIds.getEntryCount() == 0;
     for (Framework::Text* requiredQuestId : requiredQuestsIds)
     {
         visible |= zParty->zQuestStorage(*requiredQuestId)->isQuestFinished();
@@ -408,7 +408,7 @@ bool Quest::isActive(QuestParty* zParty)
         last = requiredQuestsIdsI.val();
         requiredQuestsIdsI++;
     }
-    if (!first || requiredQuestsIds.getEintragAnzahl() == 0)
+    if (!first || requiredQuestsIds.getEntryCount() == 0)
     {
         active |= tmp;
     }
@@ -659,7 +659,7 @@ void QuestCollection::setQuestVisible(bool visible,
 {
     for (Quest* quest : quests)
     {
-        if (quest->getQuestId().istGleich(questId))
+        if (quest->getQuestId().isEqual(questId))
         {
             return quest->setVisible(visible, zParty, zManager);
         }
@@ -739,7 +739,7 @@ void QuestManager::loadQuests()
 {
     Framework::Text worldDir = Game::INSTANCE->getWorldDirectory();
     Framework::Text questDir = worldDir + "/quests";
-    if (!Framework::DateiExistiert(questDir))
+    if (!Framework::FileExists(questDir))
     {
         Framework::Logging::info()
             << "no quest data found in world save, using default data";
@@ -783,11 +783,11 @@ void QuestManager::loadQuests()
         }
         valid->release();
         Framework::JSON::JSONObject* schema = validator->getJsonSchema();
-        Framework::Datei syntaxFile;
-        syntaxFile.setDatei("data/syntax/schema/quests.json");
-        syntaxFile.erstellen();
-        syntaxFile.open(Framework::Datei::Style::schreiben);
-        syntaxFile.schreibe(schema->toString(), schema->toString().getLength());
+        Framework::File syntaxFile;
+        syntaxFile.setFile("data/syntax/schema/quests.json");
+        syntaxFile.create();
+        syntaxFile.open(Framework::File::Style::write);
+        syntaxFile.write(schema->toString(), schema->toString().getLength());
         syntaxFile.close();
         schema->release();
         validator->release();
@@ -828,8 +828,8 @@ void QuestManager::loadQuests()
         validator->release();
     }
     Framework::Logging::info()
-        << "Loaded " << questCollections.getEintragAnzahl()
-        << " Quest Collections and " << parties.getEintragAnzahl()
+        << "Loaded " << questCollections.getEntryCount()
+        << " Quest Collections and " << parties.getEntryCount()
         << " Quest Parties";
 }
 
@@ -837,9 +837,9 @@ void QuestManager::saveQuests()
 {
     Framework::Text worldDir = Game::INSTANCE->getWorldDirectory();
     Framework::Text questDir = worldDir + "/quests";
-    if (!Framework::DateiExistiert(questDir))
+    if (!Framework::FileExists(questDir))
     {
-        Framework::DateiPfadErstellen(questDir + "/");
+        Framework::FilePathCreate(questDir + "/");
     }
     Framework::JSON::JSONArray* questCollectionsArray
         = new Framework::JSON::JSONArray();
@@ -848,24 +848,24 @@ void QuestManager::saveQuests()
         questCollectionsArray->addValue(
             Game::INSTANCE->zTypeRegistry()->toJson(questCollection));
     }
-    Framework::Datei datei(questDir + "/quests.json");
-    if (!datei.existiert()) datei.erstellen();
-    datei.open(Framework::Datei::Style::schreiben);
+    Framework::File File(questDir + "/quests.json");
+    if (!File.exists()) File.create();
+    File.open(Framework::File::Style::write);
     Framework::Text jsonStr = questCollectionsArray->toString();
-    datei.schreibe(jsonStr.getText(), jsonStr.getLength());
-    datei.close();
+    File.write(jsonStr.getText(), jsonStr.getLength());
+    File.close();
     questCollectionsArray->release();
     Framework::JSON::JSONArray* partiesArray = new Framework::JSON::JSONArray();
     for (QuestParty* party : parties)
     {
         partiesArray->addValue(Game::INSTANCE->zTypeRegistry()->toJson(party));
     }
-    datei.setDatei(questDir + "/parties.json");
-    if (!datei.existiert()) datei.erstellen();
-    datei.open(Framework::Datei::Style::schreiben);
+    File.setFile(questDir + "/parties.json");
+    if (!File.exists()) File.create();
+    File.open(Framework::File::Style::write);
     jsonStr = partiesArray->toString();
-    datei.schreibe(jsonStr.getText(), jsonStr.getLength());
-    datei.close();
+    File.write(jsonStr.getText(), jsonStr.getLength());
+    File.close();
     partiesArray->release();
 }
 

FactoryCraft/QuestDialog.cpp

@@ -1,7 +1,7 @@
 #include "QuestDialog.h"
 
-#include <Fenster.h>
-#include <TextFeld.h>
+#include <TextField.h>
+#include <Window.h>
 
 #include "Game.h"
 #include "Quest.h"
@@ -47,9 +47,9 @@ QuestDialog::QuestDialog(int playerId)
                              ->setID("questDetailView")
                              ->setWidthPercentage(100)
                              ->setHeightPercentage(0)
-                             ->setStyle(Framework::Fenster::Style::Titel
-                                        | Framework::Fenster::Style::Erlaubt
-                                        | Framework::Fenster::Style::Sichtbar)
+                             ->setStyle(Framework::Window::Style::Title
+                                        | Framework::Window::Style::Allowed
+                                        | Framework::Window::Style::Visible)
                              ->setTitleHeight(30)
                              ->setTitleFontSize(20)
                              ->build())
@@ -60,13 +60,13 @@ void QuestDialog::api(
     Framework::StreamReader* zRequest, NetworkMessage* zResponse)
 {
     char typ;
-    zRequest->lese(&typ, 1);
+    zRequest->read(&typ, 1);
     switch (typ)
     {
     case 0: // onSelect Message of listView
         {   // open quest graph
             int selection;
-            zRequest->lese((char*)&selection, 4);
+            zRequest->read((char*)&selection, 4);
             if (selection >= 0)
             {
                 auto questGraph = this->uiml->selectChildsByName("questGraph");
@@ -98,9 +98,9 @@ void QuestDialog::api(
     case 1: // onClick Message of questGraphItem
         {   // open quest detail view
             unsigned char len;
-            zRequest->lese((char*)&len, 1);
+            zRequest->read((char*)&len, 1);
             char* id = new char[len + 1];
-            zRequest->lese(id, len);
+            zRequest->read(id, len);
             id[len] = 0;
             Framework::Text selectedId
                 = uiml->selectChildsByName("listView")
@@ -119,8 +119,7 @@ void QuestDialog::api(
             QuestParty* zParty = zManager->zParty(getPlayerId());
             for (Quest* quest : questCollection->quests)
             {
-                if (quest->isActive(zParty)
-                    && quest->getQuestId().istGleich(id))
+                if (quest->isActive(zParty) && quest->getQuestId().isEqual(id))
                 {
                     QuestStorage* zStorage
                         = zParty->zQuestStorage(quest->questId);
@@ -179,7 +178,7 @@ void QuestDialog::api(
                       ->getAttributeValue("questId");
             for (Quest* quest : questCollection->quests)
             {
-                if (quest->getQuestId().istGleich(questId))
+                if (quest->getQuestId().isEqual(questId))
                 {
                     QuestStorage* zStorage
                         = zParty->zQuestStorage(quest->questId);
@@ -245,7 +244,7 @@ void QuestDialog::api(
                       .getFirstElement()
                       ->getAttributeValue("questId");
             unsigned char len;
-            zRequest->lese((char*)&len, 1);
+            zRequest->read((char*)&len, 1);
             char* requirementId = new char[len + 1];
             requirementId[len] = 0;
             auto requirementsContainer
@@ -254,12 +253,12 @@ void QuestDialog::api(
             {
                 for (Quest* quest : questCollection->quests)
                 {
-                    if (quest->getQuestId().istGleich(questId))
+                    if (quest->getQuestId().isEqual(questId))
                     {
                         for (QuestRequirement* requirement :
                             quest->requirements)
                         {
-                            if (requirement->getRequirementId().istGleich(
+                            if (requirement->getRequirementId().isEqual(
                                     requirementId))
                             {
                                 requirement->api(zRequest,
@@ -296,7 +295,7 @@ void QuestDialog::api(
                       .getFirstElement()
                       ->getAttributeValue("questId");
             unsigned char len;
-            zRequest->lese((char*)&len, 1);
+            zRequest->read((char*)&len, 1);
             char* reqardId = new char[len + 1];
             reqardId[len] = 0;
             auto requirementsContainer
@@ -305,11 +304,11 @@ void QuestDialog::api(
             {
                 for (Quest* quest : questCollection->quests)
                 {
-                    if (quest->getQuestId().istGleich(questId))
+                    if (quest->getQuestId().isEqual(questId))
                     {
                         for (QuestReward* reward : quest->rewards)
                         {
-                            if (reward->getRewardId().istGleich(reqardId))
+                            if (reward->getRewardId().isEqual(reqardId))
                             {
                                 reward->api(zRequest,
                                     (Framework::RCPointer<
@@ -377,7 +376,8 @@ Framework::XML::Element* QuestDialog::getQuestGraphItem(
         return UIMLBuilder::createQuestNode()
             ->setID(Framework::Text("quest_") += zQuest->questId)
             ->setQuestName(zQuest->questName)
-            ->setImagePath(zQuest->imagePath) // TODO: use icon for unknown quests
+            ->setImagePath(
+                zQuest->imagePath) // TODO: use icon for unknown quests
             ->setDescription(zQuest->description)
             ->setFinished(zStorage->isQuestFinished())
             ->setRewarded(zStorage->isQuestRewarded())
@@ -404,9 +404,9 @@ void QuestDialog::showQuestDetails(
             ->setMarginTop(10)
             ->setBorder(1, 0xFF52525E)
             ->enableVerticalScrollbar()
-            ->setStyle(Framework::TextFeld::Style::Text
-                       | Framework::TextFeld::Style::Mehrzeilig
-                       | Framework::TextFeld::Style::AutoLineBreak)
+            ->setStyle(Framework::TextField::Style::Text
+                       | Framework::TextField::Style::Multiline
+                       | Framework::TextField::Style::AutoLineBreak)
             ->build());
     UIMLContainerBuilder* requirementsContainerBuilder
         = UIMLBuilder::createContainer()
@@ -419,16 +419,16 @@ void QuestDialog::showQuestDetails(
               ->setHeight(100, -50)
               ->setDisplayAsColumn(0, 10)
               ->setBorder(1, 0xFF52525E)
-              ->setStyle(Framework::Fenster::Style::Sichtbar
-                         | Framework::Fenster::Style::Erlaubt
-                         | Framework::Fenster::Style::Rahmen)
+              ->setStyle(Framework::Window::Style::Visible
+                         | Framework::Window::Style::Allowed
+                         | Framework::Window::Style::Border)
               ->enableVerticalScrollbar()
               ->addChild(UIMLBuilder::createText("Requirements")
                       ->setID("quest_requirements_title")
                       ->setWidthPercentage(100)
                       ->setHeight(30)
-                      ->setStyle(Framework::TextFeld::Style::Text
-                                 | Framework::TextFeld::Style::Center)
+                      ->setStyle(Framework::TextField::Style::Text
+                                 | Framework::TextField::Style::Center)
                       ->setFontSize(20)
                       ->build());
     for (QuestRequirement* requirement : zQuest->requirements)
@@ -447,16 +447,16 @@ void QuestDialog::showQuestDetails(
               ->setHeight(50, -20)
               ->setDisplayAsColumn(0, 10)
               ->setBorder(1, 0xFF52525E)
-              ->setStyle(Framework::Fenster::Style::Sichtbar
-                         | Framework::Fenster::Style::Erlaubt
-                         | Framework::Fenster::Style::Rahmen)
+              ->setStyle(Framework::Window::Style::Visible
+                         | Framework::Window::Style::Allowed
+                         | Framework::Window::Style::Border)
               ->enableVerticalScrollbar()
               ->addChild(UIMLBuilder::createText("Rewards")
                       ->setID("quest_rewards_title")
                       ->setWidthPercentage(100)
                       ->setHeight(30)
-                      ->setStyle(Framework::TextFeld::Style::Text
-                                 | Framework::TextFeld::Style::Center)
+                      ->setStyle(Framework::TextField::Style::Text
+                                 | Framework::TextField::Style::Center)
                       ->setFontSize(20)
                       ->build());
     for (QuestReward* reward : zQuest->rewards)

FactoryCraft/QuestRequirement.cpp

@@ -1,6 +1,6 @@
 #include "QuestRequirement.h"
 
-#include <Fenster.h>
+#include <Window.h>
 
 #include "BlockType.h"
 #include "Game.h"
@@ -65,8 +65,8 @@ void QuestRequirementOpenDialog::addRequirementUIML(
               ->setWidthPercentage(100)
               ->setHeight(50)
               ->setDisplayAsRow(0, 10)
-              ->setStyle(Framework::Fenster::Style::Sichtbar
-                         | Framework::Fenster::Style::Erlaubt)
+              ->setStyle(Framework::Window::Style::Visible
+                         | Framework::Window::Style::Allowed)
               ->setID(Framework::Text("requirement_") += getRequirementId());
     // TODO: add icon of dialog
     Framework::Text status;
@@ -194,8 +194,8 @@ void QuestRequirementBlockBreak::addRequirementUIML(
               ->setWidthPercentage(100)
               ->setHeight(50)
               ->setDisplayAsRow(0, 10)
-              ->setStyle(Framework::Fenster::Style::Sichtbar
-                         | Framework::Fenster::Style::Erlaubt)
+              ->setStyle(Framework::Window::Style::Visible
+                         | Framework::Window::Style::Allowed)
               ->setID(Framework::Text("requirement_") += getRequirementId());
     int itemTypeId = Game::INSTANCE->zBlockType(blockTypeId)->getItemTypeId();
     if (itemTypeId > 0)
@@ -396,8 +396,8 @@ void QuestRequirementBlockPlace::addRequirementUIML(
               ->setWidthPercentage(100)
               ->setHeight(50)
               ->setDisplayAsRow(0, 10)
-              ->setStyle(Framework::Fenster::Style::Sichtbar
-                         | Framework::Fenster::Style::Erlaubt)
+              ->setStyle(Framework::Window::Style::Visible
+                         | Framework::Window::Style::Allowed)
               ->setID(Framework::Text("requirement_") += getRequirementId());
     int itemTypeId = Game::INSTANCE->zBlockType(blockTypeId)->getItemTypeId();
     if (itemTypeId > 0)
@@ -565,8 +565,8 @@ void QuestRequirementBlockInteract::addRequirementUIML(
               ->setWidthPercentage(100)
               ->setHeight(50)
               ->setDisplayAsRow(0, 10)
-              ->setStyle(Framework::Fenster::Style::Sichtbar
-                         | Framework::Fenster::Style::Erlaubt)
+              ->setStyle(Framework::Window::Style::Visible
+                         | Framework::Window::Style::Allowed)
               ->setID(Framework::Text("requirement_") += getRequirementId());
     int itemTypeId = Game::INSTANCE->zBlockType(blockTypeId)->getItemTypeId();
     if (itemTypeId > 0)
@@ -750,8 +750,8 @@ void QuestRequirementItemInInventory::addRequirementUIML(
               ->setWidthPercentage(100)
               ->setHeight(50)
               ->setDisplayAsRow(0, 10)
-              ->setStyle(Framework::Fenster::Style::Sichtbar
-                         | Framework::Fenster::Style::Erlaubt)
+              ->setStyle(Framework::Window::Style::Visible
+                         | Framework::Window::Style::Allowed)
               ->setID(Framework::Text("requirement_") += getRequirementId());
     builder->addChild(UIMLBuilder::createItemStack()
             ->setItemTypeID(itemTypeId)

FactoryCraft/QuestReward.cpp

@@ -1,6 +1,6 @@
 #include "QuestReward.h"
 
-#include <Fenster.h>
+#include <Window.h>
 
 #include "Entity.h"
 #include "Game.h"
@@ -144,8 +144,8 @@ void QuestRewardGiveItems::addRewardUIML(
               ->setWidthPercentage(100)
               ->setHeightAuto()
               ->setDisplayAsColumn(0, 10)
-              ->setStyle(Framework::Fenster::Style::Sichtbar
-                         | Framework::Fenster::Style::Erlaubt)
+              ->setStyle(Framework::Window::Style::Visible
+                         | Framework::Window::Style::Allowed)
               ->setID(Framework::Text("reward_") += rewardId)
               ->addChild(UIMLBuilder::createTextAuto("Item Reward:")->build());
     int index = 0;

FactoryCraft/RecipieList.cpp

@@ -38,7 +38,7 @@ void RecipieList::findRecipies(
 
 int RecipieList::getRecipieCount() const
 {
-    return recipies.getEintragAnzahl();
+    return recipies.getEntryCount();
 }
 
 Recipie* RecipieList::zRecipie(int index) const

FactoryCraft/RecipieLoader.cpp

@@ -1,6 +1,6 @@
 #include "RecipieLoader.h"
 
-#include <Datei.h>
+#include <File.h>
 #include <iostream>
 #include <Logging.h>
 #include <stdexcept>
@@ -55,11 +55,11 @@ void RecipieLoader::loadRecipies(const char* path)
                 << count << " recipie groups were loaded.";
         });
     Framework::JSON::JSONObject* schema = validator->getJsonSchema();
-    Framework::Datei syntaxFile;
-    syntaxFile.setDatei("data/syntax/schema/recipieGroups.json");
-    syntaxFile.erstellen();
-    syntaxFile.open(Framework::Datei::Style::schreiben);
-    syntaxFile.schreibe(schema->toString(), schema->toString().getLength());
+    Framework::File syntaxFile;
+    syntaxFile.setFile("data/syntax/schema/recipieGroups.json");
+    syntaxFile.create();
+    syntaxFile.open(Framework::File::Style::write);
+    syntaxFile.write(schema->toString(), schema->toString().getLength());
     syntaxFile.close();
     schema->release();
     validator->release();
@@ -104,10 +104,10 @@ void RecipieLoader::loadRecipies(const char* path)
             Framework::Logging::info() << count << " recipies were loaded.";
         });
     schema = validator->getJsonSchema();
-    syntaxFile.setDatei("data/syntax/schema/recipies.json");
-    syntaxFile.erstellen();
-    syntaxFile.open(Framework::Datei::Style::schreiben);
-    syntaxFile.schreibe(schema->toString(), schema->toString().getLength());
+    syntaxFile.setFile("data/syntax/schema/recipies.json");
+    syntaxFile.create();
+    syntaxFile.open(Framework::File::Style::write);
+    syntaxFile.write(schema->toString(), schema->toString().getLength());
     syntaxFile.close();
     schema->release();
     validator->release();
@@ -116,7 +116,7 @@ void RecipieLoader::loadRecipies(const char* path)
         bool found = 0;
         for (RecipieGroupConfig* groupConfig : groupConfigs)
         {
-            if (list->getName().istGleich(groupConfig->getGroupName()))
+            if (list->getName().isEqual(groupConfig->getGroupName()))
             {
                 found = 1;
                 break;
@@ -136,7 +136,7 @@ RecipieList* RecipieLoader::zRecipieList(const char* name) const
 {
     for (RecipieList* l : lists)
     {
-        if (l->getName().istGleich(name)) return l;
+        if (l->getName().isEqual(name)) return l;
     }
     return 0;
 }
@@ -156,11 +156,11 @@ Framework::XML::Element* RecipieLoader::getCrafingUIML(int itemTypeId) const
     {
         Framework::RCArray<Recipie> recipies;
         list->findRecipies(itemTypeId, recipies);
-        if (recipies.getEintragAnzahl() > 0)
+        if (recipies.getEntryCount() > 0)
         {
             for (RecipieGroupConfig* groupConfig : groupConfigs)
             {
-                if (list->getName().istGleich(groupConfig->getGroupName()))
+                if (list->getName().isEqual(groupConfig->getGroupName()))
                 {
                     recipiesBuilder->addRecipieGroup(list->getName(),
                         groupConfig->getIconItemType(),

FactoryCraft/Server.cpp

@@ -1,38 +1,38 @@
 #include "Server.h"
 
 #include <AsynchronCall.h>
-#include <Datei.h>
+#include <File.h>
 #include <Globals.h>
 #include <iostream>
 #include <Logging.h>
-#include <Zeit.h>
+#include <Timer.h>
 
 #include "Game.h"
 #include "PlayerRegister.h"
 
 // Inhalt der LoginServer Klasse aus LoginServer.h
 // Konstruktor
-FactoryCraftServer::FactoryCraftServer(InitDatei* zIni)
+FactoryCraftServer::FactoryCraftServer(InitFile* zIni)
     : ReferenceCounter()
 {
     Network::Start(100);
     runningThreads = 0;
     klients = new RCArray<FCKlient>();
-    ini = dynamic_cast<InitDatei*>(zIni->getThis());
-    id = (int)*zIni->zWert("ServerId");
+    ini = dynamic_cast<InitFile*>(zIni->getThis());
+    id = (int)*zIni->zValue("ServerId");
     sslServer = new SSLServer();
-    sslServer->setPrivateKeyPassword(zIni->zWert("SSLPasswort")->getText());
-    sslServer->setCertificateFile(zIni->zWert("SSLCert")->getText());
+    sslServer->setPrivateKeyPassword(zIni->zValue("SSLPasswort")->getText());
+    sslServer->setCertificateFile(zIni->zValue("SSLCert")->getText());
     Framework::Logging::info()
-        << "using cert file " << zIni->zWert("SSLCert")->getText();
-    sslServer->setPrivateKeyFile(zIni->zWert("SSLKey")->getText());
+        << "using cert file " << zIni->zValue("SSLCert")->getText();
+    sslServer->setPrivateKeyFile(zIni->zValue("SSLKey")->getText());
     Framework::Logging::info()
-        << "using private key " << zIni->zWert("SSLKey")->getText();
+        << "using private key " << zIni->zValue("SSLKey")->getText();
     server = new Server();
     Framework::Logging::info()
-        << "Server Port: " << ini->zWert("Port")->getText();
-    if (!server->verbinde(
-            (unsigned short)TextZuInt(ini->zWert("Port")->getText(), 10), 10))
+        << "Server Port: " << ini->zValue("Port")->getText();
+    if (!server->connect(
+            (unsigned short)TextZuInt(ini->zValue("Port")->getText(), 10), 10))
     {
         Framework::Logging::error()
             << "Der Server konnte nicht gestartet werden.";
@@ -40,9 +40,9 @@ FactoryCraftServer::FactoryCraftServer(InitDatei* zIni)
     }
 
     Framework::Logging::info()
-        << "SSL Server Port: " << ini->zWert("SSLPort")->getText();
-    if (!sslServer->verbinde(
-            (unsigned short)TextZuInt(ini->zWert("SSLPort")->getText(), 10),
+        << "SSL Server Port: " << ini->zValue("SSLPort")->getText();
+    if (!sslServer->connect(
+            (unsigned short)TextZuInt(ini->zValue("SSLPort")->getText(), 10),
             10))
     {
         Framework::Logging::error()
@@ -50,21 +50,21 @@ FactoryCraftServer::FactoryCraftServer(InitDatei* zIni)
         exit(2);
     }
     Game::initialize(
-        zIni->zWert("World")->getText(), zIni->zWert("SaveDir")->getText());
+        zIni->zValue("World")->getText(), zIni->zValue("SaveDir")->getText());
     new Framework::AsynchronCall("Server", [this]() {
         runningThreads++;
         while (server->isConnected())
         {
-            SKlient* klient = server->getKlient();
+            SClient* klient = server->getClient();
             if (!klient) continue;
             unsigned short len;
-            klient->setEmpfangTimeout(5000);
-            klient->getNachricht((char*)&len, 2);
+            klient->setReceiveTimeout(5000);
+            klient->getMessage((char*)&len, 2);
             char* key = new char[len];
-            klient->getNachricht((char*)key, len);
+            klient->getMessage((char*)key, len);
             bool bg;
-            klient->getNachricht((char*)&bg, 1);
-            klient->setEmpfangTimeout(0);
+            klient->getMessage((char*)&bg, 1);
+            klient->setReceiveTimeout(0);
             bool found = 0;
             cs.lock();
             for (FCKlient* client : *klients)
@@ -73,12 +73,12 @@ FactoryCraftServer::FactoryCraftServer(InitDatei* zIni)
                 {
                     if (bg)
                     {
-                        klient->sende("\1", 1);
+                        klient->send("\1", 1);
                         client->setBackgroundClient(klient);
                     }
                     else
                     {
-                        klient->sende("\1", 1);
+                        klient->send("\1", 1);
                         client->setForegroundClient(klient);
                     }
                     found = 1;
@@ -88,7 +88,7 @@ FactoryCraftServer::FactoryCraftServer(InitDatei* zIni)
             cs.unlock();
             if (!found)
             {
-                klient->sende("\0", 1);
+                klient->send("\0", 1);
                 Framework::Logging::error()
                     << "client failed to pass through authorisation";
                 klient->release();
@@ -101,8 +101,8 @@ FactoryCraftServer::FactoryCraftServer(InitDatei* zIni)
 // Destruktor
 FactoryCraftServer::~FactoryCraftServer()
 {
-    sslServer->trenne();
-    server->trenne();
+    sslServer->disconnect();
+    server->disconnect();
     while (runningThreads > 0)
         Sleep(100);
     sslServer->release();
@@ -117,7 +117,7 @@ void FactoryCraftServer::run()
     runningThreads++;
     while (sslServer->isConnected())
     {
-        SSLSKlient* klient = sslServer->getKlient();
+        SSLSClient* klient = sslServer->getClient();
         if (!klient) continue;
         Framework::getThreadRegister()->cleanUpClosedThreads();
         FCKlient* clHandle = new FCKlient(
@@ -133,10 +133,10 @@ void FactoryCraftServer::run()
 void FactoryCraftServer::close()
 {
     Game::INSTANCE->save();
-    sslServer->trenne();
-    server->trenne();
+    sslServer->disconnect();
+    server->disconnect();
     cs.lock();
-    for (int i = 0; i < klients->getEintragAnzahl(); i++)
+    for (int i = 0; i < klients->getEntryCount(); i++)
         klients->z(i)->absturz();
     cs.unlock();
 }
@@ -146,7 +146,7 @@ bool FactoryCraftServer::removeKlient(FCKlient* zKlient)
     bool gefunden = 0;
     getThis();
     cs.lock();
-    for (int i = 0; i < klients->getEintragAnzahl(); i++)
+    for (int i = 0; i < klients->getEntryCount(); i++)
     {
         if (klients->z(i) == zKlient)
         {
@@ -162,7 +162,7 @@ bool FactoryCraftServer::removeKlient(FCKlient* zKlient)
 
 bool FactoryCraftServer::hatClients() const
 {
-    return klients->hat(0);
+    return klients->has(0);
 }
 
 int FactoryCraftServer::getUnencryptedPort() const
@@ -170,9 +170,9 @@ int FactoryCraftServer::getUnencryptedPort() const
     return server->getPort();
 }
 
-// Inhalt der LSKlient aus LoginServer.h
+// Inhalt der LSClient aus LoginServer.h
 // Konstruktor
-FCKlient::FCKlient(SSLSKlient* klient, FactoryCraftServer* ls)
+FCKlient::FCKlient(SSLSClient* klient, FactoryCraftServer* ls)
     : Thread()
 {
     this->klient = klient;
@@ -212,19 +212,19 @@ void FCKlient::onInitialized()
     checkResources("data/models", filesToTransfer);
     checkResources("data/textures", filesToTransfer);
     short endSignal = 0;
-    foreground->sende((char*)&endSignal, 2);
+    foreground->send((char*)&endSignal, 2);
     char* buffer = new char[4096];
     for (Text* path : filesToTransfer)
     {
-        Datei file(path->getText());
+        File file(path->getText());
         __int64 length = file.getSize();
-        file.open(Datei::Style::lesen);
+        file.open(File::Style::read);
         int count = 0;
         while (count < length)
         {
             int l = MIN(4096, (int)length - count);
-            file.lese(buffer, l);
-            foreground->sende(buffer, l);
+            file.read(buffer, l);
+            foreground->send(buffer, l);
             count += l;
         }
         file.close();
@@ -236,10 +236,10 @@ void FCKlient::onInitialized()
 
 void FCKlient::checkResources(const char* path, RCArray<Text>& filesToTransfer)
 {
-    Datei file(path);
-    if (file.istOrdner())
+    File file(path);
+    if (file.isDirectory())
     {
-        RCArray<Text>* names = file.getDateiListe();
+        RCArray<Text>* names = file.getFileList();
         for (Text* name : *names)
         {
             Text tmp(path);
@@ -251,35 +251,34 @@ void FCKlient::checkResources(const char* path, RCArray<Text>& filesToTransfer)
     else
     {
         short len = (short)textLength(path);
-        foreground->sende((char*)&len, 2);
-        foreground->sende(path, len);
-        Datei resFile(path);
-        Zeit* zeit = resFile.getLastChange();
-        int tmp = zeit->zDatum()->getJahr();
-        foreground->sende((char*)&tmp, 4);
-        tmp = zeit->zDatum()->getMonat();
-        foreground->sende((char*)&tmp, 4);
-        tmp = zeit->zDatum()->getTag();
-        foreground->sende((char*)&tmp, 4);
-        tmp = (zeit->zUhrzeit()->getStunde() * 60
-                  + zeit->zUhrzeit()->getMinute())
+        foreground->send((char*)&len, 2);
+        foreground->send(path, len);
+        File resFile(path);
+        Time* Time = resFile.getLastChange();
+        int tmp = Time->zDate()->getJahr();
+        foreground->send((char*)&tmp, 4);
+        tmp = Time->zDate()->getMonat();
+        foreground->send((char*)&tmp, 4);
+        tmp = Time->zDate()->getTag();
+        foreground->send((char*)&tmp, 4);
+        tmp = (Time->zClock()->getStunde() * 60 + Time->zClock()->getMinute())
                 * 60
-            + zeit->zUhrzeit()->getSekunde();
-        foreground->sende((char*)&tmp, 4);
+            + Time->zClock()->getSekunde();
+        foreground->send((char*)&tmp, 4);
         bool needed = 0;
-        foreground->getNachricht((char*)&needed, 1);
+        foreground->getMessage((char*)&needed, 1);
         if (needed)
         {
             __int64 size = resFile.getSize();
-            foreground->sende((char*)&size, 8);
+            foreground->send((char*)&size, 8);
             filesToTransfer.add(new Text(path));
         }
-        zeit->release();
+        Time->release();
     }
 }
 
 // nicht constant
-void FCKlient::setForegroundClient(SKlient* foreground)
+void FCKlient::setForegroundClient(SClient* foreground)
 {
     Framework::Logging::trace() << "foreground client connected";
     this->foreground = foreground;
@@ -315,7 +314,7 @@ void FCKlient::setForegroundClient(SKlient* foreground)
     });
 }
 
-void FCKlient::setBackgroundClient(SKlient* background)
+void FCKlient::setBackgroundClient(SClient* background)
 {
     Framework::Logging::trace() << "background client connected";
     this->background = background;
@@ -353,10 +352,10 @@ void FCKlient::setBackgroundClient(SKlient* background)
 
 void FCKlient::absturz()
 {
-    klient->trenne();
-    if (background) background->trenne();
-    if (foreground) foreground->trenne();
-    warteAufThread(10000);
+    klient->disconnect();
+    if (background) background->disconnect();
+    if (foreground) foreground->disconnect();
+    waitForThread(10000);
     ende();
 }
 
@@ -366,7 +365,7 @@ void FCKlient::thread()
     while (1)
     {
         char c = 0;
-        if (!klient->getNachricht(&c, 1))
+        if (!klient->getMessage(&c, 1))
             break;
         else
         {
@@ -376,18 +375,18 @@ void FCKlient::thread()
             case 1: // Klient identifikation
                 {
                     char len;
-                    klient->getNachricht(&len, 1);
+                    klient->getMessage(&len, 1);
                     char* name = new char[len + 1];
-                    klient->getNachricht(name, len);
+                    klient->getMessage(name, len);
                     name[(int)len] = 0;
                     unsigned short sLen;
-                    klient->getNachricht((char*)&sLen, 2);
+                    klient->getMessage((char*)&sLen, 2);
                     char* secret = new char[sLen + 1];
-                    klient->getNachricht(secret, sLen);
+                    klient->getMessage(secret, sLen);
                     secret[sLen] = 0;
                     if (!Game::INSTANCE->checkPlayer(name, secret))
                     {
-                        klient->sende("\0", 1);
+                        klient->send("\0", 1);
                         delete[] name;
                         delete[] secret;
                         break;
@@ -395,53 +394,53 @@ void FCKlient::thread()
                     if (!Game::INSTANCE->existsPlayer(name))
                     {
                         Text secret = Game::INSTANCE->createPlayer(name);
-                        klient->sende("\2", 1);
+                        klient->send("\2", 1);
                         short len = (short)secret.getLength();
-                        klient->sende((char*)&len, 2);
-                        klient->sende(secret.getText(), len);
+                        klient->send((char*)&len, 2);
+                        klient->send(secret.getText(), len);
                         identified = 1;
                     }
                     else
                     {
-                        klient->sende("\1", 1);
+                        klient->send("\1", 1);
                         identified = 1;
                     }
                     short keyLen = (short)authKey.getLength();
-                    klient->sende((char*)&keyLen, 2);
-                    klient->sende(authKey, keyLen);
+                    klient->send((char*)&keyLen, 2);
+                    klient->send(authKey, keyLen);
                     this->name = name;
                     delete[] name;
                     delete[] secret;
                     break;
                 }
-            case 2: // Verbindungsende
+            case 2: // Verbindungsend
                 br = 1;
                 if (zGameClient)
                 {
                     zGameClient->logout();
                     zGameClient = (GameClient*)zGameClient->release();
                 }
-                klient->sende("\1", 1);
+                klient->send("\1", 1);
                 break;
             case 3: // ping
-                klient->sende("\1", 1);
+                klient->send("\1", 1);
                 break;
             case 4: // check player name valid
                 {
-                    klient->sende("\1", 1);
+                    klient->send("\1", 1);
                     char len;
-                    klient->getNachricht(&len, 1);
+                    klient->getMessage(&len, 1);
                     char* name = new char[len + 1];
-                    klient->getNachricht(name, len);
+                    klient->getMessage(name, len);
                     name[(int)len] = 0;
                     short sLen;
-                    klient->getNachricht((char*)&sLen, 2);
+                    klient->getMessage((char*)&sLen, 2);
                     char* secret = new char[sLen + 1];
-                    klient->getNachricht(secret, sLen);
+                    klient->getMessage(secret, sLen);
                     secret[sLen] = 0;
                     char res = 0;
                     if (Game::INSTANCE->checkPlayer(name, secret)) res = 1;
-                    klient->sende(&res, 1);
+                    klient->send(&res, 1);
                     delete[] name;
                     delete[] secret;
                     break;

FactoryCraft/Server.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#include <InitDatei.h>
+#include <InitFile.h>
 #ifdef _WINDOWS
 #    include <Network\Server.h>
 #else
@@ -21,7 +21,7 @@ class FactoryCraftServer : virtual public ReferenceCounter
 private:
     SSLServer* sslServer;
     Server* server;
-    InitDatei* ini;
+    InitFile* ini;
     Critical cs;
     RCArray<FCKlient>* klients;
     int runningThreads;
@@ -29,7 +29,7 @@ private:
 
 public:
     // Konstruktor
-    FactoryCraftServer(InitDatei* zIni);
+    FactoryCraftServer(InitFile* zIni);
     // Destruktor
     virtual ~FactoryCraftServer();
     // nicht constant
@@ -43,9 +43,9 @@ public:
 class FCKlient : public Thread
 {
 private:
-    Network::SSLSKlient* klient;
-    Network::SKlient* background;
-    Network::SKlient* foreground;
+    Network::SSLSClient* klient;
+    Network::SClient* background;
+    Network::SClient* foreground;
     FactoryCraftServer* ls;
     GameClient* zGameClient;
     NetworkReader* backgroundReader;
@@ -60,7 +60,7 @@ private:
 
 public:
     // Konstruktor
-    FCKlient(Network::SSLSKlient* klient, FactoryCraftServer* ls);
+    FCKlient(Network::SSLSClient* klient, FactoryCraftServer* ls);
     // Destruktor
     virtual ~FCKlient();
 
@@ -69,8 +69,8 @@ private:
     void checkResources(const char* path, RCArray<Text>& filesToTransfer);
 
 public:
-    void setForegroundClient(Network::SKlient* foreground);
-    void setBackgroundClient(Network::SKlient* background);
+    void setForegroundClient(Network::SClient* foreground);
+    void setBackgroundClient(Network::SClient* background);
     // nicht constant
     void absturz();
     void thread();

FactoryCraft/Start.cpp

@@ -1,6 +1,6 @@
 #include <csignal>
 #include <cstdlib>
-#include <Datei.h>
+#include <File.h>
 #include <Globals.h>
 #include <iostream>
 #ifndef _WINDOWS
@@ -12,7 +12,7 @@
 #include <Console.h>
 #include <Logging.h>
 #include <Text.h>
-#include <Zeit.h>
+#include <Timer.h>
 
 #include "Server.h"
 #include "WorldGenerator.h"
@@ -115,13 +115,13 @@ int main()
     setrlimit(RLIMIT_CORE, &core_limits);
 
 #endif
-    Zeit* z = getZeit();
+    Time* z = getTime();
     Text* pfad = new Text("log/");
-    Text* tmp = z->getZeit("y-m-d_h-i-s.log");
+    Text* tmp = z->getTime("y-m-d_h-i-s.log");
     pfad->append(*tmp);
     tmp->release();
     z->release();
-    Datei* logFile = new Datei(pfad);
+    File* logFile = new File(pfad);
     Logging::LoggingChannel* fileLogger
         = new Logging::FileLoggingChannel(logFile);
     fileLogger->setFormat(Logging::LoggingFormatBuilder()
@@ -135,7 +135,7 @@ int main()
     Logging::zLoggingHandler()->removeLoggingChannel(
         Logging::LogLevel::Warning, fileLogger);
     Logging::LoggingChannel* errorFileLogger = new Logging::FileLoggingChannel(
-        dynamic_cast<Datei*>(logFile->getThis()));
+        dynamic_cast<File*>(logFile->getThis()));
     errorFileLogger->setFormat(Logging::LoggingFormatBuilder()
             .datetime("h:i:s")
             .level()
@@ -194,10 +194,10 @@ int main()
     Logging::info() << "Starting ...";
     Logging::info() << "Loading config file fcInit.ini ...";
 
-    InitDatei* dat = new InitDatei("fcInit.ini");
-    if (!dat->laden())
+    InitFile* dat = new InitFile("fcInit.ini");
+    if (!dat->load())
     {
-        Logging::error() << "Datei konnte nicht gelesen werden. Das Programm "
+        Logging::error() << "File konnte nicht gelesen werden. Das Programm "
                             "wird geschlossen.";
         dat->release();
         Game::consoleHandler->release();
@@ -208,7 +208,7 @@ int main()
         = {"SSLPort", "SSLCert", "SSLKey", "SSLPasswort", "Port"};
     for (const char* w : wichtig)
     {
-        if (!dat->wertExistiert(w))
+        if (!dat->valueExists(w))
         {
             Logging::error()
                 << "The value '" << w
@@ -238,7 +238,7 @@ int main()
     {
         Game* tmp = Game::INSTANCE;
         tmp->requestStop();
-        tmp->warteAufThread(100000000);
+        tmp->waitForThread(100000000);
         tmp->release();
         Game::INSTANCE = 0;
     }

FactoryCraft/StructureCollection.cpp

@@ -122,7 +122,7 @@ StructureTemplateCollection::zStructureNoiseConfig() const
 void StructureTemplateCollection::addStructure(GeneratorTemplate* structure)
 {
     structures.add(structure);
-    if (structures.getEintragAnzahl() == 1)
+    if (structures.getEntryCount() == 1)
     {
         minAffected = structure->getMinAffectedOffset();
         maxAffected = structure->getMaxAffectedOffset();

FactoryCraft/TickOrganizer.cpp

@@ -60,7 +60,7 @@ void TickOrganizer::exitAndWait()
     queue->requestExit();
     for (int i = 0; i < workerCount; i++)
     {
-        workers[i]->warteAufThread(1000000);
+        workers[i]->waitForThread(1000000);
         workers[i]->ende();
         workers[i]->release();
     }

FactoryCraft/TickQueue.cpp

@@ -22,7 +22,7 @@ void TickQueue::startNextTick(Framework::Array<Tickable*>* zSources)
     std::unique_lock<std::mutex> lk(mutex);
     readPosition = 0;
     writePosition = 0;
-    int count = zSources->getEintragAnzahl();
+    int count = zSources->getEntryCount();
     if (count >= maxSize)
     {
         Tickable** temp = new Tickable*[count + 1000];

FactoryCraft/TreeSeblingBlock.cpp

@@ -200,12 +200,12 @@ void TreeSeblingBlockType::loadSuperBlock(
     Block* zBlock, Framework::StreamReader* zReader, int dimensionId) const
 {
     TreeSeblingBlock* block = dynamic_cast<TreeSeblingBlock*>(zBlock);
-    zReader->lese((char*)&block->seblingTicks, 4);
-    zReader->lese((char*)&block->seblingTicksMax, 4);
+    zReader->read((char*)&block->seblingTicks, 4);
+    zReader->read((char*)&block->seblingTicksMax, 4);
     int id;
-    zReader->lese((char*)&id, 4);
+    zReader->read((char*)&id, 4);
     block->wood = Game::INSTANCE->zBlockType(id);
-    zReader->lese((char*)&id, 4);
+    zReader->read((char*)&id, 4);
     block->leaves = Game::INSTANCE->zBlockType(id);
     BlockType::loadSuperBlock(zBlock, zReader, dimensionId);
 }
@@ -214,12 +214,12 @@ void TreeSeblingBlockType::saveSuperBlock(
     Block* zBlock, Framework::StreamWriter* zWriter) const
 {
     TreeSeblingBlock* block = dynamic_cast<TreeSeblingBlock*>(zBlock);
-    zWriter->schreibe((char*)&block->seblingTicks, 4);
-    zWriter->schreibe((char*)&block->seblingTicksMax, 4);
+    zWriter->write((char*)&block->seblingTicks, 4);
+    zWriter->write((char*)&block->seblingTicksMax, 4);
     int id = block->wood->getId();
-    zWriter->schreibe((char*)&id, 4);
+    zWriter->write((char*)&id, 4);
     id = block->leaves->getId();
-    zWriter->schreibe((char*)&id, 4);
+    zWriter->write((char*)&id, 4);
     BlockType::saveSuperBlock(zBlock, zWriter);
 }
 

FactoryCraft/TypeRegistry.cpp

@@ -1,6 +1,6 @@
 #include "TypeRegistry.h"
 
-#include <Datei.h>
+#include <File.h>
 
 #include "Animal.h"
 #include "BasicBlocks.h"
@@ -191,12 +191,12 @@ void TypeRegistry::writeSyntaxInfo(Framework::Text folderPath) const
             = parsableTypes.z(typeId->getText(), typeId->getLength());
         Framework::Validator::DataValidator* validator
             = factory->getValidator();
-        Framework::Datei syntaxFile(
+        Framework::File syntaxFile(
             new Framework::Text(folderPath + "/" + *typeId + ".xml"));
-        syntaxFile.erstellen();
+        syntaxFile.create();
         Framework::Text syntaxContent = validator->zConstraints()->toString();
-        syntaxFile.open(Framework::Datei::Style::schreiben);
-        syntaxFile.schreibe(syntaxContent, syntaxContent.getLength());
+        syntaxFile.open(Framework::File::Style::write);
+        syntaxFile.write(syntaxContent, syntaxContent.getLength());
         syntaxFile.close();
         validator->release();
     }

FactoryCraft/TypeRegistry.h

@@ -185,7 +185,7 @@ public:
     {
         for (SubTypeFactoryRef<T>* factory : factories)
         {
-            if (zJson->zValue("type")->asString()->getString().istGleich(
+            if (zJson->zValue("type")->asString()->getString().isEqual(
                     factory->getTypeToken()))
             {
                 return factory->fromJson(zJson);
@@ -203,7 +203,7 @@ public:
         auto name = typeNames.begin();
         for (SubTypeFactoryRef<T>* factory : factories)
         {
-            if (name->istGleich(typeid(*zObject).name()))
+            if (name->isEqual(typeid(*zObject).name()))
             {
                 Framework::JSON::JSONObject* result
                     = factory->toJson(zObject)->asObject();

FactoryCraft/UIController.cpp

@@ -23,12 +23,12 @@ void UIController::api(Framework::StreamReader* zRequest,
     Entity* zSource)
 {
     unsigned short length;
-    zRequest->lese((char*)&length, 2);
+    zRequest->read((char*)&length, 2);
     char* id = new char[length + 1];
-    zRequest->lese(id, length);
+    zRequest->read(id, length);
     id[length] = 0;
     char type;
-    zRequest->lese(&type, 1);
+    zRequest->read(&type, 1);
     switch (type)
     {
     case 0: // element message
@@ -36,7 +36,7 @@ void UIController::api(Framework::StreamReader* zRequest,
             int entityId = zSource->getId();
             for (auto dialog = activeDialogs.begin(); dialog; dialog++)
             {
-                if (dialog->getId().istGleich(id)
+                if (dialog->getId().isEqual(id)
                     && dialog->getPlayerId() == entityId)
                 {
                     dialog->api(zRequest, zResponse);
@@ -49,7 +49,7 @@ void UIController::api(Framework::StreamReader* zRequest,
             int entityId = zSource->getId();
             for (auto dialog = activeDialogs.begin(); dialog;)
             {
-                if (dialog->getId().istGleich(id)
+                if (dialog->getId().isEqual(id)
                     && dialog->getPlayerId() == entityId)
                 {
                     dialog.remove();

FactoryCraft/UIElement.cpp

@@ -135,19 +135,19 @@ Framework::XML::Element* UIElement::toUIML(
 {
     Framework::XML::Element* result = new Framework::XML::Element();
     result->setAttribute("id", id);
-    if (!marginLeft.istGleich("0"))
+    if (!marginLeft.isEqual("0"))
     {
         result->setAttribute("margin-left", marginLeft);
     }
-    if (!marginRight.istGleich("0"))
+    if (!marginRight.isEqual("0"))
     {
         result->setAttribute("margin-right", marginRight);
     }
-    if (!marginTop.istGleich("0"))
+    if (!marginTop.isEqual("0"))
     {
         result->setAttribute("margin-top", marginTop);
     }
-    if (!marginBottom.istGleich("0"))
+    if (!marginBottom.isEqual("0"))
     {
         result->setAttribute("margin-bottom", marginBottom);
     }

FactoryCraft/UIObservable.cpp

@@ -36,7 +36,7 @@ void UIObservable::removeObserver(
     for (auto observer : observers)
     {
         if (observer.sourceEntiryId == zSource->getId()
-            && observer.uimlElementId.istGleich(uimlElementId)
+            && observer.uimlElementId.isEqual(uimlElementId)
             && observer.networkApiProcessorId == networkApiProcessorId)
         {
             observers.remove(index);
@@ -54,7 +54,7 @@ void UIObservable::addObserver(
     for (auto observer : observers)
     {
         if (observer.sourceEntiryId == zSource->getId()
-            && observer.uimlElementId.istGleich(uimlElementId)
+            && observer.uimlElementId.isEqual(uimlElementId)
             && observer.networkApiProcessorId == networkApiProcessorId)
         {
             cs.unlock();

FactoryCraft/WorldGenerator.cpp

@@ -1,6 +1,6 @@
 #include "WorldGenerator.h"
 
-#include <Datei.h>
+#include <File.h>
 #include <functional>
 #include <Logging.h>
 
@@ -54,11 +54,11 @@ WorldGenerator::WorldGenerator(int seed)
             }
         });
     Framework::JSON::JSONObject* schema = configValidator->getJsonSchema();
-    Framework::Datei syntaxFile;
-    syntaxFile.setDatei("data/syntax/schema/generator.json");
-    syntaxFile.erstellen();
-    syntaxFile.open(Framework::Datei::Style::schreiben);
-    syntaxFile.schreibe(schema->toString(), schema->toString().getLength());
+    Framework::File syntaxFile;
+    syntaxFile.setFile("data/syntax/schema/generator.json");
+    syntaxFile.create();
+    syntaxFile.open(Framework::File::Style::write);
+    syntaxFile.write(schema->toString(), schema->toString().getLength());
     syntaxFile.close();
     schema->release();
     configValidator->release();
@@ -98,7 +98,7 @@ void WorldGenerator::thread()
         cs.lock();
         Area next;
         bool hasNext = 0;
-        if (requestQueue.getEintragAnzahl() > 0)
+        if (requestQueue.getEntryCount() > 0)
         {
             next = requestQueue.get(0);
             requestQueue.remove(0);
@@ -121,8 +121,8 @@ void WorldGenerator::thread()
             dim = new Dimension(next.dimensionId);
             Game::INSTANCE->addDimension(dim);
         }
-        Punkt start = Game::INSTANCE->getChunkCenter(next.startX, next.startY);
-        Punkt end = Game::INSTANCE->getChunkCenter(next.endX, next.endY);
+        Point start = Game::INSTANCE->getChunkCenter(next.startX, next.startY);
+        Point end = Game::INSTANCE->getChunkCenter(next.endX, next.endY);
         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;
@@ -133,37 +133,37 @@ void WorldGenerator::thread()
             {
                 if (!Game::INSTANCE->doesChunkExist(x, y, next.dimensionId))
                 {
-                    ZeitMesser zm;
-                    zm.messungStart();
+                    Timer zm;
+                    zm.measureStart();
                     Chunk* generatedChunk
                         = zGenerator(next.dimensionId)->generateChunk(x, y);
 #ifdef CHUNK_GENERATION_DEBUG_LOG
-                    zm.messungEnde();
+                    zm.measureEnd();
                     Framework::Logging::trace()
                         << "block generation time: " << zm.getSekunden();
                     completeTime += zm.getSekunden();
-                    zm.messungStart();
+                    zm.measureStart();
 #endif
                     generatedChunk->initializeLightning();
 #ifdef CHUNK_GENERATION_DEBUG_LOG
-                    zm.messungEnde();
+                    zm.measureEnd();
                     Framework::Logging::trace()
                         << "light calculation: " << zm.getSekunden();
                     completeTime += zm.getSekunden();
-                    zm.messungStart();
+                    zm.measureStart();
 #endif
                     generatedChunk->removeUnusedBlocks();
 #ifdef CHUNK_GENERATION_DEBUG_LOG
-                    zm.messungEnde();
+                    zm.measureEnd();
                     Framework::Logging::trace()
                         << "unused block removal: " << zm.getSekunden();
                     completeTime += zm.getSekunden();
-                    zm.messungStart();
+                    zm.measureStart();
 #endif
                     generatedChunk->getThis();
-                    dim->setChunk(generatedChunk, Punkt(x, y));
+                    dim->setChunk(generatedChunk, Point(x, y));
                     generatedChunk->release();
-                    zm.messungEnde();
+                    zm.measureEnd();
 #ifdef CHUNK_GENERATION_DEBUG_LOG
                     Framework::Logging::trace()
                         << "adding chunk to map: " << zm.getSekunden();
@@ -188,7 +188,7 @@ void WorldGenerator::requestGeneration(Area request)
 void WorldGenerator::exitAndWait()
 {
     exit = 1;
-    warteAufThread(10000);
+    waitForThread(10000);
     ende();
 }
 

FactoryCraft/WorldLoader.cpp

@@ -1,8 +1,8 @@
 #include "WorldLoader.h"
 
-#include <Datei.h>
+#include <File.h>
 #include <Logging.h>
-#include <Punkt.h>
+#include <Point.h>
 #include <Text.h>
 
 #include "Dimension.h"
@@ -17,26 +17,26 @@ WorldLoader::WorldLoader()
       exit(0)
 {
     setName("World Loader");
-    Framework::Datei d;
-    d.setDatei(Game::INSTANCE->getWorldDirectory() + "/dim");
-    RCArray<Text>* names = d.getDateiListe();
+    Framework::File d;
+    d.setFile(Game::INSTANCE->getWorldDirectory() + "/dim");
+    RCArray<Text>* names = d.getFileList();
     if (names)
     {
         for (Text* name : *names)
         {
-            Framework::Datei entities;
-            entities.setDatei(Game::INSTANCE->getWorldDirectory() + "/dim/"
+            Framework::File entities;
+            entities.setFile(Game::INSTANCE->getWorldDirectory() + "/dim/"
                               + Text(name->getText()) + "/entities");
-            if (entities.open(Framework::Datei::Style::lesen))
+            if (entities.open(Framework::File::Style::read))
             {
                 Dimension* dim
                     = Game::INSTANCE->zGenerator()->createDimension((int)*name);
                 if (dim)
                 {
-                    while (!entities.istEnde())
+                    while (!entities.isEnd())
                     {
                         int type = 0;
-                        entities.lese((char*)&type, 4);
+                        entities.read((char*)&type, 4);
                         dim->addEntity(
                             Game::INSTANCE->zEntityType(type)->loadEntity(
                                 &entities));
@@ -65,7 +65,7 @@ void WorldLoader::thread()
         cs.lock();
         Area next;
         bool hasNext = 0;
-        if (requestQueue.getEintragAnzahl() > 0)
+        if (requestQueue.getEntryCount() > 0)
         {
             next = requestQueue.get(0);
             requestQueue.remove(0);
@@ -77,8 +77,8 @@ void WorldLoader::thread()
             Sleep(1000);
             continue;
         }
-        Punkt start = Game::INSTANCE->getChunkCenter(next.startX, next.startY);
-        Punkt end = Game::INSTANCE->getChunkCenter(next.endX, next.endY);
+        Point start = Game::INSTANCE->getChunkCenter(next.startX, next.startY);
+        Point end = Game::INSTANCE->getChunkCenter(next.endX, next.endY);
         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;
@@ -89,25 +89,25 @@ void WorldLoader::thread()
             {
                 Dimension* zDim = Game::INSTANCE->zDimension(next.dimensionId);
                 bool revived = 0;
-                if (!zDim->zChunk(Punkt(x, y)) && zDim->hasChunck(x, y))
+                if (!zDim->zChunk(Point(x, y)) && zDim->hasChunck(x, y))
                 {
                     revived = zDim->reviveChunk(x, y);
                 }
                 if (!revived
                     && !Game::INSTANCE->isChunkLoaded(x, y, next.dimensionId))
                 {
-                    Datei* file = new Datei();
+                    File* file = new File();
                     Text filePath = Game::INSTANCE->getWorldDirectory()
                                   + "/dim/" + next.dimensionId + "/";
                     filePath.appendHex(x);
                     filePath += "_";
                     filePath.appendHex(y);
                     filePath += ".chunk";
-                    file->setDatei(filePath);
-                    if (file->open(Datei::Style::lesen))
+                    file->setFile(filePath);
+                    if (file->open(File::Style::read))
                     {
                         Chunk* chunk = new Chunk(
-                            Framework::Punkt(x, y), next.dimensionId, file);
+                            Framework::Point(x, y), next.dimensionId, file);
                         Dimension* dim
                             = Game::INSTANCE->zDimension(next.dimensionId);
                         if (!dim)
@@ -115,7 +115,7 @@ void WorldLoader::thread()
                             dim = new Dimension(next.dimensionId);
                             Game::INSTANCE->addDimension(dim);
                         }
-                        dim->setChunk(chunk, Punkt(x, y));
+                        dim->setChunk(chunk, Point(x, y));
                     }
                     file->close();
                     file->release();
@@ -136,7 +136,7 @@ void WorldLoader::requestLoading(Area request)
 void WorldLoader::exitAndWait()
 {
     exit = 1;
-    warteAufThread(10000);
+    waitForThread(10000);
     ende();
 }
 
@@ -148,5 +148,5 @@ bool WorldLoader::existsChunk(int x, int y, int dimension) const
     filePath += "_";
     filePath.appendHex(y);
     filePath += ".chunk";
-    return DateiExistiert(filePath);
+    return FileExists(filePath);
 }

FactoryCraft/WormCaveGenerator.cpp

@@ -30,13 +30,13 @@ NoiseWorm3D::NoiseWorm3D(Noise* pitch,
     maxAffected.x = (int)lastPos.x + minRad;
     maxAffected.y = (int)lastPos.y + minRad;
     maxAffected.z = (int)lastPos.z + minRad;
-    while (tmpSizeList.getEintragAnzahl() < distant * 20)
+    while (tmpSizeList.getEntryCount() < distant * 20)
     {
         Framework::Vec3<float> defaultDir(1.f, 0.f, 0.f);
-        if (tmpPointList.getEintragAnzahl() > 1)
+        if (tmpPointList.getEntryCount() > 1)
         {
-            defaultDir = tmpPointList.get(tmpPointList.getEintragAnzahl() - 1)
-                       - tmpPointList.get(tmpPointList.getEintragAnzahl() - 2);
+            defaultDir = tmpPointList.get(tmpPointList.getEntryCount() - 1)
+                       - tmpPointList.get(tmpPointList.getEntryCount() - 2);
         }
         float n = (float)yaw->getNoise(lastPos.x, lastPos.y, lastPos.z);
         defaultDir.rotateZ((n - 0.5f) / 2.f);
@@ -62,8 +62,8 @@ NoiseWorm3D::NoiseWorm3D(Noise* pitch,
         maxAffected.y = MAX(maxAffected.y, (int)(lastPos.y + rad));
         maxAffected.z = MAX(maxAffected.z, (int)(lastPos.z + rad));
     }
-    keyPoints = new float[3 * tmpPointList.getEintragAnzahl()];
-    keyPointSize = new float[tmpPointList.getEintragAnzahl()];
+    keyPoints = new float[3 * tmpPointList.getEntryCount()];
+    keyPointSize = new float[tmpPointList.getEntryCount()];
     float* keyPointsP = keyPoints;
     float* keyPointSizeP = keyPointSize;
     auto pi = tmpPointList.begin();
@@ -85,7 +85,7 @@ NoiseWorm3D::~NoiseWorm3D()
     delete[] keyPointSize;
 }
 
-const Framework::Punkt& NoiseWorm3D::getStartChunkCenter()
+const Framework::Point& NoiseWorm3D::getStartChunkCenter()
 {
     return startChunk;
 }
@@ -149,9 +149,9 @@ void NoiseWorm3D::getPartAffectedByChunk(
                     if (result != 0)
                     {
                         result->keyPoints
-                            = new float[tmpPointList.getEintragAnzahl() * 3];
+                            = new float[tmpPointList.getEntryCount() * 3];
                         result->keyPointSize
-                            = new float[tmpPointList.getEintragAnzahl()];
+                            = new float[tmpPointList.getEntryCount()];
                         float* rkeyPointsP = result->keyPoints;
                         float* rkeyPointSizeP = result->keyPointSize;
                         auto rpi = tmpPointList.begin();
@@ -165,8 +165,8 @@ void NoiseWorm3D::getPartAffectedByChunk(
                             ++rpi;
                             ++rsi;
                         }
-                        tmpPointList.leeren();
-                        tmpSizeList.leeren();
+                        tmpPointList.clear();
+                        tmpSizeList.clear();
                         zResult->add(result);
                         result = 0;
                     }
@@ -179,8 +179,8 @@ void NoiseWorm3D::getPartAffectedByChunk(
     }
     if (result)
     {
-        result->keyPoints = new float[tmpPointList.getEintragAnzahl() * 3];
-        result->keyPointSize = new float[tmpPointList.getEintragAnzahl()];
+        result->keyPoints = new float[tmpPointList.getEntryCount() * 3];
+        result->keyPointSize = new float[tmpPointList.getEntryCount()];
         float* rkeyPointsP = result->keyPoints;
         float* rkeyPointSizeP = result->keyPointSize;
         auto rpi = tmpPointList.begin();
@@ -208,7 +208,7 @@ bool NoiseWorm3D::isInside(int x, int y, int z)
         while (pi && si)
         {
             if (Framework::Vec3<float>((float)x, (float)y, (float)z)
-                    .abstandSq({*pi, *(pi + 1), *(pi + 2)})
+                    .distanceSq({*pi, *(pi + 1), *(pi + 2)})
                 < *si * *si)
                 return 1;
             pi += 3;
@@ -297,7 +297,7 @@ NoiseWorm3D* WormCaveGenerator::zWormOfChunk(int x, int y)
                   + minDistant),
             minRadius,
             maxRadius);
-        if (cache.getEintragAnzahl()
+        if (cache.getEntryCount()
             > (maxDistant * 2) / CHUNK_SIZE * (maxDistant * 2) / CHUNK_SIZE * 3)
             cache.remove(0);
         cache.add(worm);
@@ -309,7 +309,7 @@ NoiseWorm3D* WormCaveGenerator::zWormOfChunk(int x, int y)
 CaveChunkGenerator* WormCaveGenerator::getGeneratorForChunk(int x, int y)
 {
     Framework::RCArray<NoiseWorm3D> affected;
-    Framework::Punkt center = Game::getChunkCenter(x, y);
+    Framework::Point center = Game::getChunkCenter(x, y);
     int offset = (int)ceil((float)maxDistant / CHUNK_SIZE);
     for (int cx = -offset; cx <= offset; cx++)
     {

FactoryCraft/WormCaveGenerator.h

@@ -1,7 +1,7 @@
 #pragma once
 
 #include <Array.h>
-#include <Punkt.h>
+#include <Point.h>
 #include <Vec3.h>
 
 #include "CaveGenerator.h"
@@ -10,7 +10,7 @@
 class NoiseWorm3D : public Framework::ReferenceCounter
 {
 private:
-    Framework::Punkt startChunk;
+    Framework::Point startChunk;
     Framework::Vec3<int> minAffected;
     Framework::Vec3<int> maxAffected;
 
@@ -28,7 +28,7 @@ public:
         int minRad,
         int maxRad);
     ~NoiseWorm3D();
-    const Framework::Punkt& getStartChunkCenter();
+    const Framework::Point& getStartChunkCenter();
     void getPartAffectedByChunk(
         int x, int y, Framework::RCArray<NoiseWorm3D>* zResult);
     bool isInside(int x, int y, int z);

NoiseTest/NoiseTest.cpp

@@ -1,7 +1,7 @@
 #include <AsynchronCall.h>
-#include <Bild.h>
-#include <Bildschirm.h>
-#include <Fenster.h>
+#include <Image.h>
+#include <Screen.h>
+#include <Window.h>
 #include <Globals.h>
 #include <iostream>
 #include <RenderThread.h>
@@ -17,8 +17,8 @@
 
 using namespace Framework;
 
-WFenster* window;
-Bild* img;
+NativeWindow* window;
+Image* img;
 Vec3<int> position(0, 0, 0);
 float zoom = 1;
 bool exitF = 0;
@@ -45,24 +45,24 @@ class C : public B
 void updateView()
 {
     Vec3<int> minP = position
-                   - (Vec3<int>)(Vec3<float>((float)img->getBreite() / 2.f,
+                   - (Vec3<int>)(Vec3<float>((float)img->getWidth() / 2.f,
                                      (float)img->getHeight() / 2.f,
                                      0.f)
                                  / zoom);
     Vec3<int> maxP = position
-                   + (Vec3<int>)(Vec3<float>((float)img->getBreite() / 2.f,
+                   + (Vec3<int>)(Vec3<float>((float)img->getWidth() / 2.f,
                                      (float)img->getHeight() / 2.f,
                                      0.f)
                                  / zoom);
     int counter = 0;
     double min = INFINITY;
     double max = -INFINITY;
-    for (int i = 0; i < img->getBreite(); i++)
+    for (int i = 0; i < img->getWidth(); i++)
     {
         for (int j = 0; j < img->getHeight(); j++)
         {
             Vec3<float> pos((float)i, (float)j, 0.f);
-            pos -= Vec3<int>(img->getBreite() / 2, img->getHeight() / 2, 0);
+            pos -= Vec3<int>(img->getWidth() / 2, img->getHeight() / 2, 0);
             pos /= zoom;
             pos += position;
             double noise = wrapper->getNoise(pos.x, pos.y, pos.z);
@@ -95,12 +95,12 @@ void updateView()
         }
     }
     float percentage
-        = ((float)counter / (img->getBreite() * img->getHeight())) * 100;
+        = ((float)counter / (img->getWidth() * img->getHeight())) * 100;
     std::cout << "Showing " << minP.x << " " << minP.y << " to " << maxP.x
               << " " << maxP.y << " at height " << position.z << " with border "
               << border2 << " to " << border << " true for " << percentage
               << "% of "
-              << (img->getBreite() / zoom) * (img->getHeight() / zoom)
+              << (img->getWidth() / zoom) * (img->getHeight() / zoom)
               << " blocks. Min: " << min << " Max: " << max << std::endl;
 }
 
@@ -179,7 +179,7 @@ int main()
     window->setSize(800, 800);
     window->setPosition(100, 100);
     window->setAnzeigeModus(SW_SHOW);
-    window->setVSchließAktion([](void* p, void* o) {
+    window->setVSchließAktion([](void* p, void* o) {
         StopNachrichtenSchleife(window->getFensterHandle());
     });