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;
}
}