`receiving.cc`

9 files changed, 1869 insertions, 17 deletions

diff --git a/src/common.hh b/src/common.hh
index e0bfb81..8aef0fd 100644
--- a/src/common.hh
+++ b/src/common.hh
@@ -1,6 +1,7 @@
 #ifndef TIBIA_COMMON_HH_
 #define TIBIA_COMMON_HH_ 1
 
+#include <ctype.h>
 #include <float.h>
 #include <limits.h>
 #include <stddef.h>
diff --git a/src/communication.cc b/src/communication.cc
index 71a05d3..799cd42 100644
--- a/src/communication.cc
+++ b/src/communication.cc
@@ -920,7 +920,7 @@ bool HandleLogin(TConnection *Connection){
 	TReadBuffer InputBuffer(Connection->InData, Connection->InDataSize);
 	try{
 		uint8 Command = InputBuffer.readByte();
-		if(Command != 10){
+		if(Command != CL_CMD_LOGIN_REQUEST){
 			print(3, "Ungültiges Init-Kommando %d.\n", Command);
 			return false;
 		}
@@ -1104,7 +1104,7 @@ bool HandleLogin(TConnection *Connection){
 	TWriteBuffer WriteBuffer(Connection->InData + 2,
 					sizeof(Connection->InData) - 2);
 	try{
-		WriteBuffer.writeByte(11);
+		WriteBuffer.writeByte(CL_CMD_LOGIN);
 		WriteBuffer.writeWord((int)TerminalType);
 		WriteBuffer.writeWord((int)TerminalVersion);
 		WriteBuffer.writeQuad(Slot->CharacterID);
diff --git a/src/connections.hh b/src/connections.hh
index 17cf7df..d4f0755 100644
--- a/src/connections.hh
+++ b/src/connections.hh
@@ -10,11 +10,11 @@ struct TConnection;
 struct TPlayer;
 
 enum ClientCommand: int {
-	CL_CMD_LOGIN					= 10,
-	CL_CMD_LOGIN_TREATED			= 11,
+	CL_CMD_LOGIN_REQUEST			= 10,
+	CL_CMD_LOGIN					= 11,
 	CL_CMD_LOGOUT					= 20,
 	CL_CMD_PING						= 30,
-	CL_CMD_GO						= 100,
+	CL_CMD_GO_PATH					= 100,
 	CL_CMD_GO_NORTH					= 101,
 	CL_CMD_GO_EAST					= 102,
 	CL_CMD_GO_SOUTH					= 103,
@@ -121,7 +121,7 @@ enum ServerCommand: int {
 	SV_CMD_CHANNELS					= 171,
 	SV_CMD_OPEN_CHANNEL				= 172,
 	SV_CMD_PRIVATE_CHANNEL			= 173,
-	SV_CMD_OPEN_REQUEST				= 174,
+	SV_CMD_OPEN_REQUEST_QUEUE		= 174,
 	SV_CMD_DELETE_REQUEST			= 175,
 	SV_CMD_FINISH_REQUEST			= 176,
 	SV_CMD_CLOSE_REQUEST			= 177,
@@ -288,7 +288,7 @@ void SendTalk(TConnection *Connection, uint32 StatementID,
 void SendChannels(TConnection *Connection);
 void SendOpenChannel(TConnection *Connection, int Channel);
 void SendPrivateChannel(TConnection *Connection, const char *Name);
-void SendOpenRequest(TConnection *Connection);
+void SendOpenRequestQueue(TConnection *Connection);
 void SendDeleteRequest(TConnection *Connection, const char *Name);
 void SendFinishRequest(TConnection *Connection, const char *Name);
 void SendCloseRequest(TConnection *Connection);
@@ -300,11 +300,14 @@ void SendOutfit(TConnection *Connection);
 void SendBuddyData(TConnection *Connection, uint32 CharacterID, const char *Name, bool Online);
 void SendBuddyStatus(TConnection *Connection, uint32 CharacterID, bool Online);
 void BroadcastMessage(int Mode, const char *Text, ...) ATTR_PRINTF(2, 3);
+void CreateGamemasterRequest(const char *Name, const char *Text);
 void DeleteGamemasterRequest(const char *Name);
 void InitSending(void);
 void ExitSending(void);
 
 // receiving.cc
+void ReceiveData(TConnection *Connection);
+void ReceiveData(void);
 void InitReceiving(void);
 void ExitReceiving(void);
 
diff --git a/src/cr.hh b/src/cr.hh
index a971b3b..f36f7bf 100644
--- a/src/cr.hh
+++ b/src/cr.hh
@@ -18,6 +18,11 @@ struct TOutfit{
 		uint8 Colors[4];
 		uint32 PackedData;
 	};
+
+	constexpr bool operator==(const TOutfit &Other) const {
+		return this->OutfitID == Other.OutfitID
+			&& this->PackedData == Other.PackedData;
+	}
 };
 
 struct TSkillData {
diff --git a/src/info.cc b/src/info.cc
index 0461356..8f520cf 100644
--- a/src/info.cc
+++ b/src/info.cc
@@ -399,9 +399,7 @@ Object GetObject(uint32 CreatureID, int x, int y, int z, int RNum, ObjectType Ty
 			error("GetObject: Ungültiger ContainerCode x=%d,y=%d,z=%d,RNum=%d,Type=%d.\n",
 					x, y, z, RNum, Type.TypeID);
 		}
-	}else if(RNum == -1){
-		Obj = GetTopObject(x, y, z, false);
-	}else{
+	}else if(RNum != -1){
 		Obj = GetFirstObject(x, y, z);
 		while(Obj != NONE){
 			if(Obj.getObjectType().getDisguise() == Type){
@@ -409,6 +407,8 @@ Object GetObject(uint32 CreatureID, int x, int y, int z, int RNum, ObjectType Ty
 			}
 			Obj = Obj.getNextObject();
 		}
+	}else{
+		Obj = GetTopObject(x, y, z, false);
 	}
 
 	// NOTE(fusion): `Type` can be a map container (TypeID = 0) as a wildcard for
diff --git a/src/operate.cc b/src/operate.cc
index e019d36..6fb7f20 100644
--- a/src/operate.cc
+++ b/src/operate.cc
@@ -2634,8 +2634,8 @@ void EditText(uint32 CreatureID, Object Obj, const char *Text){
 
 	int TextLength = (int)strlen(Text);
 	int MaxLength = (ObjType.getFlag(WRITE)
-			? ObjType.getAttribute(MAXLENGTH)
-			: ObjType.getAttribute(MAXLENGTHONCE));
+			? (int)ObjType.getAttribute(MAXLENGTH)
+			: (int)ObjType.getAttribute(MAXLENGTHONCE));
 	if(TextLength >= MaxLength){
 		throw TOOLONG;
 	}
diff --git a/src/receiving.cc b/src/receiving.cc
new file mode 100644
index 0000000..1c6ee00
--- /dev/null
+++ b/src/receiving.cc
@@ -0,0 +1,1818 @@
+#include "connections.hh"
+#include "info.hh"
+
+#include "stubs.hh"
+
+#include <signal.h>
+
+bool CommandAllowed(TConnection *Connection, int Command){
+	if(Connection == NULL){
+		error("CommandAllowed: Connection ist NULL.\n");
+		return false;
+	}
+
+	if(Connection->State == CONNECTION_GAME){
+		return Command != CL_CMD_LOGIN_REQUEST
+			&& Command != CL_CMD_LOGIN;
+	}else if(Connection->State == CONNECTION_DEAD || Connection->State == CONNECTION_LOGOUT){
+		return Command == CL_CMD_LOGOUT
+			|| Command == CL_CMD_PING
+			|| Command == CL_CMD_BUG_REPORT
+			|| Command == CL_CMD_ERROR_FILE_ENTRY;
+	}else{
+		error("CommandAllowed: Ungültiger Verbindungsstatus %d bei Kommando %d.\n",
+				Connection->State, Command);
+		return false;
+	}
+}
+
+bool CheckSpecialCoordinates(int Command, int x, int y, int z, bool AllowInventoryAny){
+	if(x == 0xFFFF){ // SPECIAL_COORDINATE ?
+		if(y == INVENTORY_ANY){
+			return AllowInventoryAny;
+		}else if((y >= INVENTORY_FIRST && y <= INVENTORY_LAST)
+				|| (y >= CONTAINER_FIRST && y <= CONTAINER_LAST)){
+			return true;
+		}else{
+			print(3, "CheckSpecialCoordinates: Ungültige Koordinaten"
+					" [%d,%d,%d] bei Kommando %d.\n", x, y, z, Command);
+			return false;
+		}
+	}else{
+		return IsOnMap(x, y, z);
+	}
+}
+
+bool CheckVisibility(int Command, TConnection *Connection, int x, int y, int z){
+	if(Connection == NULL){
+		error("CheckVisibility: Connection ist NULL.\n");
+		return false;
+	}
+
+	bool Result = Connection->IsVisible(x, y, z);
+	if(!Result){
+		int PlayerX, PlayerY, PlayerZ;
+		Connection->GetPosition(&PlayerX, &PlayerY, &PlayerZ);
+		print(3, "CheckVisibility: Feld [%d,%d,%d] ist von [%d,%d,%d]"
+				" aus nicht sichtbar bei Kommando %d.\n",
+				x, y, z, PlayerX, PlayerY, PlayerZ, Command);
+	}
+	return Result;
+}
+
+bool CheckObjectType(int Command, int TypeID){
+	bool Result = ObjectTypeExists(TypeID);
+	if(!Result){
+		print(3, "CheckObjectType: Ungültiger Objekttyp %d bei Kommando %d.\n",
+				TypeID, Command);
+	}
+	return Result;
+}
+
+ObjectType GetObjectType(int Command, int TypeID){
+	// TODO(fusion): Isn't this already done by `ObjectType::setTypeID` ?
+	ObjectType ObjType(0);
+	if(CheckObjectType(Command, TypeID)){
+		ObjType.setTypeID(TypeID);
+	}
+	return ObjType;
+}
+
+void CQuitGame(TConnection *Connection, TReadBuffer *Buffer){
+	TPlayer *Player = Connection->GetPlayer();
+	if(Player == NULL){
+		Connection->Logout(0, true);
+		return;
+	}
+
+	switch(Player->LogoutPossible()){
+		case 0:{
+			Player->ToDoClear();
+			Connection->Logout(0, true);
+			break;
+		}
+
+		case 1:{
+			SendMessage(Connection, TALK_FAILURE_MESSAGE,
+					"You may not logout during or immediately after a fight!");
+			break;
+		}
+		case 2:{
+			SendMessage(Connection, TALK_FAILURE_MESSAGE,
+					"You may not logout here!");
+			break;
+		}
+
+		default:{
+			// TODO(fusion): The original function would also logout the player
+			// on this case which feels weird, specially when you can't have any
+			// other result from `LogoutPossible`.
+			error("CQuitGame: Ungültiger Rückgabewert von LogoutPossible.\n");
+			break;
+		}
+	}
+}
+
+void CPing(TConnection *Connection, TReadBuffer *Buffer){
+	// NOTE(fusion): Its a no-op because it's already encoded in `Connection::TimeStamp`.
+}
+
+void CGoPath(TConnection *Connection, TReadBuffer *Buffer){
+	// TODO(fusion): Sometimes we check, sometimes we don't. It should always be
+	// valid since these functions are all called from within `ReceiveData` which
+	// also checks it.
+	if(Connection == NULL){
+		error("CGoPath: Connection ist NULL.\n");
+		return;
+	}
+
+	TPlayer *Player = Connection->GetPlayer();
+	if(Player == NULL){
+		return;
+	}
+
+	if(Player->ToDoClear()){
+		SendSnapback(Connection);
+	}
+
+	int Steps = (int)Buffer->readByte();
+	TToDoEntry TD = {};
+	TD.Code = TDGo;
+	TD.Go.x = Player->posx;
+	TD.Go.y = Player->posy;
+	TD.Go.z = Player->posz;
+	try{
+		for(int i = 0; i < Steps; i += 1){
+			// NOTE(fusion): For whatever reason these directions are not the same
+			// we use internally.
+			switch(Buffer->readByte()){
+				case 1: TD.Go.x += 1;               break; // EAST
+				case 2: TD.Go.x += 1; TD.Go.y -= 1; break; // NORTHEAST
+				case 3:               TD.Go.y -= 1; break; // NORTH
+				case 4: TD.Go.x -= 1; TD.Go.y -= 1; break; // NORTHWEST
+				case 5: TD.Go.x -= 1;               break; // WEST
+				case 6: TD.Go.x -= 1; TD.Go.y += 1; break; // SOUTHWEST
+				case 7:               TD.Go.y += 1; break; // SOUTH
+				case 8: TD.Go.x += 1; TD.Go.y += 1; break; // SOUTHEAST
+				default:{
+					continue;
+				}
+			}
+
+			Player->ToDoAdd(TD);
+		}
+
+		Player->ToDoStart();
+	}catch(RESULT r){
+		SendResult(Connection, r);
+		Player->ToDoYield();
+	}
+}
+
+void CGoDirection(TConnection *Connection, int OffsetX, int OffsetY){
+	if(Connection == NULL){
+		error("CGoDirection: Connection ist NULL.\n");
+		return;
+	}
+
+	TPlayer *Player = Connection->GetPlayer();
+	if(Player == NULL){
+		return;
+	}
+
+	try{
+		if(Player->ToDoClear()){
+			SendSnapback(Connection);
+		}
+
+		TToDoEntry TD = {};
+		TD.Code = TDGo;
+		TD.Go.x = Player->posx + OffsetX;
+		TD.Go.y = Player->posy + OffsetY;
+		TD.Go.z = Player->posz;
+		Player->ToDoAdd(TD);
+		Player->ToDoStart();
+	}catch(RESULT r){
+		SendResult(Connection, r);
+		Player->ToDoYield();
+	}
+}
+
+void CGoStop(TConnection *Connection, TReadBuffer *Buffer){
+	if(Connection == NULL){
+		error("CGoStop: Connection ist NULL.\n");
+		return;
+	}
+
+	TPlayer *Player = Connection->GetPlayer();
+	if(Player != NULL){
+		Player->ToDoStop();
+	}
+}
+
+void CRotate(TConnection *Connection, int Direction){
+	if(Connection == NULL){
+		error("CRotate: Connection ist NULL.\n");
+		return;
+	}
+
+	TPlayer *Player = Connection->GetPlayer();
+	if(Player == NULL){
+		return;
+	}
+
+	try{
+		Player->ToDoRotate(Direction);
+		Player->ToDoStart();
+	}catch(RESULT r){
+		SendResult(Connection, r);
+		Player->ToDoYield();
+	}
+}
+
+void CMoveObject(TConnection *Connection, TReadBuffer *Buffer){
+	if(Connection == NULL){
+		error("CMoveObject: Connection ist NULL.\n");
+		return;
+	}
+
+	// TODO(fusion): I'm just following the convention being used. There is a
+	// comment in `ReceiveData` but the fact that there is only one command in
+	// a packet makes it unnecessary to "consume" all command's parameters.
+	TPlayer *Player = Connection->GetPlayer();
+	if(Player == NULL){
+		return;
+	}
+
+	int OrigX = Buffer->readWord();
+	int OrigY = Buffer->readWord();
+	int OrigZ = Buffer->readByte();
+	int TypeID = Buffer->readWord();
+	uint8 RNum = Buffer->readByte();
+	int DestX = Buffer->readWord();
+	int DestY = Buffer->readWord();
+	int DestZ = Buffer->readByte();
+	uint8 Count = Buffer->readByte();
+
+	ObjectType Type = GetObjectType(CL_CMD_MOVE_OBJECT, TypeID);
+	if(Type.isMapContainer() || (Type.getFlag(CUMULATIVE) && Count == 0)){
+		return;
+	}
+
+	if(!CheckSpecialCoordinates(CL_CMD_MOVE_OBJECT, OrigX, OrigY, OrigZ, false)
+	|| !CheckSpecialCoordinates(CL_CMD_MOVE_OBJECT, DestX, DestY, DestZ, true)){
+		return;
+	}
+
+	if((OrigX != 0xFFFF && !CheckVisibility(CL_CMD_MOVE_OBJECT, Connection, OrigX, OrigY, OrigZ))
+	|| (DestX != 0xFFFF && !CheckVisibility(CL_CMD_MOVE_OBJECT, Connection, DestX, DestY, DestZ))){
+		return;
+	}
+
+	// TODO(fusion): `RNum` usage in this context will only be used inside
+	// `GetObject` for indexing containers. For some reason I thought the
+	// Z coordinate was also used for that. Perhaps they're set to the same
+	// value.
+	if(OrigX != 0xFFFF){
+		RNum = 1;
+	}
+
+	try{
+		Player->ToDoMove(OrigX, OrigY, OrigZ, Type, RNum, DestX, DestY, DestZ, Count);
+		Player->ToDoStart();
+	}catch(RESULT r){
+		if(r != NOERROR){
+			SendResult(Connection, r);
+			Player->ToDoYield();
+		}
+	}
+}
+
+void CTradeObject(TConnection *Connection, TReadBuffer *Buffer){
+	if(Connection == NULL){
+		error("CTradeObject: Connection ist NULL.\n");
+		return;
+	}
+
+	TPlayer *Player = Connection->GetPlayer();
+	if(Player == NULL){
+		return;
+	}
+
+	int ObjX = Buffer->readWord();
+	int ObjY = Buffer->readWord();
+	int ObjZ = Buffer->readByte();
+	int TypeID = Buffer->readWord();
+	uint8 RNum = Buffer->readByte();
+	uint32 TradePartner = Buffer->readQuad();
+
+	ObjectType Type = GetObjectType(CL_CMD_TRADE_OBJECT, TypeID);
+	if(Type.isMapContainer()){
+		return;
+	}
+
+	if(!CheckSpecialCoordinates(CL_CMD_TRADE_OBJECT, ObjX, ObjY, ObjZ, false)){
+		return;
+	}
+
+	if(ObjX != 0xFFFF && !CheckVisibility(CL_CMD_TRADE_OBJECT, Connection, ObjX, ObjY, ObjZ)){
+		return;
+	}
+
+	// TODO(fusion): Same as `CMoveObject`.
+	if(ObjX != 0xFFFF){
+		RNum = 1;
+	}
+
+	try{
+		Player->ToDoTrade(ObjX, ObjY, ObjZ, Type, RNum, TradePartner);
+		Player->ToDoStart();
+	}catch(RESULT r){
+		if(r != NOERROR){
+			SendResult(Connection, r);
+			Player->ToDoYield();
+		}
+	}
+}
+
+void CInspectTrade(TConnection *Connection, TReadBuffer *Buffer){
+	if(Connection == NULL){
+		error("CInspectTrade: Connection ist NULL.\n");
+		return;
+	}
+
+	TPlayer *Player = Connection->GetPlayer();
+	if(Player == NULL){
+		return;
+	}
+
+	bool OwnOffer = (Buffer->readByte() == 0);
+	int Position = Buffer->readByte();
+	Object Obj = Player->InspectTrade(OwnOffer, Position);
+	if(Obj.exists()){
+		try{
+			Look(Player->ID, Obj);
+		}catch(RESULT r){
+			SendResult(Connection, r);
+		}
+	}
+}
+
+void CAcceptTrade(TConnection *Connection, TReadBuffer *Buffer){
+	if(Connection == NULL){
+		error("CAcceptTrade: Connection ist NULL.\n");
+		return;
+	}
+
+	TPlayer *Player = Connection->GetPlayer();
+	if(Player != NULL){
+		Player->AcceptTrade();
+	}
+}
+
+void CRejectTrade(TConnection *Connection, TReadBuffer *Buffer){
+	if(Connection == NULL){
+		error("CRejectTrade: Connection ist NULL.\n");
+		return;
+	}
+
+	TPlayer *Player = Connection->GetPlayer();
+	if(Player != NULL){
+		Player->RejectTrade();
+	}
+}
+
+void CUseObject(TConnection *Connection, TReadBuffer *Buffer){
+	if(Connection == NULL){
+		error("CUseObject: Connection ist NULL.\n");
+		return;
+	}
+
+	TPlayer *Player = Connection->GetPlayer();
+	if(Player == NULL){
+		return;
+	}
+
+	int ObjX = Buffer->readWord();
+	int ObjY = Buffer->readWord();
+	int ObjZ = Buffer->readByte();
+	int TypeID = Buffer->readWord();
+	uint8 RNum = Buffer->readByte();
+	uint8 Dummy = Buffer->readByte();
+
+	ObjectType Type = GetObjectType(CL_CMD_USE_OBJECT, TypeID);
+	if(Type.isMapContainer() || Type.getFlag(MULTIUSE)){
+		return;
+	}
+
+	if(Type.getFlag(CONTAINER) && Dummy >= NARRAY(TPlayer::OpenContainer)){
+		return;
+	}
+
+	if(!CheckSpecialCoordinates(CL_CMD_USE_OBJECT, ObjX, ObjY, ObjZ, false)){
+		return;
+	}
+
+	if(ObjX != 0xFFFF && !CheckVisibility(CL_CMD_USE_OBJECT, Connection, ObjX, ObjY, ObjZ)){
+		return;
+	}
+
+	try{
+		Player->ToDoWait(100);
+		Player->ToDoUse(1, ObjX, ObjY, ObjZ, Type, RNum, Dummy, 0, 0, 0, 0, 0);
+		Player->ToDoStart();
+	}catch(RESULT r){
+		SendResult(Connection, r);
+		Player->ToDoClear();
+		Player->ToDoYield();
+	}
+}
+
+void CUseTwoObjects(TConnection *Connection, TReadBuffer *Buffer){
+	if(Connection == NULL){
+		error("CUseTwoObjects: Connection ist NULL.\n");
+		return;
+	}
+
+	TPlayer *Player = Connection->GetPlayer();
+	if(Player == NULL){
+		return;
+	}
+
+	int ObjX1 = Buffer->readWord();
+	int ObjY1 = Buffer->readWord();
+	int ObjZ1 = Buffer->readByte();
+	int TypeID1 = Buffer->readWord();
+	uint8 RNum1 = Buffer->readByte();
+	int ObjX2 = Buffer->readWord();
+	int ObjY2 = Buffer->readWord();
+	int ObjZ2 = Buffer->readByte();
+	int TypeID2 = Buffer->readWord();
+	uint8 RNum2 = Buffer->readByte();
+
+	ObjectType Type1 = GetObjectType(CL_CMD_USE_TWO_OBJECTS, TypeID1);
+	ObjectType Type2 = GetObjectType(CL_CMD_USE_TWO_OBJECTS, TypeID2);
+	if(Type1.isMapContainer() || Type2.isMapContainer() || !Type1.getFlag(MULTIUSE)){
+		return;
+	}
+
+	if(!CheckSpecialCoordinates(CL_CMD_USE_TWO_OBJECTS, ObjX1, ObjY1, ObjZ1, false)
+	|| !CheckSpecialCoordinates(CL_CMD_USE_TWO_OBJECTS, ObjX2, ObjY2, ObjZ2, false)){
+		return;
+	}
+
+	if((ObjX1 != 0xFFFF && !CheckVisibility(CL_CMD_USE_TWO_OBJECTS, Connection, ObjX1, ObjY1, ObjZ1))
+	|| (ObjX2 != 0xFFFF && !CheckVisibility(CL_CMD_USE_TWO_OBJECTS, Connection, ObjX2, ObjY2, ObjZ2))){
+		return;
+	}
+
+	try{
+		Player->ToDoWait(100);
+		Player->ToDoUse(2, ObjX1, ObjY1, ObjZ1, Type1, RNum1, 0,
+							ObjX2, ObjY2, ObjZ2, Type2, RNum2);
+		Player->ToDoStart();
+	}catch(RESULT r){
+		SendResult(Connection, r);
+		Player->ToDoClear();
+		Player->ToDoYield();
+	}
+}
+
+void CUseOnCreature(TConnection *Connection, TReadBuffer *Buffer){
+	if(Connection == NULL){
+		error("CUseOnCreature: Connection ist NULL.\n");
+		return;
+	}
+
+	TPlayer *Player = Connection->GetPlayer();
+	if(Player == NULL){
+		return;
+	}
+
+	int ObjX = Buffer->readWord();
+	int ObjY = Buffer->readWord();
+	int ObjZ = Buffer->readByte();
+	int TypeID = Buffer->readWord();
+	uint8 RNum = Buffer->readByte();
+	uint32 TargetID = Buffer->readQuad();
+
+	// TODO(fusion): Check `Type.getFlag(MULTIUSE)`?
+	ObjectType Type = GetObjectType(CL_CMD_USE_ON_CREATURE, TypeID);
+	if(Type.isMapContainer()){
+		return;
+	}
+
+	if(!CheckSpecialCoordinates(CL_CMD_USE_ON_CREATURE, ObjX, ObjY, ObjZ, false)){
+		return;
+	}
+
+	if(ObjX != 0xFFFF && !CheckVisibility(CL_CMD_USE_ON_CREATURE, Connection, ObjX, ObjY, ObjZ)){
+		return;
+	}
+
+	TCreature *Target = GetCreature(TargetID);
+	if(Target == NULL || Target->Type == PLAYER){
+		return;
+	}
+
+	if(!CheckVisibility(CL_CMD_USE_ON_CREATURE, Connection,
+			Target->posx, Target->posy, Target->posz)){
+		return;
+	}
+
+	// TODO(fusion): Isn't this already checked with `CheckVisibility`? It also
+	// checks against the terminal offset which is not a distance semantically.
+	int DistanceX = std::abs(Target->posx - Player->posx);
+	int DistanceY = std::abs(Target->posy - Player->posy);
+	if(DistanceX >= Connection->TerminalOffsetX
+	|| DistanceY >= Connection->TerminalOffsetY){
+		SendResult(Connection, OUTOFRANGE);
+		return;
+	}
+
+	Object Obj = GetObject(Player->ID, ObjX, ObjY, ObjZ, RNum, Type);
+	if(!Obj.exists() || !Target->CrObject.exists()){
+		SendResult(Connection, NOTACCESSIBLE);
+		return;
+	}
+
+	try{
+		Player->ToDoWait(100);
+		Player->ToDoUse(2, Obj, Target->CrObject);
+		Player->ToDoStart();
+	}catch(RESULT r){
+		SendResult(Connection, r);
+		Player->ToDoClear();
+		Player->ToDoYield();
+	}
+}
+
+void CTurnObject(TConnection *Connection, TReadBuffer *Buffer){
+	if(Connection == NULL){
+		error("CTurnObject: Connection ist NULL.\n");
+		return;
+	}
+
+	TPlayer *Player = Connection->GetPlayer();
+	if(Player == NULL){
+		return;
+	}
+
+	int ObjX = Buffer->readWord();
+	int ObjY = Buffer->readWord();
+	int ObjZ = Buffer->readByte();
+	int TypeID = Buffer->readWord();
+	uint8 RNum = Buffer->readByte();
+
+	// TODO(fusion): Check `Type.getFlag(ROTATE)`?
+	ObjectType Type = GetObjectType(CL_CMD_TURN_OBJECT, TypeID);
+	if(Type.isMapContainer()){
+		return;
+	}
+
+	if(!CheckSpecialCoordinates(CL_CMD_TURN_OBJECT, ObjX, ObjY, ObjZ, false)){
+		return;
+	}
+
+	if(ObjX != 0xFFFF && !CheckVisibility(CL_CMD_TURN_OBJECT, Connection, ObjX, ObjY, ObjZ)){
+		return;
+	}
+
+	try{
+		Player->ToDoWait(100);
+		Player->ToDoTurn(ObjX, ObjY, ObjZ, Type, RNum);
+		Player->ToDoStart();
+	}catch(RESULT r){
+		SendResult(Connection, r);
+		Player->ToDoClear();
+		Player->ToDoYield();
+	}
+}
+
+void CCloseContainer(TConnection *Connection, TReadBuffer *Buffer){
+	if(Connection == NULL){
+		error("CCloseContainer: Connection ist NULL.\n");
+		return;
+	}
+
+	TPlayer *Player = Connection->GetPlayer();
+	if(Player == NULL){
+		return;
+	}
+
+	int ContainerNr = Buffer->readByte();
+	if(ContainerNr < NARRAY(TPlayer::OpenContainer)){
+		Player->SetOpenContainer(ContainerNr, NONE);
+		SendCloseContainer(Connection, ContainerNr);
+	}
+}
+
+void CUpContainer(TConnection *Connection, TReadBuffer *Buffer){
+	if(Connection == NULL){
+		error("CUpContainer: Connection ist NULL.\n");
+		return;
+	}
+
+	TPlayer *Player = Connection->GetPlayer();
+	if(Player == NULL){
+		return;
+	}
+
+	int ContainerNr = Buffer->readByte();
+	if(ContainerNr < NARRAY(TPlayer::OpenContainer)){
+		Object Con = Player->GetOpenContainer(ContainerNr);
+		if(Con != NONE){
+			Object Up = Con.getContainer();
+			ObjectType UpType = Up.getObjectType();
+			if(!UpType.isMapContainer() && !UpType.isBodyContainer()){
+				Player->SetOpenContainer(ContainerNr, Up);
+				SendContainer(Connection, ContainerNr);
+			}else{
+				Player->SetOpenContainer(ContainerNr, NONE);
+				SendCloseContainer(Connection, ContainerNr);
+			}
+		}
+	}
+}
+
+void CEditText(TConnection *Connection, TReadBuffer *Buffer){
+	if(Connection == NULL){
+		error("CEditText: Connection ist NULL.\n");
+		return;
+	}
+
+	TPlayer *Player = Connection->GetPlayer();
+	if(Player == NULL){
+		return;
+	}
+
+	Object Obj = Buffer->readQuad();
+	if(!Obj.exists()){
+		SendResult(Connection, NOTACCESSIBLE);
+		return;
+	}
+
+	ObjectType ObjType = Obj.getObjectType();
+	if(!ObjType.getFlag(WRITE)
+	&& (!ObjType.getFlag(WRITEONCE) || Obj.getAttribute(TEXTSTRING) != 0)){
+		SendResult(Connection, NOTACCESSIBLE);
+		return;
+	}
+
+	char Text[4096];
+	Buffer->readString(Text, sizeof(Text));
+	int TextLength = (int)strlen(Text);
+	int MaxLength = (ObjType.getFlag(WRITE)
+				? (int)ObjType.getAttribute(MAXLENGTH)
+				: (int)ObjType.getAttribute(MAXLENGTHONCE));
+	if(TextLength >= MaxLength){
+		SendResult(Connection, NOROOM);
+		return;
+	}
+
+	try{
+		EditText(Player->ID, Obj, Text);
+	}catch(RESULT r){
+		SendResult(Connection, r);
+	}
+}
+
+void CEditList(TConnection *Connection, TReadBuffer *Buffer){
+	if(Connection == NULL){
+		error("CEditList: Connection ist NULL.\n");
+		return;
+	}
+
+	TPlayer *Player = Connection->GetPlayer();
+	if(Player == NULL){
+		return;
+	}
+
+	char Text[4096];
+	int Type = Buffer->readByte();
+	uint32 ID = Buffer->readQuad();
+	Buffer->readString(Text, sizeof(Text));
+	if(Type == GUESTLIST){
+		ChangeGuests((uint16)ID, Player, Text);
+	}else if(Type == SUBOWNERLIST){
+		ChangeSubowners((uint16)ID, Player, Text);
+	}else if(Type == DOORLIST){
+		Object Door = ID;
+		if(!Door.exists()){
+			SendResult(Connection, NOTACCESSIBLE);
+			return;
+		}
+
+		ObjectType DoorType = Door.getObjectType();
+		if(!DoorType.getFlag(NAMEDOOR) || !DoorType.getFlag(TEXT)){
+			SendResult(Connection, NOTACCESSIBLE);
+			return;
+		}
+
+		ChangeNameDoor(Door, Player, Text);
+	}else{
+		error("CEditList: Unbekannter Typ %d.\n", Type);
+	}
+}
+
+void CLookAtPoint(TConnection *Connection, TReadBuffer *Buffer){
+	if(Connection == NULL){
+		error("CLookAtPoint: Connection ist NULL.\n");
+		return;
+	}
+
+	TPlayer *Player = Connection->GetPlayer();
+	if(Player == NULL){
+		return;
+	}
+
+	int ObjX = Buffer->readWord();
+	int ObjY = Buffer->readWord();
+	int ObjZ = Buffer->readByte();
+	if(!CheckSpecialCoordinates(CL_CMD_LOOK_AT_POINT, ObjX, ObjY, ObjZ, false)){
+		return;
+	}
+
+	if(ObjX != 0xFFFF && !CheckVisibility(CL_CMD_LOOK_AT_POINT, Connection, ObjX, ObjY, ObjZ)){
+		return;
+	}
+
+	int RNum = (ObjX == 0xFFFF ? ObjZ : -1);
+	Object Obj = GetObject(Player->ID, ObjX, ObjY, ObjZ, RNum, 0);
+	if(Obj.exists()){
+		try{
+			Look(Player->ID, Obj);
+		}catch(RESULT r){
+			SendResult(Connection, r);
+		}
+	}
+}
+
+void CTalk(TConnection *Connection, TReadBuffer *Buffer){
+	if(Connection == NULL){
+		error("CTalk: Connection ist NULL.\n");
+		return;
+	}
+
+	TPlayer *Player = Connection->GetPlayer();
+	if(Player == NULL){
+		print(3, "CTalk: Der Verbindung ist kein Spieler zugeordnet.\n");
+		return;
+	}
+
+	int Mode = Buffer->readByte();
+	if(Mode != TALK_SAY
+			&& Mode != TALK_WHISPER
+			&& Mode != TALK_YELL
+			&& Mode != TALK_PRIVATE_MESSAGE
+			&& Mode != TALK_CHANNEL_CALL
+			&& Mode != TALK_GAMEMASTER_REQUEST
+			&& Mode != TALK_GAMEMASTER_ANSWER
+			&& Mode != TALK_PLAYER_ANSWER
+			&& Mode != TALK_GAMEMASTER_BROADCAST
+			&& Mode != TALK_GAMEMASTER_CHANNELCALL
+			&& Mode != TALK_GAMEMASTER_MESSAGE
+			&& Mode != TALK_ANONYMOUS_BROADCAST
+			&& Mode != TALK_ANONYMOUS_CHANNELCALL
+			&& Mode != TALK_ANONYMOUS_MESSAGE){
+		print(3, "CTalk: Unbekannter Sprechmodus %d.\n", Mode);
+		return;
+	}
+
+	char Addressee[30] = {};
+	if(Mode == TALK_PRIVATE_MESSAGE
+			|| Mode == TALK_GAMEMASTER_ANSWER
+			|| Mode == TALK_GAMEMASTER_MESSAGE
+			|| Mode == TALK_ANONYMOUS_MESSAGE){
+		Buffer->readString(Addressee, sizeof(Addressee));
+		if(Addressee[0] == 0){
+			print(3, "CTalk: Adressat nicht angegeben.\n");
+			return;
+		}
+	}
+
+	int Channel = 0;
+	if(Mode == TALK_CHANNEL_CALL
+			|| Mode == TALK_GAMEMASTER_CHANNELCALL
+			|| Mode == TALK_ANONYMOUS_CHANNELCALL){
+		Channel = Buffer->readWord();
+		if(Channel >= GetNumberOfChannels()){
+			print(3, "CTalk: Ungültiger Kanal %d.\n", Channel);
+			return;
+		}
+
+		snprintf(Addressee, sizeof(Addressee), "%d", Channel);
+	}
+
+	char Text[256];
+	Buffer->readString(Text, sizeof(Text));
+	if(Text[0] == 0){
+		print(3, "CTalk: Kein Text.\n");
+		return;
+	}
+
+	if(findFirst(Text, '\n') != NULL){
+		error("CTalk: %s verwendet Newlines (%d,%s)\n", Player->Name, Mode, Text);
+		return;
+	}
+
+	if(Mode == TALK_GAMEMASTER_ANSWER && !CheckRight(Player->ID, READ_GAMEMASTER_CHANNEL)){
+		Mode = TALK_PRIVATE_MESSAGE;
+	}else if(Mode == TALK_GAMEMASTER_BROADCAST && !CheckRight(Player->ID, GAMEMASTER_BROADCAST)){
+		Mode = TALK_SAY;
+	}else if(Mode == TALK_GAMEMASTER_CHANNELCALL && !CheckRight(Player->ID, GAMEMASTER_BROADCAST)){
+		Mode = TALK_CHANNEL_CALL;
+	}else if(Mode == TALK_GAMEMASTER_MESSAGE && !CheckRight(Player->ID, GAMEMASTER_BROADCAST)){
+		Mode = TALK_PRIVATE_MESSAGE;
+	}else if(Mode == TALK_ANONYMOUS_BROADCAST && !CheckRight(Player->ID, ANONYMOUS_BROADCAST)){
+		Mode = TALK_SAY;
+	}else if(Mode == TALK_ANONYMOUS_CHANNELCALL && !CheckRight(Player->ID, ANONYMOUS_BROADCAST)){
+		Mode = TALK_CHANNEL_CALL;
+	}else if(Mode == TALK_ANONYMOUS_MESSAGE && !CheckRight(Player->ID, ANONYMOUS_BROADCAST)){
+		Mode = TALK_PRIVATE_MESSAGE;
+	}
+
+	if(Mode == TALK_YELL && Player->Skills[SKILL_LEVEL]->Get() <= 1){
+		SendMessage(Connection, TALK_FAILURE_MESSAGE,
+				"You may not yell as long as you are on level 1.");
+		return;
+	}
+
+	if(Mode == TALK_CHANNEL_CALL && Player->Skills[SKILL_LEVEL]->Get() <= 1){
+		SendMessage(Connection, TALK_FAILURE_MESSAGE,
+				"You may not speak into channels as long as you are on level 1.");
+		return;
+	}
+
+	if(Mode == TALK_CHANNEL_CALL
+			|| Mode == TALK_GAMEMASTER_CHANNELCALL
+			|| Mode == TALK_ANONYMOUS_CHANNELCALL){
+		if(Channel == CHANNEL_RULEVIOLATIONS){
+			print(3, "ChannelCall für GM-Request-Queue.\n");
+			return;
+		}
+
+		if(!ChannelSubscribed(Channel, Player->ID)){
+			Addressee[0] = 0;
+			Mode = TALK_SAY;
+		}
+	}
+
+	if(Mode == TALK_CHANNEL_CALL && Channel == CHANNEL_HELP
+			&& CheckRight(Player->ID, HIGHLIGHT_HELP_CHANNEL)){
+		Mode = TALK_HIGHLIGHT_CHANNELCALL;
+		Player->TutorActivities += 1;
+		print(3, "Aktvitätspunkt für %s.\n", Player->Name);
+	}
+
+	if(Mode == TALK_PLAYER_ANSWER){
+		if(Player->Request == 0){
+			return;
+		}
+
+		if(Player->RequestProcessingGamemaster == 0){
+			SendMessage(Connection, TALK_FAILURE_MESSAGE,
+					"Please wait until your request is answered.");
+			return;
+		}
+
+		TPlayer *Gamemaster = GetPlayer(Player->RequestProcessingGamemaster);
+		if(Gamemaster == NULL){
+			SendCloseRequest(Connection);
+			Player->Request = 0;
+			return;
+		}
+
+		strcpy(Addressee, Gamemaster->Name);
+	}
+
+	if(Mode == TALK_GAMEMASTER_REQUEST){
+		if(Player->Request != 0){
+			SendMessage(Connection, TALK_FAILURE_MESSAGE,
+					"You have already submitted a request."
+					" Please wait until it is answered.");
+			return;
+		}
+
+		Player->Request = AddDynamicString(Text);
+		Player->RequestTimestamp = RoundNr;
+		Player->RequestProcessingGamemaster = 0;
+		CreateGamemasterRequest(Player->Name, Text);
+	}else{
+		try{
+			Player->ToDoTalk(Mode, Addressee, Text, true);
+			Player->ToDoStart();
+		}catch(RESULT r){
+			SendResult(Connection, r);
+			Player->ToDoYield();
+		}
+	}
+}
+
+void CGetChannels(TConnection *Connection, TReadBuffer *Buffer){
+	if(Connection == NULL){
+		error("CGetChannels: Connection ist NULL.\n");
+		return;
+	}
+
+	SendChannels(Connection);
+}
+
+void CJoinChannel(TConnection *Connection, TReadBuffer *Buffer){
+	if(Connection == NULL){
+		error("CJoinChannel: Connection ist NULL.\n");
+		return;
+	}
+
+	TPlayer *Player = Connection->GetPlayer();
+	if(Player == NULL){
+		return;
+	}
+
+	int Channel = Buffer->readWord();
+	if(Channel < GetNumberOfChannels()){
+		try{
+			bool OwnChannel = JoinChannel(Channel, Player->ID);
+			if(Channel == CHANNEL_RULEVIOLATIONS){
+				SendOpenRequestQueue(Connection);
+				SendExistingRequests(Connection);
+			}else if(OwnChannel){
+				SendOpenOwnChannel(Connection, Channel);
+			}else{
+				SendOpenChannel(Connection, Channel);
+			}
+		}catch(RESULT r){
+			print(3, "Spieler darf Kanal nicht hören.\n");
+		}
+	}
+}
+
+void CLeaveChannel(TConnection *Connection, TReadBuffer *Buffer){
+	if(Connection == NULL){
+		error("CLeaveChannel: Connection ist NULL.\n");
+		return;
+	}
+
+	TPlayer *Player = Connection->GetPlayer();
+	if(Player == NULL){
+		return;
+	}
+
+	int Channel = Buffer->readWord();
+	if(Channel < GetNumberOfChannels()){
+		LeaveChannel(Channel, Player->ID, true);
+	}
+}
+
+void CPrivateChannel(TConnection *Connection, TReadBuffer *Buffer){
+	if(Connection == NULL){
+		error("CPrivateChannel: Connection ist NULL.\n");
+		return;
+	}
+
+	TPlayer *Player = Connection->GetPlayer();
+	if(Player == NULL){
+		return;
+	}
+
+	char Name[30];
+	Buffer->readString(Name, sizeof(Name));
+	if(Name[0] == 0){
+		return;
+	}
+
+	uint32 CharacterID = GetCharacterID(Name);
+	if(CharacterID == 0){
+		SendResult(Connection, PLAYERNOTEXISTING);
+		return;
+	}
+
+	if(CharacterID == Player->ID){
+		SendMessage(Connection, TALK_FAILURE_MESSAGE,
+				"You cannot set up a private message channel with yourself.");
+		return;
+	}
+
+	SendPrivateChannel(Connection, GetCharacterName(Name));
+}
+
+void CProcessRequest(TConnection *Connection, TReadBuffer *Buffer){
+	if(Connection == NULL){
+		error("CProcessRequest: Connection ist NULL.\n");
+		return;
+	}
+
+	TPlayer *Player = Connection->GetPlayer();
+	if(Player == NULL || !ChannelAvailable(CHANNEL_RULEVIOLATIONS, Player->ID)){
+		return;
+	}
+
+	char Name[30];
+	Buffer->readString(Name, sizeof(Name));
+	if(Name[0] == 0){
+		return;
+	}
+
+	TPlayer *Other;
+	if(IdentifyPlayer(Name, true, true, &Other) != 0){
+		SendMessage(Connection, TALK_FAILURE_MESSAGE,
+				"Player is not online any more.");
+		SendFinishRequest(Connection, Name);
+		return;
+	}
+
+	if(Other->Request == 0 || Other->RequestProcessingGamemaster != 0){
+		SendMessage(Connection, TALK_FAILURE_MESSAGE,
+				"Request has already been processed.");
+		SendFinishRequest(Connection, Name);
+		return;
+	}
+
+	Other->RequestProcessingGamemaster = Player->ID;
+	DeleteGamemasterRequest(Other->Name);
+}
+
+void CRemoveRequest(TConnection *Connection, TReadBuffer *Buffer){
+	if(Connection == NULL){
+		error("CRemoveRequest: Connection ist NULL.\n");
+		return;
+	}
+
+	TPlayer *Player = Connection->GetPlayer();
+	if(Player == NULL || !ChannelAvailable(CHANNEL_RULEVIOLATIONS, Player->ID)){
+		return;
+	}
+
+	char Name[30];
+	Buffer->readString(Name, sizeof(Name));
+	if(Name[0] == 0){
+		return;
+	}
+
+	TPlayer *Other;
+	if(IdentifyPlayer(Name, true, true, &Other) != 0){
+		SendMessage(Connection, TALK_FAILURE_MESSAGE,
+				"Player is not online any more.");
+		SendFinishRequest(Connection, Name);
+		return;
+	}
+
+	if(Other->Request != 0){
+		if(Other->RequestProcessingGamemaster == Player->ID){
+			Other->Request = 0;
+			SendCloseRequest(Other->Connection);
+		}else if(Other->RequestProcessingGamemaster == 0){
+			DeleteGamemasterRequest(Other->Name);
+		}
+	}
+}
+
+void CCancelRequest(TConnection *Connection, TReadBuffer *Buffer){
+	if(Connection == NULL){
+		error("CCancelRequest: Connection ist NULL.\n");
+		return;
+	}
+
+	// TODO(fusion): Does this mean regular players can't cancel their requests?
+	TPlayer *Player = Connection->GetPlayer();
+	if(Player == NULL || !ChannelAvailable(CHANNEL_RULEVIOLATIONS, Player->ID)){
+		return;
+	}
+
+	if(Player->Request != 0){
+		Player->Request = 0;
+		if(Player->RequestProcessingGamemaster != 0){
+			TPlayer *Gamemaster = GetPlayer(Player->RequestProcessingGamemaster);
+			if(Gamemaster != NULL){
+				SendFinishRequest(Gamemaster->Connection, Player->Name);
+			}
+		}else{
+			DeleteGamemasterRequest(Player->Name);
+		}
+	}
+}
+
+void CSetTactics(TConnection *Connection, TReadBuffer *Buffer){
+	if(Connection == NULL){
+		error("CSetTactics: Connection ist NULL.\n");
+		return;
+	}
+
+	TPlayer *Player = Connection->GetPlayer();
+	if(Player == NULL){
+		return;
+	}
+
+	int AttackMode = Buffer->readByte();
+	int ChaseMode = Buffer->readByte();
+	int SecureMode = Buffer->readByte();
+
+	if(AttackMode != ATTACK_MODE_OFFENSIVE
+			&& AttackMode != ATTACK_MODE_BALANCED
+			&& AttackMode != ATTACK_MODE_DEFENSIVE){
+		print(3, "CSetTactics: Ungültiger Angriffsmodus %d.\n", AttackMode);
+		return;
+	}
+
+	if(ChaseMode != CHASE_MODE_NONE
+			&& ChaseMode != CHASE_MODE_CLOSE){
+		print(3, "CSetTactics: Ungültiger Verfolgungsmodus %d.\n", ChaseMode);
+		return;
+	}
+
+	if(SecureMode != SECURE_MODE_DISABLED
+			&& SecureMode != SECURE_MODE_ENABLED){
+		print(3, "CSetTactics: Ungültiger Sicherheitsmodus %d.\n", SecureMode);
+		return;
+	}
+
+	Player->Combat.SetAttackMode((uint8)AttackMode);
+	Player->Combat.SetChaseMode((uint8)ChaseMode);
+	Player->Combat.SetSecureMode((uint8)SecureMode);
+}
+
+void CAttack(TConnection *Connection, TReadBuffer *Buffer, bool Follow){
+	if(Connection == NULL){
+		error("CAttack: Connection ist NULL.\n");
+		return;
+	}
+
+	TPlayer *Player = Connection->GetPlayer();
+	if(Player == NULL){
+		return;
+	}
+
+	uint32 TargetID = Buffer->readQuad();
+	try{
+		Player->Combat.SetAttackDest(TargetID, Follow);
+		Player->ToDoAttack();
+		Player->ToDoStart();
+	}catch(RESULT r){
+		if(r != NOERROR){
+			SendResult(Connection, r);
+			Player->ToDoYield();
+		}
+	}
+}
+
+void CInviteToParty(TConnection *Connection, TReadBuffer *Buffer){
+	if(Connection == NULL){
+		error("CInviteToParty: Connection ist NULL.\n");
+		return;
+	}
+
+	TPlayer *Player = Connection->GetPlayer();
+	if(Player == NULL){
+		return;
+	}
+
+	uint32 GuestID = Buffer->readQuad();
+	TCreature *Guest = GetCreature(GuestID);
+	if(Guest == NULL){
+		return;
+	}
+
+	if(!CheckVisibility(CL_CMD_INVITE_TO_PARTY, Connection,
+			Guest->posx, Guest->posy, Guest->posz)){
+		return;
+	}
+
+	InviteToParty(Player->ID, GuestID);
+}
+
+void CJoinParty(TConnection *Connection, TReadBuffer *Buffer){
+	if(Connection == NULL){
+		error("CJoinParty: Connection ist NULL.\n");
+		return;
+	}
+
+	TPlayer *Player = Connection->GetPlayer();
+	if(Player == NULL){
+		return;
+	}
+
+	uint32 HostID = Buffer->readQuad();
+	JoinParty(Player->ID, HostID);
+}
+
+void CRevokeInvitation(TConnection *Connection, TReadBuffer *Buffer){
+	if(Connection == NULL){
+		error("CRevokeInvitation: Connection ist NULL.\n");
+		return;
+	}
+
+	TPlayer *Player = Connection->GetPlayer();
+	if(Player == NULL){
+		return;
+	}
+
+	if(Player->GetPartyLeader(false) == 0){
+		print(3, "Spieler ist kein Mitglied einer Jagdgruppe.\n");
+		return;
+	}
+
+	uint32 GuestID = Buffer->readQuad();
+	RevokeInvitation(Player->ID, GuestID);
+}
+
+void CPassLeadership(TConnection *Connection, TReadBuffer *Buffer){
+	if(Connection == NULL){
+		error("CPassLeadership: Connection ist NULL.\n");
+		return;
+	}
+
+	TPlayer *Player = Connection->GetPlayer();
+	if(Player == NULL){
+		return;
+	}
+
+	if(Player->GetPartyLeader(false) == 0){
+		print(3, "Spieler ist kein Mitglied einer Jagdgruppe.\n");
+		return;
+	}
+
+	uint32 NewLeaderID = Buffer->readQuad();
+	PassLeadership(Player->ID, NewLeaderID);
+}
+
+void CLeaveParty(TConnection *Connection, TReadBuffer *Buffer){
+	if(Connection == NULL){
+		error("CLeaveParty: Connection ist NULL.\n");
+		return;
+	}
+
+	TPlayer *Player = Connection->GetPlayer();
+	if(Player == NULL){
+		return;
+	}
+
+	if(Player->GetPartyLeader(false) == 0){
+		print(3, "Spieler ist kein Mitglied einer Jagdgruppe.\n");
+		return;
+	}
+
+	LeaveParty(Player->ID, false);
+}
+
+void COpenChannel(TConnection *Connection, TReadBuffer *Buffer){
+	if(Connection == NULL){
+		error("COpenChannel: Connection ist NULL.\n");
+		return;
+	}
+
+	TPlayer *Player = Connection->GetPlayer();
+	if(Player == NULL){
+		return;
+	}
+
+	try{
+		OpenChannel(Player->ID);
+	}catch(RESULT r){
+		SendResult(Connection, r);
+	}
+}
+
+void CInviteToChannel(TConnection *Connection, TReadBuffer *Buffer){
+	if(Connection == NULL){
+		error("CInviteToChannel: Connection ist NULL.\n");
+		return;
+	}
+
+	TPlayer *Player = Connection->GetPlayer();
+	if(Player == NULL){
+		return;
+	}
+
+	char Name[30];
+	Buffer->readString(Name, sizeof(Name));
+	if(Name[0] == 0){
+		print(2, "CInviteToChannel: Kein Name angegeben.\n");
+		return;
+	}
+
+	try{
+		InviteToChannel(Player->ID, Name);
+	}catch(RESULT r){
+		SendResult(Connection, r);
+	}
+}
+
+void CExcludeFromChannel(TConnection *Connection, TReadBuffer *Buffer){
+	if(Connection == NULL){
+		error("CExcludeFromChannel: Connection ist NULL.\n");
+		return;
+	}
+
+	TPlayer *Player = Connection->GetPlayer();
+	if(Player == NULL){
+		return;
+	}
+
+	// TODO(fusion): The original function didn check if name was empty but it
+	// is probably a good idea.
+	char Name[30];
+	Buffer->readString(Name, sizeof(Name));
+	if(Name[0] == 0){
+		print(2, "CInviteToChannel: Kein Name angegeben.\n");
+		return;
+	}
+
+	try{
+		ExcludeFromChannel(Player->ID, Name);
+	}catch(RESULT r){
+		SendResult(Connection, r);
+	}
+}
+
+void CCancel(TConnection *Connection, TReadBuffer *Buffer){
+	if(Connection == NULL){
+		error("CCancel: Connection ist NULL.\n");
+		return;
+	}
+
+	TPlayer *Player = Connection->GetPlayer();
+	if(Player == NULL){
+		return;
+	}
+
+	try{
+		Player->Combat.StopAttack(0);
+		if(Player->ToDoClear()){
+			SendSnapback(Connection);
+		}
+	}catch(RESULT r){
+		// no-op
+	}
+
+	Player->ToDoYield();
+}
+
+void CRefreshField(TConnection *Connection, TReadBuffer *Buffer){
+	if(Connection == NULL){
+		error("CRefreshField: Connection ist NULL.\n");
+		return;
+	}
+
+	int FieldX = Buffer->readWord();
+	int FieldY = Buffer->readWord();
+	int FieldZ = Buffer->readByte();
+
+	if(!IsOnMap(FieldX, FieldY, FieldZ)){
+		return;
+	}
+
+	if(!CheckVisibility(CL_CMD_REFRESH_FIELD, Connection, FieldX, FieldY, FieldZ)){
+		return;
+	}
+
+	SendFieldData(Connection, FieldX, FieldY, FieldZ);
+}
+
+void CRefreshContainer(TConnection *Connection, TReadBuffer *Buffer){
+	if(Connection == NULL){
+		error("CRefreshContainer: Connection ist NULL.\n");
+		return;
+	}
+
+	TPlayer *Player = Connection->GetPlayer();
+	if(Player == NULL){
+		return;
+	}
+
+	int ContainerNr = Buffer->readByte();
+	if(ContainerNr < NARRAY(TPlayer::OpenContainer)){
+		Object Con = Player->GetOpenContainer(ContainerNr);
+		if(Con != NONE){
+			SendContainer(Connection, ContainerNr);
+		}
+	}
+}
+
+void CGetOutfit(TConnection *Connection, TReadBuffer *Buffer){
+	if(Connection == NULL){
+		error("CGetOutfit: Connection ist NULL.\n");
+		return;
+	}
+
+	TPlayer *Player = Connection->GetPlayer();
+	if(Player == NULL){
+		return;
+	}
+
+	if(CheckRight(Player->ID, GAMEMASTER_OUTFIT)){
+		SendMessage(Connection, TALK_FAILURE_MESSAGE,
+				"You may not change your outfit.");
+		return;
+	}
+
+	SendOutfit(Connection);
+}
+
+void CSetOutfit(TConnection *Connection, TReadBuffer *Buffer){
+	if(Connection == NULL){
+		error("CSetOutfit: Connection ist NULL.\n");
+		return;
+	}
+
+	TPlayer *Player = Connection->GetPlayer();
+	if(Player == NULL){
+		return;
+	}
+
+	TOutfit NewOutfit = {};
+	NewOutfit.OutfitID = Buffer->readWord();
+	Buffer->readBytes(NewOutfit.Colors, sizeof(NewOutfit.Colors));
+
+	int FirstOutfit = (Player->Sex == 1) ? 128 : 136;
+	int LastOutfit  = (Player->Sex == 1) ? 131 : 139;
+	if(CheckRight(Player->ID, PREMIUM_ACCOUNT)){
+		LastOutfit += 3;
+	}
+
+	if(NewOutfit.OutfitID < FirstOutfit || NewOutfit.OutfitID > LastOutfit){
+		if(Player->Sex == 1){
+			print(3, "CSetOutfit: Ungültiges Outfit %d für Männer.\n", NewOutfit.OutfitID);
+		}else{
+			print(3, "CSetOutfit: Ungültiges Outfit %d für Frauen.\n", NewOutfit.OutfitID);
+		}
+		return;
+	}
+
+	if(NewOutfit.Colors[0] > 132
+			|| NewOutfit.Colors[1] > 132
+			|| NewOutfit.Colors[2] > 132
+			|| NewOutfit.Colors[3] > 132){
+		print(3, "CSetOutfit: Ungültige Farbe für Outfit.\n");
+		return;
+	}
+
+	if(Player->Outfit == Player->OrgOutfit){
+		Player->Outfit = NewOutfit;
+		AnnounceChangedCreature(Player->ID, CREATURE_OUTFIT_CHANGED);
+	}
+
+	Player->OrgOutfit = NewOutfit;
+}
+
+void CAddBuddy(TConnection *Connection, TReadBuffer *Buffer){
+	if(Connection == NULL){
+		error("CAddBuddy: Connection ist NULL.\n");
+		return;
+	}
+
+	TPlayer *Player = Connection->GetPlayer();
+	if(Player == NULL){
+		return;
+	}
+
+	char Name[30];
+	Buffer->readString(Name, sizeof(Name));
+	if(Name[0] != 0){
+		Player->AddBuddy(Name);
+	}
+}
+
+void CRemoveBuddy(TConnection *Connection, TReadBuffer *Buffer){
+	if(Connection == NULL){
+		error("CRemoveBuddy: Connection ist NULL.\n");
+		return;
+	}
+
+	TPlayer *Player = Connection->GetPlayer();
+	if(Player == NULL){
+		return;
+	}
+
+	uint32 CharacterID = Buffer->readQuad();
+	Player->RemoveBuddy(CharacterID);
+}
+
+// NOTE(fusion): These logging functions were out of control. It's not necessarily
+// better now but it is way simpler and do we even need any special formatting?
+
+void CBugReport(TConnection *Connection, TReadBuffer *Buffer){
+	if(Connection == NULL){
+		error("CBugReport: Connection ist NULL.\n");
+		return;
+	}
+
+	char Text[1024];
+	Buffer->readString(Text, sizeof(Text));
+
+	bool Empty = true;
+	for(int i = 0; Text[i] != 0; i += 1){
+		if(!isprint(Text[i])){
+			Text[i] = 0;
+			break;
+		}else if(!isSpace(Text[i])){
+			Empty = false;
+		}
+	}
+
+	if(Empty){
+		return;
+	}
+
+	// NOTE(fusion): `ctime` will already add a new line character which is why
+	// there is none in this first `Log` call.
+	int PlayerX, PlayerY, PlayerZ;
+	time_t Time = time(NULL);
+	Connection->GetPosition(&PlayerX, &PlayerY, &PlayerZ);
+	Log("bugreport", "%s - %d/%d - [%d,%d,%d] - %s",
+			Connection->GetName(),
+			Connection->TerminalType,
+			Connection->TerminalVersion,
+			PlayerX, PlayerY, PlayerZ,
+			ctime(&Time));
+	Log("bugreport", "%s\n", Text);
+	Log("bugreport", "---------------------------------------------------------------------------\n");
+
+	SendMessage(Connection, TALK_STATUS_MESSAGE, "Comment sent.");
+}
+
+void CRuleViolation(TConnection *Connection, TReadBuffer *Buffer){
+	if(Connection == NULL){
+		error("CRuleViolation: Connection ist NULL.\n");
+		return;
+	}
+
+	TPlayer *Player = Connection->GetPlayer();
+	if(Player == NULL){
+		return;
+	}
+
+	char Name[30];
+	char Comment[200];
+	Buffer->readString(Name, sizeof(Name));
+	int Reason = Buffer->readByte();
+	int Action = Buffer->readByte();
+	Buffer->readString(Comment, sizeof(Comment));
+	uint32 StatementID = Buffer->readQuad();
+	bool IPBanishment = Buffer->readByte() != 0;
+
+	if(!CheckBanishmentRight(Player->ID, Reason, Action)
+			|| (IPBanishment && !CheckRight(Player->ID, IP_BANISHMENT))){
+		SendMessage(Connection, TALK_FAILURE_MESSAGE,
+				"You have no authorization for this action.");
+		return;
+	}
+
+	if(Comment[0] == 0){
+		SendMessage(Connection, TALK_FAILURE_MESSAGE,
+				"Please provide a comment for this report.");
+		return;
+	}
+
+	if(Action == 6 && StatementID == 0){
+		SendMessage(Connection, TALK_FAILURE_MESSAGE,
+				"Please provide a statement for this rule violation.");
+		return;
+	}
+
+	TPlayer *Criminal;
+	const char *IPAddress = NULL;
+	bool IgnoreGamemasters = !CheckRight(Player->ID, READ_GAMEMASTER_CHANNEL);
+	if(IdentifyPlayer(Name, false, IgnoreGamemasters, &Criminal) == 0){
+		if(CheckRight(Criminal->ID, NO_BANISHMENT)){
+			if(Action == 1 || Action == 3 || Action == 5){
+				SendMessage(Connection, TALK_FAILURE_MESSAGE,
+						"This name has already been approved.");
+				return;
+			}
+
+			if(Action != 6){
+				SendMessage(Connection, TALK_FAILURE_MESSAGE,
+						"You may not report a god or gamemaster.");
+				return;
+			}
+		}
+
+		strcpy(Name, Criminal->Name);
+		IPAddress = Criminal->IPAddress;
+	}else{
+		if(GetCharacterID(Name) == 0){
+			SendResult(Connection, PLAYERNOTEXISTING);
+			return;
+		}
+
+		strcpy(Name, GetCharacterName(Name));
+		if(IPBanishment){
+			SendMessage(Connection, TALK_FAILURE_MESSAGE,
+					"Player is not online. No IP address was banished.");
+			IPBanishment = false;
+		}
+	}
+
+	int NumberOfStatements = 0;
+	vector<TReportedStatement> *ReportedStatements = NULL;
+	bool HasStatement = ((Reason >= 9 && Reason <= 27) || Reason == 29);
+	if(HasStatement && StatementID != 0){
+		uint32 ListenerID = (Action != 6 ? Player->ID : 0);
+		int Context = GetCommunicationContext(ListenerID, StatementID,
+							&NumberOfStatements, &ReportedStatements);
+		if(Context == 1){
+			SendMessage(Connection, TALK_FAILURE_MESSAGE,
+					"Statement is unknown. Perhaps it is too old?");
+			return;
+		}else if(Context == 2){
+			SendMessage(Connection, TALK_FAILURE_MESSAGE,
+					"Statement has already been reported.");
+			return;
+		}
+	}
+
+	PunishmentOrder(Player, Name,IPAddress, Reason, Action, Comment,
+			NumberOfStatements, ReportedStatements, StatementID, IPBanishment);
+}
+
+void CErrorFileEntry(TConnection *Connection, TReadBuffer *Buffer){
+	if(Connection == NULL){
+		error("CErrorFileEntry: Connection ist NULL.\n");
+		return;
+	}
+
+	char Title[64];
+	char Date[32];
+	char Stack[2048];
+	char Comment[512];
+	Buffer->readString(Title, sizeof(Title));
+	Buffer->readString(Date, sizeof(Date));
+	Buffer->readString(Stack, sizeof(Stack));
+	Buffer->readString(Comment, sizeof(Comment));
+	if(Stack[0] == 0 && Comment[0] == 0){
+		return;
+	}
+
+	// NOTE(fusion): `ctime` will already add a new line character which is why
+	// there is none in this first `Log` call.
+	int PlayerX, PlayerY, PlayerZ;
+	time_t Time = time(NULL);
+	Connection->GetPosition(&PlayerX, &PlayerY, &PlayerZ);
+	Log("client-error", "%s - %d/%d - [%d,%d,%d] - %s",
+			Connection->GetName(),
+			Connection->TerminalType,
+			Connection->TerminalVersion,
+			PlayerX, PlayerY, PlayerZ,
+			ctime(&Time));
+	Log("client-error", "%s\n", Title);
+	Log("client-error", "%s\n", Date);
+
+	if(Stack[0] != 0){
+		Log("client-error", "\n");
+		Log("client-error", "%s\n", Stack);
+	}
+
+	if(Comment[0] != 0){
+		Log("client-error", "\n");
+		Log("client-error", "%s\n", Comment);
+	}
+
+	Log("client-error","---------------------------------------------------------------------------\n");
+}
+
+void ReceiveData(TConnection *Connection){
+	if(Connection == NULL){
+		error("ReceiveData: Connection ist NULL.\n");
+		return;
+	}
+
+	if(Connection->InDataSize <= 0){
+		error("ReceiveData: Keine Daten vorhanden.\n");
+		return;
+	}
+
+	if((Connection->InDataSize + 2) > (int)sizeof(Connection->InData)){
+		error("ReceiveData: Zu große Paketlänge %d.\n", Connection->InDataSize);
+		return;
+	}
+
+	// TODO(fusion): I thought the client would actually pack multiple commands
+	// in the same packet. Perhaps not until some later version?
+
+	// IMPORTANT(fusion): The actual payload size is in the buffer's first two
+	// bytes which is why we start reading from offset two.
+	TReadBuffer Buffer(Connection->InData + 2, Connection->InDataSize);
+
+	uint8 Command;
+	try{
+		Command = Buffer.readByte();
+	}catch(const char *str){
+		error("ReceiveData: Fehler beim Auslesen des Kommandos (%s).\n", str);
+		return;
+	}
+
+	if(Connection->State == CONNECTION_LOGIN){
+		if(Command != CL_CMD_LOGIN){
+			error("ReceiveData: Falsches Login-Kommando %d.\n", Command);
+		}else if(!Connection->JoinGame(&Buffer)){
+			Log("game", "Einloggen gescheitert.\n");
+			SendResult(Connection, LOGINERROR);
+			TPlayer *Player = Connection->GetPlayer();
+			if(Player != NULL){
+				DecrementIsOnlineOrder(Player->ID);
+			}else{
+				error("ReceiveData: Einloggen gescheitert und keine Kreatur bekannt.\n");
+			}
+			Connection->Disconnect();
+		}
+		return;
+	}
+
+	if(!CommandAllowed(Connection, Command)){
+		return;
+	}
+
+	Connection->ResetTimer(Command);
+	try{
+		switch(Command){
+			case CL_CMD_LOGOUT:					CQuitGame(Connection, &Buffer); break;
+			case CL_CMD_PING:					CPing(Connection, &Buffer); break;
+			case CL_CMD_GO_PATH:				CGoPath(Connection, &Buffer); break;
+			case CL_CMD_GO_NORTH:				CGoDirection(Connection,  0, -1); break;
+			case CL_CMD_GO_EAST:				CGoDirection(Connection,  1,  0); break;
+			case CL_CMD_GO_SOUTH:				CGoDirection(Connection,  0,  1); break;
+			case CL_CMD_GO_WEST:				CGoDirection(Connection, -1,  0); break;
+			case CL_CMD_GO_STOP:				CGoStop(Connection, &Buffer); break;
+			case CL_CMD_GO_NORTHEAST:			CGoDirection(Connection,  1, -1); break;
+			case CL_CMD_GO_SOUTHEAST:			CGoDirection(Connection,  1,  1); break;
+			case CL_CMD_GO_SOUTHWEST:			CGoDirection(Connection, -1,  1); break;
+			case CL_CMD_GO_NORTHWEST:			CGoDirection(Connection, -1, -1); break;
+			case CL_CMD_ROTATE_NORTH:			CRotate(Connection, DIRECTION_NORTH); break;
+			case CL_CMD_ROTATE_EAST:			CRotate(Connection, DIRECTION_EAST); break;
+			case CL_CMD_ROTATE_SOUTH:			CRotate(Connection, DIRECTION_SOUTH); break;
+			case CL_CMD_ROTATE_WEST:			CRotate(Connection, DIRECTION_WEST); break;
+			case CL_CMD_MOVE_OBJECT:			CMoveObject(Connection, &Buffer); break;
+			case CL_CMD_TRADE_OBJECT:			CTradeObject(Connection, &Buffer); break;
+			case CL_CMD_INSPECT_TRADE:			CInspectTrade(Connection, &Buffer); break;
+			case CL_CMD_ACCEPT_TRADE:			CAcceptTrade(Connection, &Buffer); break;
+			case CL_CMD_REJECT_TRADE:			CRejectTrade(Connection, &Buffer); break;
+			case CL_CMD_USE_OBJECT:				CUseObject(Connection, &Buffer); break;
+			case CL_CMD_USE_TWO_OBJECTS:		CUseTwoObjects(Connection, &Buffer); break;
+			case CL_CMD_USE_ON_CREATURE:		CUseOnCreature(Connection, &Buffer); break;
+			case CL_CMD_TURN_OBJECT:			CTurnObject(Connection, &Buffer); break;
+			case CL_CMD_CLOSE_CONTAINER:		CCloseContainer(Connection, &Buffer); break;
+			case CL_CMD_UP_CONTAINER:			CUpContainer(Connection, &Buffer); break;
+			case CL_CMD_EDIT_TEXT:				CEditText(Connection, &Buffer); break;
+			case CL_CMD_EDIT_LIST:				CEditList(Connection, &Buffer); break;
+			case CL_CMD_LOOK_AT_POINT:			CLookAtPoint(Connection, &Buffer); break;
+			case CL_CMD_TALK:					CTalk(Connection, &Buffer); break;
+			case CL_CMD_GET_CHANNELS:			CGetChannels(Connection, &Buffer); break;
+			case CL_CMD_JOIN_CHANNEL:			CJoinChannel(Connection, &Buffer); break;
+			case CL_CMD_LEAVE_CHANNEL:			CLeaveChannel(Connection, &Buffer); break;
+			case CL_CMD_PRIVATE_CHANNEL:		CPrivateChannel(Connection, &Buffer); break;
+			case CL_CMD_PROCESS_REQUEST:		CProcessRequest(Connection, &Buffer); break;
+			case CL_CMD_REMOVE_REQUEST:			CRemoveRequest(Connection, &Buffer); break;
+			case CL_CMD_CANCEL_REQUEST:			CCancelRequest(Connection, &Buffer); break;
+			case CL_CMD_SET_TACTICS:			CSetTactics(Connection, &Buffer); break;
+			case CL_CMD_ATTACK:					CAttack(Connection, &Buffer, false); break;
+			case CL_CMD_FOLLOW:					CAttack(Connection, &Buffer, true); break;
+			case CL_CMD_INVITE_TO_PARTY:		CInviteToParty(Connection, &Buffer); break;
+			case CL_CMD_JOIN_PARTY:				CJoinParty(Connection, &Buffer); break;
+			case CL_CMD_REVOKE_INVITATION:		CRevokeInvitation(Connection, &Buffer); break;
+			case CL_CMD_PASS_LEADERSHIP:		CPassLeadership(Connection, &Buffer); break;
+			case CL_CMD_LEAVE_PARTY:			CLeaveParty(Connection, &Buffer); break;
+			case CL_CMD_OPEN_CHANNEL:			COpenChannel(Connection, &Buffer); break;
+			case CL_CMD_INVITE_TO_CHANNEL:		CInviteToChannel(Connection, &Buffer); break;
+			case CL_CMD_EXCLUDE_FROM_CHANNEL:	CExcludeFromChannel(Connection, &Buffer); break;
+			case CL_CMD_CANCEL:					CCancel(Connection, &Buffer); break;
+			case CL_CMD_REFRESH_FIELD:			CRefreshField(Connection, &Buffer); break;
+			case CL_CMD_REFRESH_CONTAINER:		CRefreshContainer(Connection, &Buffer); break;
+			case CL_CMD_GET_OUTFIT:				CGetOutfit(Connection, &Buffer); break;
+			case CL_CMD_SET_OUTFIT:				CSetOutfit(Connection, &Buffer); break;
+			case CL_CMD_ADD_BUDDY:				CAddBuddy(Connection, &Buffer); break;
+			case CL_CMD_REMOVE_BUDDY:			CRemoveBuddy(Connection, &Buffer); break;
+			case CL_CMD_BUG_REPORT:				CBugReport(Connection, &Buffer); break;
+			case CL_CMD_RULE_VIOLATION:			CRuleViolation(Connection, &Buffer); break;
+			case CL_CMD_ERROR_FILE_ENTRY:		CErrorFileEntry(Connection, &Buffer); break;
+			default:{
+				print(3, "Unbekanntes Kommando %d.\n", Command);
+				break;
+			}
+		}
+	}catch(const char *str){
+		error("Fehler beim Auslesen der Daten für Kommando %d (%s).\n", Command, str);
+	}
+}
+
+void ReceiveData(void){
+	TConnection *Connection = GetFirstConnection();
+	while(Connection != NULL){
+		if(Connection->Live() && Connection->WaitingForACK){
+			ReceiveData(Connection);
+			Connection->WaitingForACK = false;
+			// TODO(fusion): It could have been disconnected inside `ReceiveData`?
+			if(Connection->Live()){
+				kill(Connection->GetPID(), SIGUSR1);
+			}
+		}
+		Connection = GetNextConnection();
+	}
+}
+
+void InitReceiving(void){
+	// no-op
+}
+
+void ExitReceiving(void){
+	// no-op
+}
diff --git a/src/sending.cc b/src/sending.cc
index 52c3e28..14551da 100644
--- a/src/sending.cc
+++ b/src/sending.cc
@@ -1091,8 +1091,8 @@ void SendEditText(TConnection *Connection, Object Obj){
 	char SpellbookBuffer[4096] = {};
 	if(ObjType.getFlag(WRITE) || ObjType.getFlag(WRITEONCE)){
 		MaxLength = (ObjType.getFlag(WRITE)
-				? ObjType.getAttribute(MAXLENGTH)
-				: ObjType.getAttribute(MAXLENGTHONCE));
+				? (int)ObjType.getAttribute(MAXLENGTH)
+				: (int)ObjType.getAttribute(MAXLENGTHONCE));
 		MaxLength -= 1;
 		Text = GetDynamicString(Obj.getAttribute(TEXTSTRING));
 		Editor = GetDynamicString(Obj.getAttribute(EDITOR));
@@ -1532,12 +1532,12 @@ void SendPrivateChannel(TConnection *Connection, const char *Name){
 	FinishSendData(Connection);
 }
 
-void SendOpenRequest(TConnection *Connection){
+void SendOpenRequestQueue(TConnection *Connection){
 	if(!BeginSendData(Connection)){
 		return;
 	}
 
-	SendByte(Connection, SV_CMD_OPEN_REQUEST);
+	SendByte(Connection, SV_CMD_OPEN_REQUEST_QUEUE);
 	SendWord(Connection, (uint16)CHANNEL_RULEVIOLATIONS);
 	FinishSendData(Connection);
 }
@@ -1724,6 +1724,29 @@ void BroadcastMessage(int Mode, const char *Text, ...){
 	}
 }
 
+void CreateGamemasterRequest(const char *Name, const char *Text){
+	if(Name == NULL){
+		error("CreateGamemasterRequest: Name ist NULL.\n");
+		return;
+	}
+
+	if(Text == NULL){
+		error("CreateGamemasterRequest: Name ist NULL.\n");
+		return;
+	}
+
+	TConnection *Connection = GetFirstConnection();
+	while(Connection != NULL){
+		if(Connection->Live()){
+			TPlayer *Player = Connection->GetPlayer();
+			if(Player != NULL && ChannelSubscribed(CHANNEL_RULEVIOLATIONS, Player->ID)){
+				SendTalk(Connection, 0, Name, TALK_GAMEMASTER_REQUEST, Text, 0);
+			}
+		}
+		Connection = GetNextConnection();
+	}
+}
+
 void DeleteGamemasterRequest(const char *Name){
 	if(Name == NULL){
 		error("DeleteGamemasterRequest: Name ist NULL.\n");
diff --git a/src/stubs.hh b/src/stubs.hh
index a7bd80d..e3b694e 100644
--- a/src/stubs.hh
+++ b/src/stubs.hh
@@ -18,6 +18,9 @@ typedef void TSendMailsFunction(TPlayerData *PlayerData);
 extern void AbortWriter(void);
 extern void AddBuddyOrder(TCreature *Creature, uint32 CharacterID);
 extern void RemoveBuddyOrder(TCreature *Creature, uint32 BuddyID);
+extern void ChangeGuests(uint16 HouseID, TPlayer *Player, const char *Text);
+extern void ChangeSubowners(uint16 HouseID, TPlayer *Player, const char *Text);
+extern void ChangeNameDoor(Object Door, TPlayer *Player, const char *Text);
 extern void ChangeNPCState(TCreature *Npc, int NewState, bool Stimulus);
 extern void CharacterDeathOrder(TCreature *Creature, int OldLevel,
 			uint32 Offender, const char *Remark, bool Unjustified);
@@ -47,7 +50,6 @@ extern void PunishmentOrder(TCreature *Creature, const char *Name, const char *I
 					int Reason, int Action, const char *Comment, int NumberOfStatements,
 					vector<TReportedStatement> *ReportedStatements, uint32 StatementID,
 					bool IPBanishment);
-extern void ReceiveData(void);
 extern void SavePlayerData(TPlayerData *Slot);
 extern bool LoadPlayerData(TPlayerData *Slot);
 extern bool PlayerDataExists(uint32 CharacterID);