Disable pushing when flying, start work on DEFLATE decompressor from scratch.

ClassicalSharp/Entities/LocalPlayer.cs

@@ -59,7 +59,7 @@ namespace ClassicalSharp.Entities {
 			bool wasOnGround = onGround;
 			
 			HandleInput(ref xMoving, ref zMoving);
-			if (!Hacks.Noclip && Hacks.CanBePushed) physics.DoEntityPush();
+			if (!Hacks.Floating && Hacks.CanBePushed) physics.DoEntityPush();
 			
 			// Immediate stop in noclip mode
 			if (!Hacks.NoclipSlide && (Hacks.Noclip && xMoving == 0 && zMoving == 0))

src/Client/Deflate.c

@@ -1,5 +1,16 @@
 #include "Deflate.h"
 #include "ErrorHandler.h"
+#include "Funcs.h"
+#include "Platform.h"
+
+bool Header_ReadByte(Stream* s, UInt8* state, Int32* value) {
+	*value = s->TryReadByte();
+	if (*value == -1) return false;
+
+	(*state)++;
+	return true;
+}
+
 
 #define GZipState_Header1           0
 #define GZipState_Header2           1
@@ -13,19 +24,6 @@
 #define GZipState_Comment           9
 #define GZipState_Done              10
 
-#define ZLibState_CompressionMethod 0
-#define ZLibState_Flags             1
-#define ZLibState_Done              2
-
-bool Header_ReadByte(Stream* s, UInt8* state, Int32* value) {
-	*value = s->TryReadByte();
-	if (*value == -1) return false;
-
-	(*state)++;
-	return true;
-}
-
-
 void GZipHeader_Init(GZipHeader* header) {
 	header->State = GZipState_Header1;
 	header->Done = false;
@@ -104,12 +102,16 @@ void GZipHeader_Read(Stream* s, GZipHeader* header) {
 		}
 
 		header->State++;
-		header->PartsRead = 0;		
+		header->PartsRead = 0;
 		header->Done = true;
 	}
 }
 
 
+#define ZLibState_CompressionMethod 0
+#define ZLibState_Flags             1
+#define ZLibState_Done              2
+
 void ZLibHeader_Init(ZLibHeader* header) {
 	header->State = ZLibState_CompressionMethod;
 	header->Done = false;
@@ -139,4 +141,127 @@ void ZLibHeader_Read(Stream* s, ZLibHeader* header) {
 		}
 		header->Done = true;
 	}
+}
+
+
+#define DeflateState_Header 0
+#define DeflateState_UncompressedHeader 1
+#define DeflateState_UncompressedData 2
+#define DeflateState_DynamicHeader 3
+
+#define DeflateState_Done 250
+
+void Deflate_Init(DeflateState* state, Stream* source) {
+	state->State = DeflateState_Header;
+	state->Source = source;
+	state->Bits = 0;
+	state->NumBits = 0;
+	state->AvailIn = 0;
+	state->NextIn = 0;
+	state->LastBlock = false;
+	state->AvailOut = 0;
+	state->Output = NULL;
+}
+
+/* Insert this byte into the bit buffer */
+#define DEFLATE_GET_BYTE(state)\
+state->AvailIn--;\
+state->Bits |= (UInt32)(state->Input[state->NextIn]) << state->NumBits;\
+state->NextIn++;\
+state->NumBits += 8;\
+
+/* Gets bytes from the bit buffer */
+#define DEFLATE_CONSUME_BITS(state, bits, result)\
+result = state->Bits & ((1UL << (bits)) - 1UL);\
+state->Bits >>= bits;\
+state->NumBits -= bits;
+
+/* Aligns bit buffer to be on a byte boundary*/
+#define DEFLATE_ALIGN_BITS(state, tmp)\
+tmp = state->NumBits & 7;\
+state->Bits >>= tmp;\
+state->NumBits -= tmp;
+
+#define DEFLATE_NEXTBLOCK_STATE(state) state->State = state->LastBlock ? DeflateState_Done : DeflateState_Header;
+
+void Deflate_Process(DeflateState* state) {
+	switch (state->State) {
+	case DeflateState_Header: {
+		while (state->NumBits < 3) {
+			if (state->AvailIn == 0) return;
+			DEFLATE_GET_BYTE(state);
+		}
+
+		UInt32 blockHeader;
+		DEFLATE_CONSUME_BITS(state, 3, blockHeader);
+		state->LastBlock = blockHeader & 1;
+
+		switch (blockHeader >> 1) {
+		case 0: { /* Uncompressed block*/
+			UInt32 tmp;
+			DEFLATE_ALIGN_BITS(state, tmp);
+			state->State = DeflateState_UncompressedHeader;
+		} break;
+
+		case 1: { /* Compressed with FIXED huffman table*/
+		} break;
+
+		case 2: { /* Compressed with dynamic huffman table */
+
+		} break;
+
+		case 3:
+			ErrorHandler_Fail("DEFLATE - Invalid block type");
+			return;
+		}
+	} break;
+
+	case DeflateState_UncompressedHeader: {
+		while (state->NumBits < 32) {
+			if (state->AvailIn == 0) return;
+			DEFLATE_GET_BYTE(state);
+		}
+
+		UInt32 len, nlen;
+		DEFLATE_CONSUME_BITS(state, 16, len);
+		DEFLATE_CONSUME_BITS(state, 16, nlen);
+		if (len != (nlen ^ 0xFFFFUL)) {
+			ErrorHandler_Fail("DEFLATE - Uncompressed block LEN check failed");
+		}
+		state->UncompressedLen = len;
+		state->State = DeflateState_UncompressedData;
+	} break;
+
+	case DeflateState_UncompressedData: {
+		/* TODO: HOW TO HANDLE INFINITE LOOP HERE ?????????? */
+		/* TODO TODO TODO TODO TODO TODO */
+		while (state->AvailIn > 0 && state->AvailOut > 0) {
+			UInt32 copyLen = min(state->AvailIn, state->AvailOut);
+			copyLen = min(copyLen, state->UncompressedLen);
+
+			Platform_MemCpy(state->Output, state->Input, copyLen);
+			state->Output += copyLen;
+			state->AvailIn -= copyLen;
+			state->AvailOut -= copyLen;
+			state->UncompressedLen -= copyLen;
+
+			if (state->UncompressedLen == 0) {
+				state->State = DEFLATE_NEXTBLOCK_STATE(state);
+				break;
+			}
+		}
+	} break;
+
+	case DeflateState_DynamicHeader: {
+		while (state->NumBits < 14) {
+			if (state->AvailIn == 0) return;
+			DEFLATE_GET_BYTE(state);
+		}
+
+		UInt32 numLits, numDists, numCodeLens;
+		DEFLATE_CONSUME_BITS(state, 5, numLits); numLits += 257;
+		DEFLATE_CONSUME_BITS(state, 5, numDists); numDists += 1;
+		DEFLATE_CONSUME_BITS(state, 4, numCodeLens); numCodeLens += 4;
+	} break;
+	}
 }

src/Client/Deflate.h

@@ -29,4 +29,27 @@ typedef struct ZLibHeader_ {
 void ZLibHeader_Init(ZLibHeader* header);
 /* Reads part of the ZLIB header. header.Done is set to true on completion of reading the header. */
 void ZLibHeader_Read(Stream* s, ZLibHeader* header);
+
+
+#define DEFLATE_INPUT_MAX 1024
+typedef struct DeflateState_ {
+	UInt8 State;
+	Stream* Source;
+	bool LastBlock; /* Whether the last DEFLATE block has been encounted in the stream */
+
+	UInt32 Bits;    /* Holds bits across byte boundaries*/
+	UInt32 NumBits; /* Number of bits in Bits buffer*/
+
+	UInt8 Input[DEFLATE_INPUT_MAX]; /* Buffer for input to DEFLATE */
+	UInt32 NextIn;                  /* Index within Input of byte being read */
+	UInt32 AvailIn;                 /* Number of bytes that can be read from Input */
+
+	UInt8* Output;    /* Pointer for output data */
+	UInt32 AvailOut;  /* Max number of bytes to output */
+
+	UInt32 UncompressedLen;
+} DeflateState;
+
+void Deflate_Init(DeflateState* state, Stream* source);
+void Deflate_Process(DeflateState* state);
 #endif