API tools faq
paste
Advertisement
Wouto1997

C# - Minecraft client packet handler

Wouto1997
Aug 6th, 2012
196
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C# 18.15 KB | None | 0 0
raw download clone embed print report
  1. public static void HandlePacket(Client sender, Stream stream)
  2.         {
  3.             // Use { } in every case so you can keep using variable names...
  4.             int packet__id = stream.ReadByte();
  5.             Console.WriteLine("Received: " + packet__id);
  6.             switch (packet__id)
  7.             {
  8.                     // Ping
  9.                 case 0:
  10.                     {
  11.                         new Packet(ReadByteArray(stream, 4)).Enqueue();
  12.                     }
  13.                     break;
  14.                     // Login Request
  15.                 case 1:
  16.                     {
  17.                         sender.EntityID = ReadInt(stream);
  18.                         sender.world.leveltype = ReadString(stream);
  19.                         sender.gamemode = ReadByte(stream);
  20.                         sender.world.Dimension = ReadByte(stream);
  21.                         sender.Difficulty = ReadByte(stream);
  22.                         sender.ServerMaxPlayers = ReadByte(stream);
  23.                     }
  24.                     break;
  25.                     // Chat Message
  26.                 case 3:
  27.                     {
  28.                         sender.Chat(null, ReadString(stream));
  29.                     }
  30.                     break;
  31.                     // Time Update
  32.                 case 4:
  33.                     {
  34.                         sender.world.Time = ReadLong(stream);
  35.                     }
  36.                     break;
  37.                     // Entity Equipment
  38.                 case 5:
  39.                     {
  40.                         // this is me really really really hoping it does all reading methods in this order...
  41.  
  42.                         // Entity.FindEntity(ReadInt(stream)).Equipment[ReadShort(stream)] = ReadSlot(stream);
  43.                         // not sure so the ugly way ,-,
  44.                         Entity entity = Entity.FindEntity(ReadInt(stream));
  45.                         short slot = ReadShort(stream);
  46.                         entity.Equipment[slot] = ReadSlot(stream);
  47.                     }
  48.                     break;
  49.                     // Spawn Position
  50.                 case 6:
  51.                     {
  52.                         sender.world.SpawnX = ReadInt(stream);
  53.                         sender.world.SpawnY = ReadInt(stream);
  54.                         sender.world.SpawnZ = ReadInt(stream);
  55.                     }
  56.                     break;
  57.                     // Update Health
  58.                 case 8:
  59.                     {
  60.                         sender.Health = ReadShort(stream);
  61.                         sender.Food = ReadShort(stream);
  62.                         sender.FoodSaturation = ReadFloat(stream);
  63.                     }
  64.                     break;
  65.                     // Respawn
  66.                 case 9:
  67.                     {
  68.                         sender.world.Dimension = ReadInt(stream);
  69.                         sender.Difficulty = ReadByte(stream);
  70.                         sender.gamemode = ReadByte(stream);
  71.                         sender.world.Height = ReadShort(stream);
  72.                         sender.world.leveltype = ReadString(stream);
  73.                     }
  74.                     break;
  75.                     // Player Position And Look
  76.                 case 13:
  77.                     {
  78.                         sender.X = ReadDouble(stream);
  79.                         sender.Stance = ReadDouble(stream);
  80.                         sender.Y = ReadDouble(stream);
  81.                         sender.Z = ReadDouble(stream);
  82.                         sender.Yaw = ReadFloat(stream);
  83.                         sender.Pitch = ReadFloat(stream);
  84.                         sender.OnGround = ReadBool(stream);
  85.                     }
  86.                     break;
  87.                     // Use Bed ( idk man, but 'use' bed... I prefer calling it sleeping... )
  88.                 case 17:
  89.                     {
  90.                         Entity entity = Entity.FindEntity(ReadInt(stream));
  91.                         ReadByte(stream);
  92.                         if (entity.EntityID == sender.EntityID) { sender.BedLocationIfSleeping.X = ReadInt(stream); sender.BedLocationIfSleeping.Y = ReadByte(stream); sender.BedLocationIfSleeping.Z = ReadInt(stream); }
  93.                         else { entity.BedLocationIfSleeping.X = ReadInt(stream); entity.BedLocationIfSleeping.Y = ReadByte(stream); entity.BedLocationIfSleeping.Z = ReadInt(stream); }
  94.                     }
  95.                     break;
  96.                     // Animation
  97.                 case 18:
  98.                     {
  99.                         ReadInt(stream);
  100.                         ReadByte(stream);
  101.                         // just discarding the answers... don't really know the use of this in a bot
  102.                     }
  103.                     break;
  104.                     // Spawn named entity
  105.                 case 20:
  106.                     {
  107.                         int id = ReadInt(stream);
  108.                         Entity entity = null;
  109.                         // not sure if existing entity or have to 'spawn' one...
  110.                         Entity.all.ForEach(delegate(Entity e) { if (e.EntityID == id) { entity = e; } });
  111.                         if (entity == null) { entity = new Entity(id); }
  112.                         entity.Username = ReadString(stream);
  113.                         entity.location.X = ReadInt(stream);
  114.                         entity.location.Y = ReadInt(stream);
  115.                         entity.location.Z = ReadInt(stream);
  116.                         entity.Yaw = ReadByte(stream);
  117.                         entity.Pitch = ReadByte(stream);
  118.                         // not -1 but 0 if empty
  119.                         entity.Equipment[0].ID = ReadShort(stream);
  120.                         //metadata..?
  121.                         //ReadShort(stream);
  122.  
  123.                         byte b = ReadByte(stream);
  124.                         while (b != 0x7f)
  125.                         { b = ReadByte(stream); }
  126.                     }
  127.                     break;
  128.                     // Spawn Dropped Item
  129.                 case 21:
  130.                     {
  131.                         Entity entity = new Entity(ReadInt(stream));
  132.                         entity.ItemID = ReadShort(stream);
  133.                         entity.count = ReadByte(stream);
  134.                         entity.damage_data = ReadShort(stream);
  135.                         entity.location.X = ReadInt(stream);
  136.                         entity.location.Y = ReadInt(stream);
  137.                         entity.location.Z = ReadInt(stream);
  138.                         entity.Rotation = ReadByte(stream);
  139.                         entity.Pitch = ReadByte(stream);
  140.                         entity.Roll = ReadByte(stream);
  141.                     }
  142.                     break;
  143.                     // Collect Item (disposing)
  144.                 case 22:
  145.                     {
  146.                         ReadInt(stream);
  147.                         ReadInt(stream);
  148.                     }
  149.                     break;
  150.                     // Spawn Object / Vehicle
  151.                 case 23:
  152.                     {
  153.                         ReadInt(stream);
  154.                         ReadByte(stream);
  155.                         ReadInt(stream);
  156.                         ReadInt(stream);
  157.                         ReadInt(stream);
  158.                         ReadInt(stream);
  159.                         ReadShort(stream);
  160.                         ReadShort(stream);
  161.                         ReadShort(stream);
  162.                     }
  163.                     break;
  164.                     // spawn mob
  165.                 case 24:
  166.                     {
  167.                         ReadInt(stream);
  168.                         ReadByte(stream);
  169.                         ReadInt(stream);
  170.                         ReadInt(stream);
  171.                         ReadInt(stream);
  172.                         ReadByte(stream);
  173.                         ReadByte(stream);
  174.                         ReadByte(stream);
  175.                         ReadShort(stream);
  176.                         ReadShort(stream);
  177.                         ReadShort(stream);
  178.                         byte b = ReadByte(stream);
  179.                         while (b != 0x7f)
  180.                         { b = ReadByte(stream); }
  181.                     }
  182.                     break;
  183.                     // spawn painting.... >.>
  184.                 case 25:
  185.                     {
  186.                         ReadInt(stream);
  187.                         ReadString(stream);
  188.                         ReadInt(stream);
  189.                         ReadInt(stream);
  190.                         ReadInt(stream);
  191.                         ReadInt(stream);
  192.                     }
  193.                     break;
  194.                     // Spawn Experience Orb
  195.                 case 26:
  196.                     {
  197.                         ReadInt(stream);
  198.                         ReadInt(stream);
  199.                         ReadInt(stream);
  200.                         ReadInt(stream);
  201.                         ReadShort(stream);
  202.                     }
  203.                     break;
  204.                     // Entity Velocity
  205.                 case 27:
  206.                     {
  207.                         ReadInt(stream);
  208.                         ReadShort(stream);
  209.                         ReadShort(stream);
  210.                         ReadShort(stream);
  211.                     }
  212.                     break;
  213.                     // destroy entity
  214.                 case 28:
  215.                     {
  216.                         byte b = ReadByte(stream);
  217.                         ReadByteArray(stream, b * 4); // ammount of entities * int-bytes(4)
  218.                     }
  219.                     break;
  220.                     // Entity...
  221.                 case 29:
  222.                     {
  223.                         // I think the chance we're ever receiving this is 0.00001%...
  224.                         ReadInt(stream);
  225.                     }
  226.                     break;
  227.                 case 30:
  228.                     {
  229.                         ReadInt(stream);
  230.                         ReadByte(stream);
  231.                         ReadByte(stream);
  232.                         ReadByte(stream);
  233.                     }
  234.                     break;
  235.                     // Entity Look
  236.                 case 31:
  237.                     {
  238.                         ReadInt(stream);
  239.                         ReadByte(stream);
  240.                         ReadByte(stream);
  241.                     }
  242.                     break;
  243.  
  244.                     // fuck dis shit
  245.  
  246.                 case 32:
  247.                     {
  248.                         ReadByteArray(stream, 6);
  249.                     }
  250.                     break;
  251.                 case 33:
  252.                     {
  253.                         ReadByteArray(stream, 9);
  254.                     }
  255.                     break;
  256.                 case 34:
  257.                     {
  258.                         ReadByteArray(stream, 18);
  259.                     }
  260.                     break;
  261.                 case 37:
  262.                     {
  263.                         ReadByteArray(stream, 4);
  264.                     }
  265.                     break;
  266.                 case 38:
  267.                     {
  268.                         ReadByteArray(stream, 8);
  269.                     }
  270.                     break;
  271.                 case 39:
  272.                     {
  273.                         ReadByteArray(stream, 4);
  274.                         byte b = ReadByte(stream);
  275.                         while (b != 0x7f) { b = ReadByte(stream); }
  276.                     }
  277.                     break;
  278.                 case 40:
  279.                     {
  280.                         ReadByteArray(stream, 8);
  281.                     }
  282.                     break;
  283.                 case 41:
  284.                     {
  285.                         ReadByteArray(stream, 5);
  286.                     }
  287.                     break;
  288.                 case 42:
  289.                     {
  290.                         ReadByteArray(stream, 8);
  291.                     }
  292.                     break;
  293.                 case 51:
  294.                     {
  295.                         ReadByteArray(stream, 13);
  296.                         int len = ReadInt(stream);
  297.                         ReadByteArray(stream, len);
  298.                     }
  299.                     break;
  300.                 case 52:
  301.                     {
  302.                         ReadByteArray(stream, 10);
  303.                         int len = ReadInt(stream);
  304.                         if (len > 0) { ReadByteArray(stream, len); }
  305.                     }
  306.                     break;
  307.                 case 53:
  308.                     {
  309.                         ReadByteArray(stream, 12);
  310.                     }
  311.                     break;
  312.                 case 54:
  313.                     {
  314.                         ReadByteArray(stream, 13);
  315.                     }
  316.                     break;
  317.                 case 55:
  318.                     {
  319.                         ReadByteArray(stream, 17);
  320.                     }
  321.                     break;
  322.                 case 56:
  323.                     {
  324.                         int len = ReadShort(stream);
  325.                         int len2 = ReadInt(stream);
  326.                         ReadByteArray(stream, len2);
  327.                         ReadByteArray(stream, len * 12);
  328.                     }
  329.                     break;
  330.                 case 60:
  331.                     {
  332.                         ReadByteArray(stream, 28);
  333.                         int len = ReadInt(stream);
  334.                         ReadByteArray(stream, len * 3 + 12);
  335.                     }
  336.                     break;
  337.                 case 61:
  338.                     {
  339.                         ReadByteArray(stream, 17);
  340.                     }
  341.                     break;
  342.                 case 62:
  343.                     {
  344.                         ReadString(stream);
  345.                         ReadByteArray(stream, 17);
  346.                     }
  347.                     break;
  348.                 case 70:
  349.                     {
  350.                         ReadByteArray(stream, 2);
  351.                     }
  352.                     break;
  353.                 case 71:
  354.                     {
  355.                         ReadByteArray(stream, 17);
  356.                     }
  357.                     break;
  358.                 case 72:
  359.                     {
  360.                         ReadShort(stream);
  361.                         ReadString(stream);
  362.                         ReadByte(stream);
  363.                     }
  364.                     break;
  365.                 case 65:
  366.                     {
  367.                         ReadByte(stream);
  368.                     }
  369.                     break;
  370.                 case 103:
  371.                     {
  372.                         ReadByteArray(stream, 3);
  373.                         ReadSlot(stream);
  374.                     }
  375.                     break;
  376.                 case 104:
  377.                     {
  378.                         ReadByte(stream);
  379.                         short i = ReadShort(stream);
  380.                         for(;i > 0; i--)
  381.                         {
  382.                             ReadSlot(stream);
  383.                         }
  384.                     }
  385.                     break;
  386.                 case 105:
  387.                     {
  388.                         ReadByteArray(stream, 5);
  389.                     }
  390.                     break;
  391.                 case 106:
  392.                     {
  393.                         ReadByteArray(stream, 4);
  394.                     }
  395.                     break;
  396.                 case 107:
  397.                     {
  398.                         ReadShort(stream);
  399.                         ReadSlot(stream);
  400.                     }
  401.                     break;
  402.                 case 130:
  403.                     {
  404.                         ReadByteArray(stream, 10);
  405.                         ReadString(stream);
  406.                         ReadString(stream);
  407.                         ReadString(stream);
  408.                         ReadString(stream);
  409.                     }
  410.                     break;
  411.                 case 131:
  412.                     {
  413.                         ReadInt(stream);
  414.                         byte b = ReadByte(stream);
  415.                         ReadByteArray(stream, b);
  416.                     }
  417.                     break;
  418.                 case 132:
  419.                     {
  420.                         ReadByteArray(stream, 11);
  421.                         int len = ReadShort(stream);
  422.                         if (len > 0) { ReadByteArray(stream, len); }
  423.                     }
  424.                     break;
  425.                 case 200:
  426.                     {
  427.                         ReadByteArray(stream, 5);
  428.                     }
  429.                     break;
  430.                 case 201:
  431.                     {
  432.                         ReadString(stream);
  433.                         ReadByteArray(stream, 3);
  434.                     }
  435.                     break;
  436.                 case 202:
  437.                     {
  438.                         ReadByteArray(stream, 3);
  439.                     }
  440.                     break;
  441.                 case 203:
  442.                     {
  443.                         ReadString(stream);
  444.                     }
  445.                     break;
  446.                 case 250:
  447.                     {
  448.                         ReadString(stream);
  449.                         short len = ReadShort(stream);
  450.                         ReadByteArray(stream, len);
  451.                     }
  452.                     break;
  453.                 case 253:
  454.                     {
  455.                         short len1 = ReadShort(stream);
  456.                         ReadByteArray(stream, len1);
  457.                         short len2 = ReadShort(stream);
  458.                         ReadByteArray(stream, len2);
  459.                     }
  460.                     break;
  461.                 case 254:
  462.                     {
  463.                         ReadString(stream);
  464.                         short len1 = ReadShort(stream);
  465.                         ReadByteArray(stream, len1);
  466.                         short len2 = ReadShort(stream);
  467.                         ReadByteArray(stream, len2);
  468.                     }
  469.                     break;
  470.                 case 256:
  471.                     {
  472.                         ReadString(stream);
  473.                         sender.client.Close();
  474.                     }
  475.                     break;
  476.                     // Shit happens
  477.                 default:
  478.                     {
  479.                         Console.WriteLine("Received unknown packet type: " + packet__id);
  480.                         Console.WriteLine("({0})", BitConverter.ToString(BitConverter.GetBytes(packet__id)).Split('-')[3]);
  481.                     }
  482.                     break;
  483.             }
  484.         }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!