public void WritePacket(IMinecraftStream stream)
 {
     stream.WriteInt8(WindowID);
     stream.WriteInt16(SlotIndex);
     stream.WriteBoolean(RightClick);
     stream.WriteInt16(TransactionID);
     stream.WriteBoolean(Shift);
     stream.WriteInt16(ItemID);
     if (ItemID != -1)
     {
         stream.WriteInt8(Count);
         stream.WriteInt16(Metadata);
     }
 }
 public void WritePacket(IMinecraftStream stream)
 {
     stream.WriteInt8(WindowID);
     stream.WriteInt16(SlotIndex);
     stream.WriteBoolean(RightClick);
     stream.WriteInt16(TransactionID);
     stream.WriteBoolean(Shift);
     stream.WriteInt16(ItemID);
     if (ItemID != -1)
     {
         stream.WriteInt8(Count);
         stream.WriteInt16(Metadata);
     }
 }
        public IPacket WritePacket(IMinecraftStream stream)
        {
            stream.WriteVarInt(ID);
            stream.WriteBoolean(OnGround);
            stream.Purge();

            return this;
        }
Exemple #4
0
        public IPacket WritePacket(IMinecraftStream stream)
        {
            stream.WriteVarInt(ID);
            stream.WriteBoolean(OnGround);
            stream.Purge();

            return(this);
        }
Exemple #5
0
 public void WritePacket(IMinecraftStream stream)
 {
     stream.WriteInt32(EntityID);
     stream.WriteBoolean(InBed);
     stream.WriteInt32(X);
     stream.WriteInt8(Y);
     stream.WriteInt32(Z);
 }
 public void WritePacket(IMinecraftStream stream)
 {
     stream.WriteInt32(EntityID);
     stream.WriteBoolean(true); // Unknown
     stream.WriteInt32(X);
     stream.WriteInt32(Y);
     stream.WriteInt32(Z);
 }
 public void WritePacket(IMinecraftStream stream)
 {
     stream.WriteDouble(X);
     stream.WriteDouble(Y);
     stream.WriteDouble(Stance);
     stream.WriteDouble(Z);
     stream.WriteBoolean(OnGround);
 }
Exemple #8
0
 public void WritePacket(IMinecraftStream stream)
 {
     stream.WriteInt32(EntityID);
     stream.WriteBoolean(InBed);
     stream.WriteInt32(X);
     stream.WriteInt8(Y);
     stream.WriteInt32(Z);
 }
 public void WritePacket(IMinecraftStream stream)
 {
     stream.WriteDouble(X);
     stream.WriteDouble(Y);
     stream.WriteDouble(Stance);
     stream.WriteDouble(Z);
     stream.WriteBoolean(OnGround);
 }
        public IPacket WritePacket(IMinecraftStream stream)
        {
            stream.WriteVarInt(ID);
            stream.WriteInt(EntityID);
            stream.WriteInt(VehicleID);
            stream.WriteBoolean(Leash);
            stream.Purge();

            return this;
        }
Exemple #11
0
        public IPacket WritePacket(IMinecraftStream stream)
        {
            stream.WriteVarInt(ID);
            stream.WriteString(Text);
            stream.WriteBoolean(HasPosition);
            LookedAtBlock.ToStreamLong(stream);
            stream.Purge();

            return(this);
        }
Exemple #12
0
        public IPacket WritePacket(IMinecraftStream stream)
        {
            stream.WriteVarInt(ID);
            stream.WriteByte(WindowId);
            stream.WriteShort(ActionNumber);
            stream.WriteBoolean(Accepted);
            stream.Purge();

            return(this);
        }
        public IPacket WritePacket(IMinecraftStream stream)
        {
            stream.WriteVarInt(ID);
            stream.WriteString(Text);
            stream.WriteBoolean(HasPosition);
            LookedAtBlock.ToStreamLong(stream);
            stream.Purge();

            return this;
        }
Exemple #14
0
        public IPacket WritePacket(IMinecraftStream stream)
        {
            stream.WriteVarInt(ID);
            stream.WriteVarInt(EntityID);
            DeltaVector3.ToStreamSByteFixedPoint(stream);
            stream.WriteBoolean(OnGround);
            stream.Purge();

            return(this);
        }
        public IPacket WritePacket(IMinecraftStream stream)
        {
            stream.WriteVarInt(ID);
            stream.WriteVarInt(EntityID);
            DeltaVector3.ToStreamSByteFixedPoint(stream);
            stream.WriteBoolean(OnGround);
            stream.Purge();

            return this;
        }
        public IPacket WritePacket(IMinecraftStream stream)
        {
            stream.WriteVarInt(ID);
            stream.WriteByte(WindowID);
            stream.WriteShort(Slot);
            stream.WriteBoolean(Accepted);
            stream.Purge();

            return this;
        }
Exemple #17
0
        public IPacket WritePacket(IMinecraftStream stream)
        {
            stream.WriteVarInt(ID);
            stream.WriteInt(EntityID);
            stream.WriteInt(VehicleID);
            stream.WriteBoolean(Leash);
            stream.Purge();

            return(this);
        }
        public IPacket WritePacket(IMinecraftStream stream)
        {
            stream.WriteVarInt(ID);
            stream.WriteInt((int) EffectID);
            Location.ToStreamLong(stream);
            stream.WriteInt(Data);
            stream.WriteBoolean(DisableRelativeVolume);
            stream.Purge();

            return this;
        }
Exemple #19
0
        public IPacket WritePacket(IMinecraftStream stream)
        {
            stream.WriteVarInt(ID);
            stream.WriteInt((int)EffectID);
            Location.ToStreamLong(stream);
            stream.WriteInt(Data);
            stream.WriteBoolean(DisableRelativeVolume);
            stream.Purge();

            return(this);
        }
        public IPacket WritePacket(IMinecraftStream stream)
        {
            stream.WriteVarInt(ID);
            stream.WriteVarInt(EntityID);
            stream.WriteSByte(Yaw);
            stream.WriteSByte(Pitch);
            stream.WriteBoolean(OnGround);
            stream.Purge();

            return(this);
        }
        public IPacket WritePacket(IMinecraftStream stream)
        {
            stream.WriteVarInt(ID);
            stream.WriteVarInt(EntityID);
            stream.WriteSByte(Yaw);
            stream.WriteSByte(Pitch);
            stream.WriteBoolean(OnGround);
            stream.Purge();

            return this;
        }
        public IPacket WritePacket(IMinecraftStream stream)
        {
            stream.WriteVarInt(ID);
            stream.WriteString(Locale);
            stream.WriteByte(ViewDistance);
            stream.WriteByte((byte)ChatFlags);
            stream.WriteBoolean(ChatColours);
            DisplayedSkinParts.ToStream(stream);
            stream.Purge();

            return(this);
        }
        public IPacket WritePacket(IMinecraftStream stream)
        {
            stream.WriteVarInt(ID);
            stream.WriteString(Locale);
            stream.WriteByte(ViewDistance);
            stream.WriteByte((byte) ChatFlags);
            stream.WriteBoolean(ChatColours);
            DisplayedSkinParts.ToStream(stream);
            stream.Purge();

            return this;
        }
        public IPacket WritePacket(IMinecraftStream stream)
        {
            stream.WriteVarInt(ID);
            stream.WriteVarInt(EntityID);
            stream.WriteSByte((sbyte) EffectID);
            stream.WriteSByte(Amplifier);
            stream.WriteVarInt(Duration);
            stream.WriteBoolean(HideParticles);
            stream.Purge();

            return this;
        }
        public IPacket WritePacket(IMinecraftStream stream)
        {
            stream.WriteVarInt(ID);
            stream.WriteVarInt(EntityID);
            stream.WriteSByte((sbyte)EffectID);
            stream.WriteSByte(Amplifier);
            stream.WriteVarInt(Duration);
            stream.WriteBoolean(HideParticles);
            stream.Purge();

            return(this);
        }
 public void ToStream(ref IMinecraftStream stream)
 {
     stream.WriteString(Name);
     Properties.ToStream(ref stream);
     stream.WriteVarInt(Gamemode);
     stream.WriteVarInt(Ping);
     stream.WriteBoolean(HasDisplayName);
     if (HasDisplayName)
     {
         stream.WriteString(DisplayName);
     }
 }
        public IPacket WritePacket(IMinecraftStream stream)
        {
            stream.WriteVarInt(ID);
            stream.WriteDouble(X);
            stream.WriteDouble(FeetY);
            stream.WriteDouble(Z);
            stream.WriteFloat(Yaw);
            stream.WriteFloat(Pitch);
            stream.WriteBoolean(OnGround);
            stream.Purge();

            return(this);
        }
        public IPacket WritePacket(IMinecraftStream stream)
        {
            stream.WriteVarInt(ID);
            stream.WriteDouble(X);
            stream.WriteDouble(FeetY);
            stream.WriteDouble(Z);
            stream.WriteFloat(Yaw);
            stream.WriteFloat(Pitch);
            stream.WriteBoolean(OnGround);
            stream.Purge();

            return this;
        }
        public void ToStream(ref IMinecraftStream stream)
        {
            stream.WriteVarInt(Count);

            foreach (var entry in _entries)
            {
                stream.WriteString(entry.Name);
                stream.WriteString(entry.Value);
                stream.WriteBoolean(entry.IsSigned);
                if (entry.IsSigned)
                    stream.WriteString(entry.Signature);
            }
        }
        public IPacket WritePacket(IMinecraftStream stream)
        {
            stream.WriteVarInt(ID);
            stream.WriteInt(EntityID);
            stream.WriteVarInt((byte) GameMode);
            stream.WriteSByte((sbyte) Dimension);
            stream.WriteVarInt((byte) Difficulty);
            stream.WriteByte(MaxPlayers);
            stream.WriteString(LevelType);
            stream.WriteBoolean(ReducedDebugInfo);
            stream.Purge();

            return this;
        }
        public IPacket WritePacket(IMinecraftStream stream)
        {
            stream.WriteVarInt(ID);
            stream.WriteString(ScoreName);
            stream.WriteBoolean(RemoveItem);
            if (!RemoveItem)
            {
                stream.WriteString(ObjectiveName);
                stream.WriteInt(Value.Value);
            }
            stream.Purge();

            return this;
        }
        public IPacket WritePacket(IMinecraftStream stream)
        {
            stream.WriteVarInt(ID);
            stream.WriteString(ScoreName);
            stream.WriteBoolean(RemoveItem);
            if (!RemoveItem)
            {
                stream.WriteString(ObjectiveName);
                stream.WriteInt(Value.Value);
            }
            stream.Purge();

            return(this);
        }
Exemple #33
0
        public IPacket WritePacket(IMinecraftStream stream)
        {
            stream.WriteVarInt(ID);
            stream.WriteInt(EntityID);
            stream.WriteVarInt((byte)GameMode);
            stream.WriteSByte((sbyte)Dimension);
            stream.WriteVarInt((byte)Difficulty);
            stream.WriteByte(MaxPlayers);
            stream.WriteString(LevelType);
            stream.WriteBoolean(ReducedDebugInfo);
            stream.Purge();

            return(this);
        }
        public void ToStream(ref IMinecraftStream stream)
        {
            stream.WriteVarInt(Count);

            foreach (var entry in _entries)
            {
                stream.WriteString(entry.Name);
                stream.WriteString(entry.Value);
                stream.WriteBoolean(entry.IsSigned);
                if (entry.IsSigned)
                {
                    stream.WriteString(entry.Signature);
                }
            }
        }
Exemple #35
0
        // TODO: Convert to RawData
        public void ToStream(IMinecraftStream stream)
        {
            var OverWorld = true; // TODO: From World class

            stream.WriteVarInt(Coordinates.X);
            stream.WriteVarInt(Coordinates.Z);
            stream.WriteBoolean(OverWorld);
            stream.WriteUShort(PrimaryBitMap);

            var sectionCount = GetSectionCount(PrimaryBitMap);

            var chunkRawBlocks      = new byte[sectionCount * TwoByteData];
            var chunkRawBlocksLight = new byte[sectionCount * HalfByteData];
            var chunkRawSkylight    = new byte[sectionCount * HalfByteData];

            var size = sectionCount * (TwoByteData + HalfByteData + (OverWorld ? HalfByteData : 0)) + (OverWorld ? Biomes.Length : 0);
            var data = new byte[size];

            for (int y = 0, i = 0; y < Sections.Length; y++)
            {
                var section = Sections[y];

                if (Sections[i].IsFilled)
                {
                    // Blocks & Metadata
                    //Array.Copy(section.RawBlocks, 0, chunkRawBlocks, i * section.RawBlocks.Length, section.RawBlocks.Length);
                    // Light
                    //Array.Copy(section.RawBlockLight, 0, chunkRawBlocksLight, i * section.RawBlockLight.Length, section.RawBlockLight.Length);
                    // Sky light
                    //if (OverWorld)
                    //    Array.Copy(section.RawSkyLight, 0, chunkRawSkylight, i  *section.RawSkyLight.Length, section.RawSkyLight.Length);

                    i++;
                }
            }

            Array.Copy(chunkRawBlocks, 0, data, 0, chunkRawBlocks.Length);
            Array.Copy(chunkRawBlocksLight, 0, data, chunkRawBlocks.Length, chunkRawBlocksLight.Length);
            Array.Copy(chunkRawSkylight, 0, data, chunkRawBlocks.Length + chunkRawBlocksLight.Length, chunkRawSkylight.Length);
            if (OverWorld)
            {
                Array.Copy(Biomes, 0, data, data.Length - Biomes.Length, Biomes.Length);
            }

            stream.WriteVarInt(size);
            stream.WriteByteArray(data);
        }
Exemple #36
0
        public IPacket WritePacket(IMinecraftStream stream)
        {
            stream.WriteVarInt(ID);
            stream.WriteInt((int)ParticleID);
            stream.WriteBoolean(LongDistance);
            stream.WriteFloat(X);
            stream.WriteFloat(Y);
            stream.WriteFloat(Z);
            stream.WriteFloat(OffsetX);
            stream.WriteFloat(OffsetY);
            stream.WriteFloat(OffsetZ);
            stream.WriteFloat(ParticleData);
            stream.WriteInt(NumberOfParticles);
            stream.WriteVarIntArray(Data);

            return(this);
        }
        public IPacket WritePacket(IMinecraftStream stream)
        {
            stream.WriteVarInt(ID);
            stream.WriteInt((int) ParticleID);
            stream.WriteBoolean(LongDistance);
            stream.WriteFloat(X);
            stream.WriteFloat(Y);
            stream.WriteFloat(Z);
            stream.WriteFloat(OffsetX);
            stream.WriteFloat(OffsetY);
            stream.WriteFloat(OffsetZ);
            stream.WriteFloat(ParticleData);
            stream.WriteInt(NumberOfParticles);
            stream.WriteVarIntArray(Data);

            return this;
        }
Exemple #38
0
 public void WritePacket(IMinecraftStream stream)
 {
     stream.WriteInt32(UserID);
     stream.WriteInt32(TargetID);
     stream.WriteBoolean(LeftClick);
 }
Exemple #39
0
 public void WritePacket(IMinecraftStream stream)
 {
     stream.WriteInt8(WindowID);
     stream.WriteInt16(TransactionID);
     stream.WriteBoolean(Accepted);
 }
 public void WritePacket(IMinecraftStream stream)
 {
     stream.WriteSingle(Yaw);
     stream.WriteSingle(Pitch);
     stream.WriteBoolean(OnGround);
 }
 public void WritePacket(IMinecraftStream stream)
 {
     stream.WriteInt8(WindowID);
     stream.WriteInt16(TransactionID);
     stream.WriteBoolean(Accepted);
 }
 public void WritePacket(IMinecraftStream stream)
 {
     stream.WriteInt32(X);
     stream.WriteInt32(Z);
     stream.WriteBoolean(Load);
 }
Exemple #43
0
 public void WritePacket(IMinecraftStream stream)
 {
     stream.WriteInt32(UserID);
     stream.WriteInt32(TargetID);
     stream.WriteBoolean(LeftClick);
 }
Exemple #44
0
 public void WritePacket(IMinecraftStream stream)
 {
     stream.WriteSingle(Yaw);
     stream.WriteSingle(Pitch);
     stream.WriteBoolean(OnGround);
 }
 public void ToStream(ref IMinecraftStream stream)
 {
     stream.WriteString(Name);
     Properties.ToStream(ref stream);
     stream.WriteVarInt(Gamemode);
     stream.WriteVarInt(Ping);
     stream.WriteBoolean(HasDisplayName);
     if (HasDisplayName)
         stream.WriteString(DisplayName);
     
 }
Exemple #46
0
        // TODO: Convert to RawData
        public void ToStream(IMinecraftStream stream)
        {
            stream.WriteBoolean(GroundUp);
            Metadata.ToStream(stream);

            int totalSections = 0;

            foreach (var metadata in Metadata.GetMetadata())
            {
                totalSections += Chunk.GetSectionCount(metadata.PrimaryBitMap);
            }

            var size = totalSections * (Chunk.TwoByteData + Chunk.HalfByteData + (GroundUp ? Chunk.HalfByteData : 0)) + Metadata.Count * 256;
            var data = new byte[size];

            int i      = 0;
            int offset = 0;

            foreach (var metadata in _entries)
            {
                var sectionCount = Chunk.GetSectionCount(metadata.PrimaryBitMap);

                var chunkRawBlocks      = new byte[sectionCount * Chunk.TwoByteData];
                var chunkRawBlocksLight = new byte[sectionCount * Chunk.HalfByteData];
                var chunkRawSkylight    = new byte[sectionCount * Chunk.HalfByteData];

                var chunkLength = sectionCount * (Chunk.TwoByteData + Chunk.HalfByteData + (_entries[i].OverWorld ? Chunk.HalfByteData : 0)) + 256;
                var chunkData   = new byte[chunkLength];

                int j = 0;
                foreach (var section in _entries[i].Sections)
                {
                    if (_entries[i].Sections[j].IsFilled)
                    {
                        // Blocks & Metadata
                        //Array.Copy(section.RawBlocks, 0, chunkRawBlocks, j * section.RawBlocks.Length, section.RawBlocks.Length);
                        // Light
                        //Array.Copy(section.RawBlockLight, 0, chunkRawBlocksLight, j * section.RawBlockLight.Length, section.RawBlockLight.Length);
                        // Sky light
                        //if (_entries[i].OverWorld)
                        //    Array.Copy(section.RawSkyLight, 0, chunkRawSkylight, j * section.RawSkyLight.Length, section.RawSkyLight.Length);

                        j++;
                    }
                }

                Array.Copy(chunkRawBlocks, 0, chunkData, 0, chunkRawBlocks.Length);
                Array.Copy(chunkRawBlocksLight, 0, chunkData, chunkRawBlocks.Length, chunkRawBlocksLight.Length);
                Array.Copy(chunkRawSkylight, 0, chunkData, chunkRawBlocks.Length + chunkRawBlocksLight.Length, chunkRawSkylight.Length);
                if (_entries[i].OverWorld)
                {
                    Array.Copy(_entries[i].Biomes, 0, chunkData, chunkData.Length - _entries[i].Biomes.Length, _entries[i].Biomes.Length);
                }

                Array.Copy(chunkData, 0, data, offset, chunkData.Length);


                offset += chunkLength;
                i++;
            }

            stream.WriteVarInt(size);
            stream.WriteByteArray(data);
        }
 public void WritePacket(IMinecraftStream stream)
 {
     stream.WriteBoolean(OnGround);
 }
 public void ToStream(ref IMinecraftStream stream)
 {
     stream.WriteBoolean(HasDisplayName);
     stream.WriteString(DisplayName);
 }
Exemple #49
0
 public void WritePacket(IMinecraftStream stream)
 {
     stream.WriteBoolean(OnGround);
 }
 public void ToStream(ref IMinecraftStream stream)
 {
     stream.WriteBoolean(HasDisplayName);
     stream.WriteString(DisplayName);
 }
 public void WritePacket(IMinecraftStream stream)
 {
     stream.WriteInt32(X);
     stream.WriteInt32(Z);
     stream.WriteBoolean(Load);
 }