InteractionRules.java

package com.hypixel.hytale.protocol;

import com.hypixel.hytale.protocol.io.ProtocolException;
import com.hypixel.hytale.protocol.io.ValidationResult;
import com.hypixel.hytale.protocol.io.VarInt;
import io.netty.buffer.ByteBuf;
import java.util.Arrays;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class InteractionRules {
   public static final int NULLABLE_BIT_FIELD_SIZE = 1;
   public static final int FIXED_BLOCK_SIZE = 17;
   public static final int VARIABLE_FIELD_COUNT = 4;
   public static final int VARIABLE_BLOCK_START = 33;
   public static final int   ;
   
    InteractionType[] blockedBy;
   
    InteractionType[] blocking;
   
    InteractionType[] interruptedBy;
   
    InteractionType[] interrupting;
     blockedByBypassIndex;
     blockingBypassIndex;
     interruptedByBypassIndex;
     interruptingBypassIndex;

     {
   }

     {
      .blockedBy = blockedBy;
      .blocking = blocking;
      .interruptedBy = interruptedBy;
      .interrupting = interrupting;
      .blockedByBypassIndex = blockedByBypassIndex;
      .blockingBypassIndex = blockingBypassIndex;
      .interruptedByBypassIndex = interruptedByBypassIndex;
      .interruptingBypassIndex = interruptingBypassIndex;
   }

     {
      .blockedBy = other.blockedBy;
      .blocking = other.blocking;
      .interruptedBy = other.interruptedBy;
      .interrupting = other.interrupting;
      .blockedByBypassIndex = other.blockedByBypassIndex;
      .blockingBypassIndex = other.blockingBypassIndex;
      .interruptedByBypassIndex = other.interruptedByBypassIndex;
      .interruptingBypassIndex = other.interruptingBypassIndex;
   }

   
     InteractionRules  {
          ();
         buf.getByte(offset);
      obj.blockedByBypassIndex = buf.getIntLE(offset + );
      obj.blockingBypassIndex = buf.getIntLE(offset + );
      obj.interruptedByBypassIndex = buf.getIntLE(offset + );
      obj.interruptingBypassIndex = buf.getIntLE(offset + );
       ((nullBits & ) != ) {
            offset +  + buf.getIntLE(offset + );
            VarInt.peek(buf, varPos0);
          (blockedByCount < ) {
             ProtocolException.negativeLength(, blockedByCount);
         }

          (blockedByCount > ) {
             ProtocolException.arrayTooLong(, blockedByCount, );
         }

            VarInt.length(buf, varPos0);
          (()(varPos0 + varIntLen) + ()blockedByCount *  > ()buf.readableBytes()) {
             ProtocolException.bufferTooSmall(, varPos0 + varIntLen + blockedByCount * , buf.readableBytes());
         }

         obj.blockedBy =  [blockedByCount];
            varPos0 + varIntLen;

         (   ; i < blockedByCount; ++i) {
            obj.blockedBy[i] = InteractionType.fromValue(buf.getByte(elemPos));
            ++elemPos;
         }
      }

       ((nullBits & ) != ) {
            offset +  + buf.getIntLE(offset + );
            VarInt.peek(buf, varPos1);
          (blockingCount < ) {
             ProtocolException.negativeLength(, blockingCount);
         }

          (blockingCount > ) {
             ProtocolException.arrayTooLong(, blockingCount, );
         }

            VarInt.length(buf, varPos1);
          (()(varPos1 + varIntLen) + ()blockingCount *  > ()buf.readableBytes()) {
             ProtocolException.bufferTooSmall(, varPos1 + varIntLen + blockingCount * , buf.readableBytes());
         }

         obj.blocking =  [blockingCount];
            varPos1 + varIntLen;

         (   ; i < blockingCount; ++i) {
            obj.blocking[i] = InteractionType.fromValue(buf.getByte(elemPos));
            ++elemPos;
         }
      }

       ((nullBits & ) != ) {
            offset +  + buf.getIntLE(offset + );
            VarInt.peek(buf, varPos2);
          (interruptedByCount < ) {
             ProtocolException.negativeLength(, interruptedByCount);
         }

          (interruptedByCount > ) {
             ProtocolException.arrayTooLong(, interruptedByCount, );
         }

            VarInt.length(buf, varPos2);
          (()(varPos2 + varIntLen) + ()interruptedByCount *  > ()buf.readableBytes()) {
             ProtocolException.bufferTooSmall(, varPos2 + varIntLen + interruptedByCount * , buf.readableBytes());
         }

         obj.interruptedBy =  [interruptedByCount];
            varPos2 + varIntLen;

         (   ; i < interruptedByCount; ++i) {
            obj.interruptedBy[i] = InteractionType.fromValue(buf.getByte(elemPos));
            ++elemPos;
         }
      }

       ((nullBits & ) != ) {
            offset +  + buf.getIntLE(offset + );
            VarInt.peek(buf, varPos3);
          (interruptingCount < ) {
             ProtocolException.negativeLength(, interruptingCount);
         }

          (interruptingCount > ) {
             ProtocolException.arrayTooLong(, interruptingCount, );
         }

            VarInt.length(buf, varPos3);
          (()(varPos3 + varIntLen) + ()interruptingCount *  > ()buf.readableBytes()) {
             ProtocolException.bufferTooSmall(, varPos3 + varIntLen + interruptingCount * , buf.readableBytes());
         }

         obj.interrupting =  [interruptingCount];
            varPos3 + varIntLen;

         (   ; i < interruptingCount; ++i) {
            obj.interrupting[i] = InteractionType.fromValue(buf.getByte(elemPos));
            ++elemPos;
         }
      }

       obj;
   }

       {
         buf.getByte(offset);
         ;
       ((nullBits & ) != ) {
            buf.getIntLE(offset + );
            offset +  + fieldOffset0;
            VarInt.peek(buf, pos0);
         pos0 += VarInt.length(buf, pos0) + arrLen * ;
          (pos0 - offset > maxEnd) {
            maxEnd = pos0 - offset;
         }
      }

       ((nullBits & ) != ) {
            buf.getIntLE(offset + );
            offset +  + fieldOffset1;
            VarInt.peek(buf, pos1);
         pos1 += VarInt.length(buf, pos1) + arrLen * ;
          (pos1 - offset > maxEnd) {
            maxEnd = pos1 - offset;
         }
      }

       ((nullBits & ) != ) {
            buf.getIntLE(offset + );
            offset +  + fieldOffset2;
            VarInt.peek(buf, pos2);
         pos2 += VarInt.length(buf, pos2) + arrLen * ;
          (pos2 - offset > maxEnd) {
            maxEnd = pos2 - offset;
         }
      }

       ((nullBits & ) != ) {
            buf.getIntLE(offset + );
            offset +  + fieldOffset3;
            VarInt.peek(buf, pos3);
         pos3 += VarInt.length(buf, pos3) + arrLen * ;
          (pos3 - offset > maxEnd) {
            maxEnd = pos3 - offset;
         }
      }

       maxEnd;
   }

      {
         buf.writerIndex();
         ;
       (.blockedBy != ) {
         nullBits = ()(nullBits | );
      }

       (.blocking != ) {
         nullBits = ()(nullBits | );
      }

       (.interruptedBy != ) {
         nullBits = ()(nullBits | );
      }

       (.interrupting != ) {
         nullBits = ()(nullBits | );
      }

      buf.writeByte(nullBits);
      buf.writeIntLE(.blockedByBypassIndex);
      buf.writeIntLE(.blockingBypassIndex);
      buf.writeIntLE(.interruptedByBypassIndex);
      buf.writeIntLE(.interruptingBypassIndex);
         buf.writerIndex();
      buf.writeIntLE();
         buf.writerIndex();
      buf.writeIntLE();
         buf.writerIndex();
      buf.writeIntLE();
         buf.writerIndex();
      buf.writeIntLE();
         buf.writerIndex();
       (.blockedBy != ) {
         buf.setIntLE(blockedByOffsetSlot, buf.writerIndex() - varBlockStart);
          (.blockedBy.length > ) {
             ProtocolException.arrayTooLong(, .blockedBy.length, );
         }

         VarInt.write(buf, .blockedBy.length);

         (InteractionType item : .blockedBy) {
            buf.writeByte(item.getValue());
         }
      }  {
         buf.setIntLE(blockedByOffsetSlot, -);
      }

       (.blocking != ) {
         buf.setIntLE(blockingOffsetSlot, buf.writerIndex() - varBlockStart);
          (.blocking.length > ) {
             ProtocolException.arrayTooLong(, .blocking.length, );
         }

         VarInt.write(buf, .blocking.length);

         (InteractionType item : .blocking) {
            buf.writeByte(item.getValue());
         }
      }  {
         buf.setIntLE(blockingOffsetSlot, -);
      }

       (.interruptedBy != ) {
         buf.setIntLE(interruptedByOffsetSlot, buf.writerIndex() - varBlockStart);
          (.interruptedBy.length > ) {
             ProtocolException.arrayTooLong(, .interruptedBy.length, );
         }

         VarInt.write(buf, .interruptedBy.length);

         (InteractionType item : .interruptedBy) {
            buf.writeByte(item.getValue());
         }
      }  {
         buf.setIntLE(interruptedByOffsetSlot, -);
      }

       (.interrupting != ) {
         buf.setIntLE(interruptingOffsetSlot, buf.writerIndex() - varBlockStart);
          (.interrupting.length > ) {
             ProtocolException.arrayTooLong(, .interrupting.length, );
         }

         VarInt.write(buf, .interrupting.length);

         (InteractionType item : .interrupting) {
            buf.writeByte(item.getValue());
         }
      }  {
         buf.setIntLE(interruptingOffsetSlot, -);
      }

   }

      {
         ;
       (.blockedBy != ) {
         size += VarInt.size(.blockedBy.length) + .blockedBy.length * ;
      }

       (.blocking != ) {
         size += VarInt.size(.blocking.length) + .blocking.length * ;
      }

       (.interruptedBy != ) {
         size += VarInt.size(.interruptedBy.length) + .interruptedBy.length * ;
      }

       (.interrupting != ) {
         size += VarInt.size(.interrupting.length) + .interrupting.length * ;
      }

       size;
   }

     ValidationResult  {
       (buffer.readableBytes() - offset < ) {
          ValidationResult.error();
      }  {
            buffer.getByte(offset);
          ((nullBits & ) != ) {
               buffer.getIntLE(offset + );
             (blockedByOffset < ) {
                ValidationResult.error();
            }

               offset +  + blockedByOffset;
             (pos >= buffer.writerIndex()) {
                ValidationResult.error();
            }

               VarInt.peek(buffer, pos);
             (blockedByCount < ) {
                ValidationResult.error();
            }

             (blockedByCount > ) {
                ValidationResult.error();
            }

            pos += VarInt.length(buffer, pos);
            pos += blockedByCount * ;
             (pos > buffer.writerIndex()) {
                ValidationResult.error();
            }
         }

          ((nullBits & ) != ) {
               buffer.getIntLE(offset + );
             (blockingOffset < ) {
                ValidationResult.error();
            }

               offset +  + blockingOffset;
             (pos >= buffer.writerIndex()) {
                ValidationResult.error();
            }

               VarInt.peek(buffer, pos);
             (blockingCount < ) {
                ValidationResult.error();
            }

             (blockingCount > ) {
                ValidationResult.error();
            }

            pos += VarInt.length(buffer, pos);
            pos += blockingCount * ;
             (pos > buffer.writerIndex()) {
                ValidationResult.error();
            }
         }

          ((nullBits & ) != ) {
               buffer.getIntLE(offset + );
             (interruptedByOffset < ) {
                ValidationResult.error();
            }

               offset +  + interruptedByOffset;
             (pos >= buffer.writerIndex()) {
                ValidationResult.error();
            }

               VarInt.peek(buffer, pos);
             (interruptedByCount < ) {
                ValidationResult.error();
            }

             (interruptedByCount > ) {
                ValidationResult.error();
            }

            pos += VarInt.length(buffer, pos);
            pos += interruptedByCount * ;
             (pos > buffer.writerIndex()) {
                ValidationResult.error();
            }
         }

          ((nullBits & ) != ) {
               buffer.getIntLE(offset + );
             (interruptingOffset < ) {
                ValidationResult.error();
            }

               offset +  + interruptingOffset;
             (pos >= buffer.writerIndex()) {
                ValidationResult.error();
            }

               VarInt.peek(buffer, pos);
             (interruptingCount < ) {
                ValidationResult.error();
            }

             (interruptingCount > ) {
                ValidationResult.error();
            }

            pos += VarInt.length(buffer, pos);
            pos += interruptingCount * ;
             (pos > buffer.writerIndex()) {
                ValidationResult.error();
            }
         }

          ValidationResult.OK;
      }
   }

    InteractionRules  {
          ();
      copy.blockedBy = .blockedBy !=  ? (InteractionType[])Arrays.copyOf(.blockedBy, .blockedBy.length) : ;
      copy.blocking = .blocking !=  ? (InteractionType[])Arrays.copyOf(.blocking, .blocking.length) : ;
      copy.interruptedBy = .interruptedBy !=  ? (InteractionType[])Arrays.copyOf(.interruptedBy, .interruptedBy.length) : ;
      copy.interrupting = .interrupting !=  ? (InteractionType[])Arrays.copyOf(.interrupting, .interrupting.length) : ;
      copy.blockedByBypassIndex = .blockedByBypassIndex;
      copy.blockingBypassIndex = .blockingBypassIndex;
      copy.interruptedByBypassIndex = .interruptedByBypassIndex;
      copy.interruptingBypassIndex = .interruptingBypassIndex;
       copy;
   }

      {
       ( == obj) {
          ;
      }   (!(obj  InteractionRules)) {
          ;
      }  {
            (InteractionRules)obj;
          Arrays.equals(.blockedBy, other.blockedBy) && Arrays.equals(.blocking, other.blocking) && Arrays.equals(.interruptedBy, other.interruptedBy) && Arrays.equals(.interrupting, other.interrupting) && .blockedByBypassIndex == other.blockedByBypassIndex && .blockingBypassIndex == other.blockingBypassIndex && .interruptedByBypassIndex == other.interruptedByBypassIndex && .interruptingBypassIndex == other.interruptingBypassIndex;
      }
   }

      {
         ;
      result =  * result + Arrays.hashCode(.blockedBy);
      result =  * result + Arrays.hashCode(.blocking);
      result =  * result + Arrays.hashCode(.interruptedBy);
      result =  * result + Arrays.hashCode(.interrupting);
      result =  * result + Integer.hashCode(.blockedByBypassIndex);
      result =  * result + Integer.hashCode(.blockingBypassIndex);
      result =  * result + Integer.hashCode(.interruptedByBypassIndex);
      result =  * result + Integer.hashCode(.interruptingBypassIndex);
       result;
   }
}