studiorailgun/Renderer
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

NetArranger no allocation on read block
Some checks failed
studiorailgun/Renderer/pipeline/head There was a failure building this commit
Details

Browse Source
This commit is contained in:
austin 2025-05-26 14:20:53 -04:00
parent ac13a458fd
commit 0d77c4e571
14 changed files with 1664 additions and 2318 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
src/main/java/electrosphere/net/client/ClientNetworking.java
View File

@ -11,13 +11,12 @@ import electrosphere.net.parser.net.message.TypeBytes;
import electrosphere.net.parser.net.message.NetworkMessage.MessageType; import electrosphere.net.parser.net.message.NetworkMessage.MessageType;
import electrosphere.net.parser.net.message.ServerMessage.ServerMessageType; import electrosphere.net.parser.net.message.ServerMessage.ServerMessageType;
import electrosphere.net.parser.net.raw.NetworkParser; import electrosphere.net.parser.net.raw.NetworkParser;
import electrosphere.net.parser.util.ByteStreamUtils;
import io.github.studiorailgun.CircularByteBuffer;
import java.io.IOException; import java.io.IOException;
import java.io.InputStream; import java.io.InputStream;
import java.io.OutputStream; import java.io.OutputStream;
import java.net.Socket; import java.net.Socket;
import java.nio.ByteBuffer;
import java.util.LinkedList; import java.util.LinkedList;
import java.util.List; import java.util.List;
import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeUnit;
@ -178,32 +177,33 @@ public class ClientNetworking implements Runnable {
// //
//register custom message parsers //register custom message parsers
parser.registerCustomParser(TypeBytes.MESSAGE_TYPE_TERRAIN, TypeBytes.TERRAIN_MESSAGE_TYPE_SENDREDUCEDBLOCKDATA, (NetworkMessage message, CircularByteBuffer buff) -> { parser.registerCustomParser(TypeBytes.MESSAGE_TYPE_TERRAIN, TypeBytes.TERRAIN_MESSAGE_TYPE_SENDREDUCEDBLOCKDATA, (NetworkMessage message, ByteBuffer buff) -> {
TerrainMessage castMessage = (TerrainMessage)message; TerrainMessage castMessage = (TerrainMessage)message;
castMessage.setworldX(ByteStreamUtils.popIntFromByteQueue(buff)); //get meta data
castMessage.setworldY(ByteStreamUtils.popIntFromByteQueue(buff)); castMessage.setworldX(buff.getInt());
castMessage.setworldZ(ByteStreamUtils.popIntFromByteQueue(buff)); castMessage.setworldY(buff.getInt());
castMessage.setchunkResolution(ByteStreamUtils.popIntFromByteQueue(buff)); castMessage.setworldZ(buff.getInt());
castMessage.sethomogenousValue(ByteStreamUtils.popIntFromByteQueue(buff)); castMessage.setchunkResolution(buff.getInt());
//strip the byte stream header castMessage.sethomogenousValue(buff.getInt());
ByteStreamUtils.popIntFromByteQueue(buff);
//get main data blob
if(castMessage.gethomogenousValue() == BlockChunkData.NOT_HOMOGENOUS){ if(castMessage.gethomogenousValue() == BlockChunkData.NOT_HOMOGENOUS){
//read types from byte stream //read types from byte stream
short[] types = BlockChunkPool.getShort(); short[] types = BlockChunkPool.getShort();
for(int i = 0; i < BlockChunkData.TOTAL_DATA_WIDTH; i++){ for(int i = 0; i < BlockChunkData.TOTAL_DATA_WIDTH; i++){
types[i] = ByteStreamUtils.popShortFromByteQueue(buff); types[i] = buff.getShort();
} }
//read metadata from byte stream //read metadata from byte stream
short[] metadata = BlockChunkPool.getShort(); short[] metadata = BlockChunkPool.getShort();
for(int i = 0; i < BlockChunkData.TOTAL_DATA_WIDTH; i++){ for(int i = 0; i < BlockChunkData.TOTAL_DATA_WIDTH; i++){
metadata[i] = ByteStreamUtils.popShortFromByteQueue(buff); metadata[i] = buff.getShort();
} }
List<Object> extraData = new LinkedList<Object>(); List<Object> extraData = new LinkedList<Object>();
extraData.add(types); extraData.add(types);
extraData.add(metadata); extraData.add(metadata);
castMessage.setExtraData(extraData); castMessage.setExtraData(extraData);
} else { } else {
buff.read(1); buff.get();
} }
}); });

161
src/main/java/electrosphere/net/parser/net/message/AuthMessage.java
View File

@ -2,11 +2,8 @@ package electrosphere.net.parser.net.message;
import java.io.IOException; import java.io.IOException;
import java.io.OutputStream; import java.io.OutputStream;
import io.github.studiorailgun.CircularByteBuffer; import java.nio.ByteBuffer;
import electrosphere.net.parser.util.ByteStreamUtils; import electrosphere.net.parser.util.ByteStreamUtils;
import java.util.LinkedList;
import java.util.List;
import java.util.Map; import java.util.Map;
import java.util.function.BiConsumer; import java.util.function.BiConsumer;
@ -77,53 +74,15 @@ public class AuthMessage extends NetworkMessage {
this.pass = pass; this.pass = pass;
} }
/**
* Removes the packet header from the buffer
* @param byteBuffer The buffer
*/
static void stripPacketHeader(CircularByteBuffer byteBuffer){
byteBuffer.read(2);
}
/**
* Checks if this message can be parsed (ie are all bytes present)
* @param byteBuffer The buffer
* @param secondByte The second byte, signifying the subtype of the message
* @return true if the message can be parsed, false otherwise
*/
public static boolean canParseMessage(CircularByteBuffer byteBuffer, byte secondByte){
switch(secondByte){
case TypeBytes.AUTH_MESSAGE_TYPE_AUTHREQUEST:
if(byteBuffer.getRemaining() >= TypeBytes.AUTH_MESSAGE_TYPE_AUTHREQUEST_SIZE){
return true;
} else {
return false;
}
case TypeBytes.AUTH_MESSAGE_TYPE_AUTHDETAILS:
return AuthMessage.canParseAuthDetailsMessage(byteBuffer);
case TypeBytes.AUTH_MESSAGE_TYPE_AUTHSUCCESS:
if(byteBuffer.getRemaining() >= TypeBytes.AUTH_MESSAGE_TYPE_AUTHSUCCESS_SIZE){
return true;
} else {
return false;
}
case TypeBytes.AUTH_MESSAGE_TYPE_AUTHFAILURE:
if(byteBuffer.getRemaining() >= TypeBytes.AUTH_MESSAGE_TYPE_AUTHFAILURE_SIZE){
return true;
} else {
return false;
}
}
return false;
}
/** /**
* Parses a message of type AuthRequest * Parses a message of type AuthRequest
*/ */
public static AuthMessage parseAuthRequestMessage(CircularByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,CircularByteBuffer>> customParserMap){ public static AuthMessage parseAuthRequestMessage(ByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,ByteBuffer>> customParserMap){
if(byteBuffer.remaining() < 0){
return null;
}
AuthMessage rVal = (AuthMessage)pool.get(MessageType.AUTH_MESSAGE); AuthMessage rVal = (AuthMessage)pool.get(MessageType.AUTH_MESSAGE);
rVal.messageType = AuthMessageType.AUTHREQUEST; rVal.messageType = AuthMessageType.AUTHREQUEST;
AuthMessage.stripPacketHeader(byteBuffer);
return rVal; return rVal;
} }
@ -135,50 +94,29 @@ public class AuthMessage extends NetworkMessage {
return rVal; return rVal;
} }
/**
* Checks if a message of type AuthDetails can be parsed from the byte stream
*/
public static boolean canParseAuthDetailsMessage(CircularByteBuffer byteBuffer){
int currentStreamLength = byteBuffer.getRemaining();
List<Byte> temporaryByteQueue = new LinkedList<Byte>();
int userSize = 0;
if(currentStreamLength < 6){
return false;
} else {
temporaryByteQueue.add(byteBuffer.peek(2 + 0));
temporaryByteQueue.add(byteBuffer.peek(2 + 1));
temporaryByteQueue.add(byteBuffer.peek(2 + 2));
temporaryByteQueue.add(byteBuffer.peek(2 + 3));
userSize = ByteStreamUtils.popIntFromByteQueue(temporaryByteQueue);
}
if(currentStreamLength < 6 + userSize){
return false;
}
int passSize = 0;
if(currentStreamLength < 10){
return false;
} else {
temporaryByteQueue.add(byteBuffer.peek(6 + userSize + 0));
temporaryByteQueue.add(byteBuffer.peek(6 + userSize + 1));
temporaryByteQueue.add(byteBuffer.peek(6 + userSize + 2));
temporaryByteQueue.add(byteBuffer.peek(6 + userSize + 3));
passSize = ByteStreamUtils.popIntFromByteQueue(temporaryByteQueue);
}
if(currentStreamLength < 10 + userSize + passSize){
return false;
}
return true;
}
/** /**
* Parses a message of type AuthDetails * Parses a message of type AuthDetails
*/ */
public static AuthMessage parseAuthDetailsMessage(CircularByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,CircularByteBuffer>> customParserMap){ public static AuthMessage parseAuthDetailsMessage(ByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,ByteBuffer>> customParserMap){
if(byteBuffer.remaining() < 8){
return null;
}
int lenAccumulator = 0;
int userlen = byteBuffer.getInt();
lenAccumulator = lenAccumulator + userlen;
int passlen = byteBuffer.getInt();
lenAccumulator = lenAccumulator + passlen;
if(byteBuffer.remaining() < 8 + lenAccumulator){
return null;
}
AuthMessage rVal = (AuthMessage)pool.get(MessageType.AUTH_MESSAGE); AuthMessage rVal = (AuthMessage)pool.get(MessageType.AUTH_MESSAGE);
rVal.messageType = AuthMessageType.AUTHDETAILS; rVal.messageType = AuthMessageType.AUTHDETAILS;
AuthMessage.stripPacketHeader(byteBuffer); if(userlen > 0){
rVal.setuser(ByteStreamUtils.popStringFromByteQueue(byteBuffer)); rVal.setuser(ByteStreamUtils.popStringFromByteBuffer(byteBuffer, userlen));
rVal.setpass(ByteStreamUtils.popStringFromByteQueue(byteBuffer)); }
if(passlen > 0){
rVal.setpass(ByteStreamUtils.popStringFromByteBuffer(byteBuffer, passlen));
}
return rVal; return rVal;
} }
@ -195,10 +133,12 @@ public class AuthMessage extends NetworkMessage {
/** /**
* Parses a message of type AuthSuccess * Parses a message of type AuthSuccess
*/ */
public static AuthMessage parseAuthSuccessMessage(CircularByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,CircularByteBuffer>> customParserMap){ public static AuthMessage parseAuthSuccessMessage(ByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,ByteBuffer>> customParserMap){
if(byteBuffer.remaining() < 0){
return null;
}
AuthMessage rVal = (AuthMessage)pool.get(MessageType.AUTH_MESSAGE); AuthMessage rVal = (AuthMessage)pool.get(MessageType.AUTH_MESSAGE);
rVal.messageType = AuthMessageType.AUTHSUCCESS; rVal.messageType = AuthMessageType.AUTHSUCCESS;
AuthMessage.stripPacketHeader(byteBuffer);
return rVal; return rVal;
} }
@ -213,10 +153,12 @@ public class AuthMessage extends NetworkMessage {
/** /**
* Parses a message of type AuthFailure * Parses a message of type AuthFailure
*/ */
public static AuthMessage parseAuthFailureMessage(CircularByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,CircularByteBuffer>> customParserMap){ public static AuthMessage parseAuthFailureMessage(ByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,ByteBuffer>> customParserMap){
if(byteBuffer.remaining() < 0){
return null;
}
AuthMessage rVal = (AuthMessage)pool.get(MessageType.AUTH_MESSAGE); AuthMessage rVal = (AuthMessage)pool.get(MessageType.AUTH_MESSAGE);
rVal.messageType = AuthMessageType.AUTHFAILURE; rVal.messageType = AuthMessageType.AUTHFAILURE;
AuthMessage.stripPacketHeader(byteBuffer);
return rVal; return rVal;
} }
@ -285,28 +227,53 @@ public class AuthMessage extends NetworkMessage {
@Override @Override
public void write(OutputStream stream) throws IOException { public void write(OutputStream stream) throws IOException {
switch(this.messageType){ switch(this.messageType){
case AUTHREQUEST: case AUTHREQUEST: {
//
//message header //message header
stream.write(TypeBytes.MESSAGE_TYPE_AUTH); stream.write(TypeBytes.MESSAGE_TYPE_AUTH);
stream.write(TypeBytes.AUTH_MESSAGE_TYPE_AUTHREQUEST); stream.write(TypeBytes.AUTH_MESSAGE_TYPE_AUTHREQUEST);
break;
case AUTHDETAILS: //
//Write body of packet
} break;
case AUTHDETAILS: {
//
//message header //message header
stream.write(TypeBytes.MESSAGE_TYPE_AUTH); stream.write(TypeBytes.MESSAGE_TYPE_AUTH);
stream.write(TypeBytes.AUTH_MESSAGE_TYPE_AUTHDETAILS); stream.write(TypeBytes.AUTH_MESSAGE_TYPE_AUTHDETAILS);
//
//Write variable length table in packet
ByteStreamUtils.writeInt(stream, user.length());
ByteStreamUtils.writeInt(stream, pass.length());
//
//Write body of packet
ByteStreamUtils.writeString(stream, user); ByteStreamUtils.writeString(stream, user);
ByteStreamUtils.writeString(stream, pass); ByteStreamUtils.writeString(stream, pass);
break; } break;
case AUTHSUCCESS: case AUTHSUCCESS: {
//
//message header //message header
stream.write(TypeBytes.MESSAGE_TYPE_AUTH); stream.write(TypeBytes.MESSAGE_TYPE_AUTH);
stream.write(TypeBytes.AUTH_MESSAGE_TYPE_AUTHSUCCESS); stream.write(TypeBytes.AUTH_MESSAGE_TYPE_AUTHSUCCESS);
break;
case AUTHFAILURE: //
//Write body of packet
} break;
case AUTHFAILURE: {
//
//message header //message header
stream.write(TypeBytes.MESSAGE_TYPE_AUTH); stream.write(TypeBytes.MESSAGE_TYPE_AUTH);
stream.write(TypeBytes.AUTH_MESSAGE_TYPE_AUTHFAILURE); stream.write(TypeBytes.AUTH_MESSAGE_TYPE_AUTHFAILURE);
break;
//
//Write body of packet
} break;
} }
} }

321
src/main/java/electrosphere/net/parser/net/message/CharacterMessage.java
View File

@ -2,11 +2,8 @@ package electrosphere.net.parser.net.message;
import java.io.IOException; import java.io.IOException;
import java.io.OutputStream; import java.io.OutputStream;
import io.github.studiorailgun.CircularByteBuffer; import java.nio.ByteBuffer;
import electrosphere.net.parser.util.ByteStreamUtils; import electrosphere.net.parser.util.ByteStreamUtils;
import java.util.LinkedList;
import java.util.List;
import java.util.Map; import java.util.Map;
import java.util.function.BiConsumer; import java.util.function.BiConsumer;
@ -66,65 +63,15 @@ public class CharacterMessage extends NetworkMessage {
this.data = data; this.data = data;
} }
/**
* Removes the packet header from the buffer
* @param byteBuffer The buffer
*/
static void stripPacketHeader(CircularByteBuffer byteBuffer){
byteBuffer.read(2);
}
/**
* Checks if this message can be parsed (ie are all bytes present)
* @param byteBuffer The buffer
* @param secondByte The second byte, signifying the subtype of the message
* @return true if the message can be parsed, false otherwise
*/
public static boolean canParseMessage(CircularByteBuffer byteBuffer, byte secondByte){
switch(secondByte){
case TypeBytes.CHARACTER_MESSAGE_TYPE_REQUESTCHARACTERLIST:
if(byteBuffer.getRemaining() >= TypeBytes.CHARACTER_MESSAGE_TYPE_REQUESTCHARACTERLIST_SIZE){
return true;
} else {
return false;
}
case TypeBytes.CHARACTER_MESSAGE_TYPE_RESPONSECHARACTERLIST:
return CharacterMessage.canParseResponseCharacterListMessage(byteBuffer);
case TypeBytes.CHARACTER_MESSAGE_TYPE_REQUESTCREATECHARACTER:
return CharacterMessage.canParseRequestCreateCharacterMessage(byteBuffer);
case TypeBytes.CHARACTER_MESSAGE_TYPE_RESPONSECREATECHARACTERSUCCESS:
if(byteBuffer.getRemaining() >= TypeBytes.CHARACTER_MESSAGE_TYPE_RESPONSECREATECHARACTERSUCCESS_SIZE){
return true;
} else {
return false;
}
case TypeBytes.CHARACTER_MESSAGE_TYPE_RESPONSECREATECHARACTERFAILURE:
if(byteBuffer.getRemaining() >= TypeBytes.CHARACTER_MESSAGE_TYPE_RESPONSECREATECHARACTERFAILURE_SIZE){
return true;
} else {
return false;
}
case TypeBytes.CHARACTER_MESSAGE_TYPE_REQUESTSPAWNCHARACTER:
return CharacterMessage.canParseRequestSpawnCharacterMessage(byteBuffer);
case TypeBytes.CHARACTER_MESSAGE_TYPE_RESPONSESPAWNCHARACTER:
return CharacterMessage.canParseResponseSpawnCharacterMessage(byteBuffer);
case TypeBytes.CHARACTER_MESSAGE_TYPE_EDITORSWAP:
if(byteBuffer.getRemaining() >= TypeBytes.CHARACTER_MESSAGE_TYPE_EDITORSWAP_SIZE){
return true;
} else {
return false;
}
}
return false;
}
/** /**
* Parses a message of type RequestCharacterList * Parses a message of type RequestCharacterList
*/ */
public static CharacterMessage parseRequestCharacterListMessage(CircularByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,CircularByteBuffer>> customParserMap){ public static CharacterMessage parseRequestCharacterListMessage(ByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,ByteBuffer>> customParserMap){
if(byteBuffer.remaining() < 0){
return null;
}
CharacterMessage rVal = (CharacterMessage)pool.get(MessageType.CHARACTER_MESSAGE); CharacterMessage rVal = (CharacterMessage)pool.get(MessageType.CHARACTER_MESSAGE);
rVal.messageType = CharacterMessageType.REQUESTCHARACTERLIST; rVal.messageType = CharacterMessageType.REQUESTCHARACTERLIST;
CharacterMessage.stripPacketHeader(byteBuffer);
return rVal; return rVal;
} }
@ -136,36 +83,24 @@ public class CharacterMessage extends NetworkMessage {
return rVal; return rVal;
} }
/**
* Checks if a message of type ResponseCharacterList can be parsed from the byte stream
*/
public static boolean canParseResponseCharacterListMessage(CircularByteBuffer byteBuffer){
int currentStreamLength = byteBuffer.getRemaining();
List<Byte> temporaryByteQueue = new LinkedList<Byte>();
int dataSize = 0;
if(currentStreamLength < 6){
return false;
} else {
temporaryByteQueue.add(byteBuffer.peek(2 + 0));
temporaryByteQueue.add(byteBuffer.peek(2 + 1));
temporaryByteQueue.add(byteBuffer.peek(2 + 2));
temporaryByteQueue.add(byteBuffer.peek(2 + 3));
dataSize = ByteStreamUtils.popIntFromByteQueue(temporaryByteQueue);
}
if(currentStreamLength < 6 + dataSize){
return false;
}
return true;
}
/** /**
* Parses a message of type ResponseCharacterList * Parses a message of type ResponseCharacterList
*/ */
public static CharacterMessage parseResponseCharacterListMessage(CircularByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,CircularByteBuffer>> customParserMap){ public static CharacterMessage parseResponseCharacterListMessage(ByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,ByteBuffer>> customParserMap){
if(byteBuffer.remaining() < 4){
return null;
}
int lenAccumulator = 0;
int datalen = byteBuffer.getInt();
lenAccumulator = lenAccumulator + datalen;
if(byteBuffer.remaining() < 4 + lenAccumulator){
return null;
}
CharacterMessage rVal = (CharacterMessage)pool.get(MessageType.CHARACTER_MESSAGE); CharacterMessage rVal = (CharacterMessage)pool.get(MessageType.CHARACTER_MESSAGE);
rVal.messageType = CharacterMessageType.RESPONSECHARACTERLIST; rVal.messageType = CharacterMessageType.RESPONSECHARACTERLIST;
CharacterMessage.stripPacketHeader(byteBuffer); if(datalen > 0){
rVal.setdata(ByteStreamUtils.popStringFromByteQueue(byteBuffer)); rVal.setdata(ByteStreamUtils.popStringFromByteBuffer(byteBuffer, datalen));
}
return rVal; return rVal;
} }
@ -178,36 +113,24 @@ public class CharacterMessage extends NetworkMessage {
return rVal; return rVal;
} }
/**
* Checks if a message of type RequestCreateCharacter can be parsed from the byte stream
*/
public static boolean canParseRequestCreateCharacterMessage(CircularByteBuffer byteBuffer){
int currentStreamLength = byteBuffer.getRemaining();
List<Byte> temporaryByteQueue = new LinkedList<Byte>();
int dataSize = 0;
if(currentStreamLength < 6){
return false;
} else {
temporaryByteQueue.add(byteBuffer.peek(2 + 0));
temporaryByteQueue.add(byteBuffer.peek(2 + 1));
temporaryByteQueue.add(byteBuffer.peek(2 + 2));
temporaryByteQueue.add(byteBuffer.peek(2 + 3));
dataSize = ByteStreamUtils.popIntFromByteQueue(temporaryByteQueue);
}
if(currentStreamLength < 6 + dataSize){
return false;
}
return true;
}
/** /**
* Parses a message of type RequestCreateCharacter * Parses a message of type RequestCreateCharacter
*/ */
public static CharacterMessage parseRequestCreateCharacterMessage(CircularByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,CircularByteBuffer>> customParserMap){ public static CharacterMessage parseRequestCreateCharacterMessage(ByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,ByteBuffer>> customParserMap){
if(byteBuffer.remaining() < 4){
return null;
}
int lenAccumulator = 0;
int datalen = byteBuffer.getInt();
lenAccumulator = lenAccumulator + datalen;
if(byteBuffer.remaining() < 4 + lenAccumulator){
return null;
}
CharacterMessage rVal = (CharacterMessage)pool.get(MessageType.CHARACTER_MESSAGE); CharacterMessage rVal = (CharacterMessage)pool.get(MessageType.CHARACTER_MESSAGE);
rVal.messageType = CharacterMessageType.REQUESTCREATECHARACTER; rVal.messageType = CharacterMessageType.REQUESTCREATECHARACTER;
CharacterMessage.stripPacketHeader(byteBuffer); if(datalen > 0){
rVal.setdata(ByteStreamUtils.popStringFromByteQueue(byteBuffer)); rVal.setdata(ByteStreamUtils.popStringFromByteBuffer(byteBuffer, datalen));
}
return rVal; return rVal;
} }
@ -223,10 +146,12 @@ public class CharacterMessage extends NetworkMessage {
/** /**
* Parses a message of type ResponseCreateCharacterSuccess * Parses a message of type ResponseCreateCharacterSuccess
*/ */
public static CharacterMessage parseResponseCreateCharacterSuccessMessage(CircularByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,CircularByteBuffer>> customParserMap){ public static CharacterMessage parseResponseCreateCharacterSuccessMessage(ByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,ByteBuffer>> customParserMap){
if(byteBuffer.remaining() < 0){
return null;
}
CharacterMessage rVal = (CharacterMessage)pool.get(MessageType.CHARACTER_MESSAGE); CharacterMessage rVal = (CharacterMessage)pool.get(MessageType.CHARACTER_MESSAGE);
rVal.messageType = CharacterMessageType.RESPONSECREATECHARACTERSUCCESS; rVal.messageType = CharacterMessageType.RESPONSECREATECHARACTERSUCCESS;
CharacterMessage.stripPacketHeader(byteBuffer);
return rVal; return rVal;
} }
@ -241,10 +166,12 @@ public class CharacterMessage extends NetworkMessage {
/** /**
* Parses a message of type ResponseCreateCharacterFailure * Parses a message of type ResponseCreateCharacterFailure
*/ */
public static CharacterMessage parseResponseCreateCharacterFailureMessage(CircularByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,CircularByteBuffer>> customParserMap){ public static CharacterMessage parseResponseCreateCharacterFailureMessage(ByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,ByteBuffer>> customParserMap){
if(byteBuffer.remaining() < 0){
return null;
}
CharacterMessage rVal = (CharacterMessage)pool.get(MessageType.CHARACTER_MESSAGE); CharacterMessage rVal = (CharacterMessage)pool.get(MessageType.CHARACTER_MESSAGE);
rVal.messageType = CharacterMessageType.RESPONSECREATECHARACTERFAILURE; rVal.messageType = CharacterMessageType.RESPONSECREATECHARACTERFAILURE;
CharacterMessage.stripPacketHeader(byteBuffer);
return rVal; return rVal;
} }
@ -256,36 +183,24 @@ public class CharacterMessage extends NetworkMessage {
return rVal; return rVal;
} }
/**
* Checks if a message of type RequestSpawnCharacter can be parsed from the byte stream
*/
public static boolean canParseRequestSpawnCharacterMessage(CircularByteBuffer byteBuffer){
int currentStreamLength = byteBuffer.getRemaining();
List<Byte> temporaryByteQueue = new LinkedList<Byte>();
int dataSize = 0;
if(currentStreamLength < 6){
return false;
} else {
temporaryByteQueue.add(byteBuffer.peek(2 + 0));
temporaryByteQueue.add(byteBuffer.peek(2 + 1));
temporaryByteQueue.add(byteBuffer.peek(2 + 2));
temporaryByteQueue.add(byteBuffer.peek(2 + 3));
dataSize = ByteStreamUtils.popIntFromByteQueue(temporaryByteQueue);
}
if(currentStreamLength < 6 + dataSize){
return false;
}
return true;
}
/** /**
* Parses a message of type RequestSpawnCharacter * Parses a message of type RequestSpawnCharacter
*/ */
public static CharacterMessage parseRequestSpawnCharacterMessage(CircularByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,CircularByteBuffer>> customParserMap){ public static CharacterMessage parseRequestSpawnCharacterMessage(ByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,ByteBuffer>> customParserMap){
if(byteBuffer.remaining() < 4){
return null;
}
int lenAccumulator = 0;
int datalen = byteBuffer.getInt();
lenAccumulator = lenAccumulator + datalen;
if(byteBuffer.remaining() < 4 + lenAccumulator){
return null;
}
CharacterMessage rVal = (CharacterMessage)pool.get(MessageType.CHARACTER_MESSAGE); CharacterMessage rVal = (CharacterMessage)pool.get(MessageType.CHARACTER_MESSAGE);
rVal.messageType = CharacterMessageType.REQUESTSPAWNCHARACTER; rVal.messageType = CharacterMessageType.REQUESTSPAWNCHARACTER;
CharacterMessage.stripPacketHeader(byteBuffer); if(datalen > 0){
rVal.setdata(ByteStreamUtils.popStringFromByteQueue(byteBuffer)); rVal.setdata(ByteStreamUtils.popStringFromByteBuffer(byteBuffer, datalen));
}
return rVal; return rVal;
} }
@ -298,36 +213,24 @@ public class CharacterMessage extends NetworkMessage {
return rVal; return rVal;
} }
/**
* Checks if a message of type ResponseSpawnCharacter can be parsed from the byte stream
*/
public static boolean canParseResponseSpawnCharacterMessage(CircularByteBuffer byteBuffer){
int currentStreamLength = byteBuffer.getRemaining();
List<Byte> temporaryByteQueue = new LinkedList<Byte>();
int dataSize = 0;
if(currentStreamLength < 6){
return false;
} else {
temporaryByteQueue.add(byteBuffer.peek(2 + 0));
temporaryByteQueue.add(byteBuffer.peek(2 + 1));
temporaryByteQueue.add(byteBuffer.peek(2 + 2));
temporaryByteQueue.add(byteBuffer.peek(2 + 3));
dataSize = ByteStreamUtils.popIntFromByteQueue(temporaryByteQueue);
}
if(currentStreamLength < 6 + dataSize){
return false;
}
return true;
}
/** /**
* Parses a message of type ResponseSpawnCharacter * Parses a message of type ResponseSpawnCharacter
*/ */
public static CharacterMessage parseResponseSpawnCharacterMessage(CircularByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,CircularByteBuffer>> customParserMap){ public static CharacterMessage parseResponseSpawnCharacterMessage(ByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,ByteBuffer>> customParserMap){
if(byteBuffer.remaining() < 4){
return null;
}
int lenAccumulator = 0;
int datalen = byteBuffer.getInt();
lenAccumulator = lenAccumulator + datalen;
if(byteBuffer.remaining() < 4 + lenAccumulator){
return null;
}
CharacterMessage rVal = (CharacterMessage)pool.get(MessageType.CHARACTER_MESSAGE); CharacterMessage rVal = (CharacterMessage)pool.get(MessageType.CHARACTER_MESSAGE);
rVal.messageType = CharacterMessageType.RESPONSESPAWNCHARACTER; rVal.messageType = CharacterMessageType.RESPONSESPAWNCHARACTER;
CharacterMessage.stripPacketHeader(byteBuffer); if(datalen > 0){
rVal.setdata(ByteStreamUtils.popStringFromByteQueue(byteBuffer)); rVal.setdata(ByteStreamUtils.popStringFromByteBuffer(byteBuffer, datalen));
}
return rVal; return rVal;
} }
@ -343,10 +246,12 @@ public class CharacterMessage extends NetworkMessage {
/** /**
* Parses a message of type EditorSwap * Parses a message of type EditorSwap
*/ */
public static CharacterMessage parseEditorSwapMessage(CircularByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,CircularByteBuffer>> customParserMap){ public static CharacterMessage parseEditorSwapMessage(ByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,ByteBuffer>> customParserMap){
if(byteBuffer.remaining() < 0){
return null;
}
CharacterMessage rVal = (CharacterMessage)pool.get(MessageType.CHARACTER_MESSAGE); CharacterMessage rVal = (CharacterMessage)pool.get(MessageType.CHARACTER_MESSAGE);
rVal.messageType = CharacterMessageType.EDITORSWAP; rVal.messageType = CharacterMessageType.EDITORSWAP;
CharacterMessage.stripPacketHeader(byteBuffer);
return rVal; return rVal;
} }
@ -459,50 +364,106 @@ public class CharacterMessage extends NetworkMessage {
@Override @Override
public void write(OutputStream stream) throws IOException { public void write(OutputStream stream) throws IOException {
switch(this.messageType){ switch(this.messageType){
case REQUESTCHARACTERLIST: case REQUESTCHARACTERLIST: {
//
//message header //message header
stream.write(TypeBytes.MESSAGE_TYPE_CHARACTER); stream.write(TypeBytes.MESSAGE_TYPE_CHARACTER);
stream.write(TypeBytes.CHARACTER_MESSAGE_TYPE_REQUESTCHARACTERLIST); stream.write(TypeBytes.CHARACTER_MESSAGE_TYPE_REQUESTCHARACTERLIST);
break;
case RESPONSECHARACTERLIST: //
//Write body of packet
} break;
case RESPONSECHARACTERLIST: {
//
//message header //message header
stream.write(TypeBytes.MESSAGE_TYPE_CHARACTER); stream.write(TypeBytes.MESSAGE_TYPE_CHARACTER);
stream.write(TypeBytes.CHARACTER_MESSAGE_TYPE_RESPONSECHARACTERLIST); stream.write(TypeBytes.CHARACTER_MESSAGE_TYPE_RESPONSECHARACTERLIST);
//
//Write variable length table in packet
ByteStreamUtils.writeInt(stream, data.length());
//
//Write body of packet
ByteStreamUtils.writeString(stream, data); ByteStreamUtils.writeString(stream, data);
break; } break;
case REQUESTCREATECHARACTER: case REQUESTCREATECHARACTER: {
//
//message header //message header
stream.write(TypeBytes.MESSAGE_TYPE_CHARACTER); stream.write(TypeBytes.MESSAGE_TYPE_CHARACTER);
stream.write(TypeBytes.CHARACTER_MESSAGE_TYPE_REQUESTCREATECHARACTER); stream.write(TypeBytes.CHARACTER_MESSAGE_TYPE_REQUESTCREATECHARACTER);
//
//Write variable length table in packet
ByteStreamUtils.writeInt(stream, data.length());
//
//Write body of packet
ByteStreamUtils.writeString(stream, data); ByteStreamUtils.writeString(stream, data);
break; } break;
case RESPONSECREATECHARACTERSUCCESS: case RESPONSECREATECHARACTERSUCCESS: {
//
//message header //message header
stream.write(TypeBytes.MESSAGE_TYPE_CHARACTER); stream.write(TypeBytes.MESSAGE_TYPE_CHARACTER);
stream.write(TypeBytes.CHARACTER_MESSAGE_TYPE_RESPONSECREATECHARACTERSUCCESS); stream.write(TypeBytes.CHARACTER_MESSAGE_TYPE_RESPONSECREATECHARACTERSUCCESS);
break;
case RESPONSECREATECHARACTERFAILURE: //
//Write body of packet
} break;
case RESPONSECREATECHARACTERFAILURE: {
//
//message header //message header
stream.write(TypeBytes.MESSAGE_TYPE_CHARACTER); stream.write(TypeBytes.MESSAGE_TYPE_CHARACTER);
stream.write(TypeBytes.CHARACTER_MESSAGE_TYPE_RESPONSECREATECHARACTERFAILURE); stream.write(TypeBytes.CHARACTER_MESSAGE_TYPE_RESPONSECREATECHARACTERFAILURE);
break;
case REQUESTSPAWNCHARACTER: //
//Write body of packet
} break;
case REQUESTSPAWNCHARACTER: {
//
//message header //message header
stream.write(TypeBytes.MESSAGE_TYPE_CHARACTER); stream.write(TypeBytes.MESSAGE_TYPE_CHARACTER);
stream.write(TypeBytes.CHARACTER_MESSAGE_TYPE_REQUESTSPAWNCHARACTER); stream.write(TypeBytes.CHARACTER_MESSAGE_TYPE_REQUESTSPAWNCHARACTER);
//
//Write variable length table in packet
ByteStreamUtils.writeInt(stream, data.length());
//
//Write body of packet
ByteStreamUtils.writeString(stream, data); ByteStreamUtils.writeString(stream, data);
break; } break;
case RESPONSESPAWNCHARACTER: case RESPONSESPAWNCHARACTER: {
//
//message header //message header
stream.write(TypeBytes.MESSAGE_TYPE_CHARACTER); stream.write(TypeBytes.MESSAGE_TYPE_CHARACTER);
stream.write(TypeBytes.CHARACTER_MESSAGE_TYPE_RESPONSESPAWNCHARACTER); stream.write(TypeBytes.CHARACTER_MESSAGE_TYPE_RESPONSESPAWNCHARACTER);
//
//Write variable length table in packet
ByteStreamUtils.writeInt(stream, data.length());
//
//Write body of packet
ByteStreamUtils.writeString(stream, data); ByteStreamUtils.writeString(stream, data);
break; } break;
case EDITORSWAP: case EDITORSWAP: {
//
//message header //message header
stream.write(TypeBytes.MESSAGE_TYPE_CHARACTER); stream.write(TypeBytes.MESSAGE_TYPE_CHARACTER);
stream.write(TypeBytes.CHARACTER_MESSAGE_TYPE_EDITORSWAP); stream.write(TypeBytes.CHARACTER_MESSAGE_TYPE_EDITORSWAP);
break;
//
//Write body of packet
} break;
} }
} }

128
src/main/java/electrosphere/net/parser/net/message/CombatMessage.java
View File

@ -2,11 +2,8 @@ package electrosphere.net.parser.net.message;
import java.io.IOException; import java.io.IOException;
import java.io.OutputStream; import java.io.OutputStream;
import io.github.studiorailgun.CircularByteBuffer; import java.nio.ByteBuffer;
import electrosphere.net.parser.util.ByteStreamUtils; import electrosphere.net.parser.util.ByteStreamUtils;
import java.util.LinkedList;
import java.util.List;
import java.util.Map; import java.util.Map;
import java.util.function.BiConsumer; import java.util.function.BiConsumer;
@ -224,96 +221,35 @@ public class CombatMessage extends NetworkMessage {
this.hurtboxType = hurtboxType; this.hurtboxType = hurtboxType;
} }
/**
* Removes the packet header from the buffer
* @param byteBuffer The buffer
*/
static void stripPacketHeader(CircularByteBuffer byteBuffer){
byteBuffer.read(2);
}
/**
* Checks if this message can be parsed (ie are all bytes present)
* @param byteBuffer The buffer
* @param secondByte The second byte, signifying the subtype of the message
* @return true if the message can be parsed, false otherwise
*/
public static boolean canParseMessage(CircularByteBuffer byteBuffer, byte secondByte){
switch(secondByte){
case TypeBytes.COMBAT_MESSAGE_TYPE_SERVERREPORTHITBOXCOLLISION:
return CombatMessage.canParseserverReportHitboxCollisionMessage(byteBuffer);
}
return false;
}
/**
* Checks if a message of type serverReportHitboxCollision can be parsed from the byte stream
*/
public static boolean canParseserverReportHitboxCollisionMessage(CircularByteBuffer byteBuffer){
int currentStreamLength = byteBuffer.getRemaining();
List<Byte> temporaryByteQueue = new LinkedList<Byte>();
if(currentStreamLength < 6){
return false;
}
if(currentStreamLength < 10){
return false;
}
if(currentStreamLength < 18){
return false;
}
int hitboxTypeSize = 0;
if(currentStreamLength < 22){
return false;
} else {
temporaryByteQueue.add(byteBuffer.peek(18 + 0));
temporaryByteQueue.add(byteBuffer.peek(18 + 1));
temporaryByteQueue.add(byteBuffer.peek(18 + 2));
temporaryByteQueue.add(byteBuffer.peek(18 + 3));
hitboxTypeSize = ByteStreamUtils.popIntFromByteQueue(temporaryByteQueue);
}
if(currentStreamLength < 22 + hitboxTypeSize){
return false;
}
int hurtboxTypeSize = 0;
if(currentStreamLength < 26){
return false;
} else {
temporaryByteQueue.add(byteBuffer.peek(22 + hitboxTypeSize + 0));
temporaryByteQueue.add(byteBuffer.peek(22 + hitboxTypeSize + 1));
temporaryByteQueue.add(byteBuffer.peek(22 + hitboxTypeSize + 2));
temporaryByteQueue.add(byteBuffer.peek(22 + hitboxTypeSize + 3));
hurtboxTypeSize = ByteStreamUtils.popIntFromByteQueue(temporaryByteQueue);
}
if(currentStreamLength < 26 + hitboxTypeSize + hurtboxTypeSize){
return false;
}
if(currentStreamLength < 34 + hitboxTypeSize + hurtboxTypeSize){
return false;
}
if(currentStreamLength < 42 + hitboxTypeSize + hurtboxTypeSize){
return false;
}
if(currentStreamLength < 50 + hitboxTypeSize + hurtboxTypeSize){
return false;
}
return true;
}
/** /**
* Parses a message of type serverReportHitboxCollision * Parses a message of type serverReportHitboxCollision
*/ */
public static CombatMessage parseserverReportHitboxCollisionMessage(CircularByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,CircularByteBuffer>> customParserMap){ public static CombatMessage parseserverReportHitboxCollisionMessage(ByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,ByteBuffer>> customParserMap){
if(byteBuffer.remaining() < 48){
return null;
}
int lenAccumulator = 0;
int hitboxTypelen = byteBuffer.getInt();
lenAccumulator = lenAccumulator + hitboxTypelen;
int hurtboxTypelen = byteBuffer.getInt();
lenAccumulator = lenAccumulator + hurtboxTypelen;
if(byteBuffer.remaining() < 48 + lenAccumulator){
return null;
}
CombatMessage rVal = (CombatMessage)pool.get(MessageType.COMBAT_MESSAGE); CombatMessage rVal = (CombatMessage)pool.get(MessageType.COMBAT_MESSAGE);
rVal.messageType = CombatMessageType.SERVERREPORTHITBOXCOLLISION; rVal.messageType = CombatMessageType.SERVERREPORTHITBOXCOLLISION;
CombatMessage.stripPacketHeader(byteBuffer); rVal.setentityID(byteBuffer.getInt());
rVal.setentityID(ByteStreamUtils.popIntFromByteQueue(byteBuffer)); rVal.setreceiverEntityID(byteBuffer.getInt());
rVal.setreceiverEntityID(ByteStreamUtils.popIntFromByteQueue(byteBuffer)); rVal.settime(byteBuffer.getLong());
rVal.settime(ByteStreamUtils.popLongFromByteQueue(byteBuffer)); if(hitboxTypelen > 0){
rVal.sethitboxType(ByteStreamUtils.popStringFromByteQueue(byteBuffer)); rVal.sethitboxType(ByteStreamUtils.popStringFromByteBuffer(byteBuffer, hitboxTypelen));
rVal.sethurtboxType(ByteStreamUtils.popStringFromByteQueue(byteBuffer)); }
rVal.setpositionX(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer)); if(hurtboxTypelen > 0){
rVal.setpositionY(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer)); rVal.sethurtboxType(ByteStreamUtils.popStringFromByteBuffer(byteBuffer, hurtboxTypelen));
rVal.setpositionZ(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer)); }
rVal.setpositionX(byteBuffer.getDouble());
rVal.setpositionY(byteBuffer.getDouble());
rVal.setpositionZ(byteBuffer.getDouble());
return rVal; return rVal;
} }
@ -393,10 +329,20 @@ public class CombatMessage extends NetworkMessage {
@Override @Override
public void write(OutputStream stream) throws IOException { public void write(OutputStream stream) throws IOException {
switch(this.messageType){ switch(this.messageType){
case SERVERREPORTHITBOXCOLLISION: case SERVERREPORTHITBOXCOLLISION: {
//
//message header //message header
stream.write(TypeBytes.MESSAGE_TYPE_COMBAT); stream.write(TypeBytes.MESSAGE_TYPE_COMBAT);
stream.write(TypeBytes.COMBAT_MESSAGE_TYPE_SERVERREPORTHITBOXCOLLISION); stream.write(TypeBytes.COMBAT_MESSAGE_TYPE_SERVERREPORTHITBOXCOLLISION);
//
//Write variable length table in packet
ByteStreamUtils.writeInt(stream, hitboxType.length());
ByteStreamUtils.writeInt(stream, hurtboxType.length());
//
//Write body of packet
ByteStreamUtils.writeInt(stream, entityID); ByteStreamUtils.writeInt(stream, entityID);
ByteStreamUtils.writeInt(stream, receiverEntityID); ByteStreamUtils.writeInt(stream, receiverEntityID);
ByteStreamUtils.writeLong(stream, time); ByteStreamUtils.writeLong(stream, time);
@ -405,7 +351,7 @@ public class CombatMessage extends NetworkMessage {
ByteStreamUtils.writeDouble(stream, positionX); ByteStreamUtils.writeDouble(stream, positionX);
ByteStreamUtils.writeDouble(stream, positionY); ByteStreamUtils.writeDouble(stream, positionY);
ByteStreamUtils.writeDouble(stream, positionZ); ByteStreamUtils.writeDouble(stream, positionZ);
break; } break;
} }
} }

542
src/main/java/electrosphere/net/parser/net/message/EntityMessage.java
View File

@ -2,11 +2,8 @@ package electrosphere.net.parser.net.message;
import java.io.IOException; import java.io.IOException;
import java.io.OutputStream; import java.io.OutputStream;
import io.github.studiorailgun.CircularByteBuffer; import java.nio.ByteBuffer;
import electrosphere.net.parser.util.ByteStreamUtils; import electrosphere.net.parser.util.ByteStreamUtils;
import java.util.LinkedList;
import java.util.List;
import java.util.Map; import java.util.Map;
import java.util.function.BiConsumer; import java.util.function.BiConsumer;
@ -579,160 +576,38 @@ public class EntityMessage extends NetworkMessage {
this.interactionSignal = interactionSignal; this.interactionSignal = interactionSignal;
} }
/**
* Removes the packet header from the buffer
* @param byteBuffer The buffer
*/
static void stripPacketHeader(CircularByteBuffer byteBuffer){
byteBuffer.read(2);
}
/**
* Checks if this message can be parsed (ie are all bytes present)
* @param byteBuffer The buffer
* @param secondByte The second byte, signifying the subtype of the message
* @return true if the message can be parsed, false otherwise
*/
public static boolean canParseMessage(CircularByteBuffer byteBuffer, byte secondByte){
switch(secondByte){
case TypeBytes.ENTITY_MESSAGE_TYPE_CREATE:
return EntityMessage.canParseCreateMessage(byteBuffer);
case TypeBytes.ENTITY_MESSAGE_TYPE_MOVEUPDATE:
if(byteBuffer.getRemaining() >= TypeBytes.ENTITY_MESSAGE_TYPE_MOVEUPDATE_SIZE){
return true;
} else {
return false;
}
case TypeBytes.ENTITY_MESSAGE_TYPE_ATTACKUPDATE:
if(byteBuffer.getRemaining() >= TypeBytes.ENTITY_MESSAGE_TYPE_ATTACKUPDATE_SIZE){
return true;
} else {
return false;
}
case TypeBytes.ENTITY_MESSAGE_TYPE_STARTATTACK:
if(byteBuffer.getRemaining() >= TypeBytes.ENTITY_MESSAGE_TYPE_STARTATTACK_SIZE){
return true;
} else {
return false;
}
case TypeBytes.ENTITY_MESSAGE_TYPE_KILL:
if(byteBuffer.getRemaining() >= TypeBytes.ENTITY_MESSAGE_TYPE_KILL_SIZE){
return true;
} else {
return false;
}
case TypeBytes.ENTITY_MESSAGE_TYPE_DESTROY:
if(byteBuffer.getRemaining() >= TypeBytes.ENTITY_MESSAGE_TYPE_DESTROY_SIZE){
return true;
} else {
return false;
}
case TypeBytes.ENTITY_MESSAGE_TYPE_SETPROPERTY:
if(byteBuffer.getRemaining() >= TypeBytes.ENTITY_MESSAGE_TYPE_SETPROPERTY_SIZE){
return true;
} else {
return false;
}
case TypeBytes.ENTITY_MESSAGE_TYPE_ATTACHENTITYTOENTITY:
return EntityMessage.canParseattachEntityToEntityMessage(byteBuffer);
case TypeBytes.ENTITY_MESSAGE_TYPE_UPDATEENTITYVIEWDIR:
if(byteBuffer.getRemaining() >= TypeBytes.ENTITY_MESSAGE_TYPE_UPDATEENTITYVIEWDIR_SIZE){
return true;
} else {
return false;
}
case TypeBytes.ENTITY_MESSAGE_TYPE_SYNCPHYSICS:
if(byteBuffer.getRemaining() >= TypeBytes.ENTITY_MESSAGE_TYPE_SYNCPHYSICS_SIZE){
return true;
} else {
return false;
}
case TypeBytes.ENTITY_MESSAGE_TYPE_INTERACT:
return EntityMessage.canParseinteractMessage(byteBuffer);
}
return false;
}
/**
* Checks if a message of type Create can be parsed from the byte stream
*/
public static boolean canParseCreateMessage(CircularByteBuffer byteBuffer){
int currentStreamLength = byteBuffer.getRemaining();
List<Byte> temporaryByteQueue = new LinkedList<Byte>();
if(currentStreamLength < 6){
return false;
}
if(currentStreamLength < 10){
return false;
}
int entitySubtypeSize = 0;
if(currentStreamLength < 14){
return false;
} else {
temporaryByteQueue.add(byteBuffer.peek(10 + 0));
temporaryByteQueue.add(byteBuffer.peek(10 + 1));
temporaryByteQueue.add(byteBuffer.peek(10 + 2));
temporaryByteQueue.add(byteBuffer.peek(10 + 3));
entitySubtypeSize = ByteStreamUtils.popIntFromByteQueue(temporaryByteQueue);
}
if(currentStreamLength < 14 + entitySubtypeSize){
return false;
}
int creatureTemplateSize = 0;
if(currentStreamLength < 18){
return false;
} else {
temporaryByteQueue.add(byteBuffer.peek(14 + entitySubtypeSize + 0));
temporaryByteQueue.add(byteBuffer.peek(14 + entitySubtypeSize + 1));
temporaryByteQueue.add(byteBuffer.peek(14 + entitySubtypeSize + 2));
temporaryByteQueue.add(byteBuffer.peek(14 + entitySubtypeSize + 3));
creatureTemplateSize = ByteStreamUtils.popIntFromByteQueue(temporaryByteQueue);
}
if(currentStreamLength < 18 + entitySubtypeSize + creatureTemplateSize){
return false;
}
if(currentStreamLength < 26 + entitySubtypeSize + creatureTemplateSize){
return false;
}
if(currentStreamLength < 34 + entitySubtypeSize + creatureTemplateSize){
return false;
}
if(currentStreamLength < 42 + entitySubtypeSize + creatureTemplateSize){
return false;
}
if(currentStreamLength < 50 + entitySubtypeSize + creatureTemplateSize){
return false;
}
if(currentStreamLength < 58 + entitySubtypeSize + creatureTemplateSize){
return false;
}
if(currentStreamLength < 66 + entitySubtypeSize + creatureTemplateSize){
return false;
}
if(currentStreamLength < 74 + entitySubtypeSize + creatureTemplateSize){
return false;
}
return true;
}
/** /**
* Parses a message of type Create * Parses a message of type Create
*/ */
public static EntityMessage parseCreateMessage(CircularByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,CircularByteBuffer>> customParserMap){ public static EntityMessage parseCreateMessage(ByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,ByteBuffer>> customParserMap){
if(byteBuffer.remaining() < 72){
return null;
}
int lenAccumulator = 0;
int entitySubtypelen = byteBuffer.getInt();
lenAccumulator = lenAccumulator + entitySubtypelen;
int creatureTemplatelen = byteBuffer.getInt();
lenAccumulator = lenAccumulator + creatureTemplatelen;
if(byteBuffer.remaining() < 72 + lenAccumulator){
return null;
}
EntityMessage rVal = (EntityMessage)pool.get(MessageType.ENTITY_MESSAGE); EntityMessage rVal = (EntityMessage)pool.get(MessageType.ENTITY_MESSAGE);
rVal.messageType = EntityMessageType.CREATE; rVal.messageType = EntityMessageType.CREATE;
EntityMessage.stripPacketHeader(byteBuffer); rVal.setentityID(byteBuffer.getInt());
rVal.setentityID(ByteStreamUtils.popIntFromByteQueue(byteBuffer)); rVal.setentityCategory(byteBuffer.getInt());
rVal.setentityCategory(ByteStreamUtils.popIntFromByteQueue(byteBuffer)); if(entitySubtypelen > 0){
rVal.setentitySubtype(ByteStreamUtils.popStringFromByteQueue(byteBuffer)); rVal.setentitySubtype(ByteStreamUtils.popStringFromByteBuffer(byteBuffer, entitySubtypelen));
rVal.setcreatureTemplate(ByteStreamUtils.popStringFromByteQueue(byteBuffer)); }
rVal.setpositionX(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer)); if(creatureTemplatelen > 0){
rVal.setpositionY(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer)); rVal.setcreatureTemplate(ByteStreamUtils.popStringFromByteBuffer(byteBuffer, creatureTemplatelen));
rVal.setpositionZ(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer)); }
rVal.setrotationX(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer)); rVal.setpositionX(byteBuffer.getDouble());
rVal.setrotationY(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer)); rVal.setpositionY(byteBuffer.getDouble());
rVal.setrotationZ(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer)); rVal.setpositionZ(byteBuffer.getDouble());
rVal.setrotationW(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer)); rVal.setrotationX(byteBuffer.getDouble());
rVal.setrotationY(byteBuffer.getDouble());
rVal.setrotationZ(byteBuffer.getDouble());
rVal.setrotationW(byteBuffer.getDouble());
return rVal; return rVal;
} }
@ -758,22 +633,24 @@ public class EntityMessage extends NetworkMessage {
/** /**
* Parses a message of type moveUpdate * Parses a message of type moveUpdate
*/ */
public static EntityMessage parsemoveUpdateMessage(CircularByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,CircularByteBuffer>> customParserMap){ public static EntityMessage parsemoveUpdateMessage(ByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,ByteBuffer>> customParserMap){
if(byteBuffer.remaining() < 84){
return null;
}
EntityMessage rVal = (EntityMessage)pool.get(MessageType.ENTITY_MESSAGE); EntityMessage rVal = (EntityMessage)pool.get(MessageType.ENTITY_MESSAGE);
rVal.messageType = EntityMessageType.MOVEUPDATE; rVal.messageType = EntityMessageType.MOVEUPDATE;
EntityMessage.stripPacketHeader(byteBuffer); rVal.setentityID(byteBuffer.getInt());
rVal.setentityID(ByteStreamUtils.popIntFromByteQueue(byteBuffer)); rVal.settime(byteBuffer.getLong());
rVal.settime(ByteStreamUtils.popLongFromByteQueue(byteBuffer)); rVal.setpositionX(byteBuffer.getDouble());
rVal.setpositionX(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer)); rVal.setpositionY(byteBuffer.getDouble());
rVal.setpositionY(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer)); rVal.setpositionZ(byteBuffer.getDouble());
rVal.setpositionZ(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer)); rVal.setrotationX(byteBuffer.getDouble());
rVal.setrotationX(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer)); rVal.setrotationY(byteBuffer.getDouble());
rVal.setrotationY(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer)); rVal.setrotationZ(byteBuffer.getDouble());
rVal.setrotationZ(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer)); rVal.setrotationW(byteBuffer.getDouble());
rVal.setrotationW(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer)); rVal.setvelocity(byteBuffer.getDouble());
rVal.setvelocity(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer)); rVal.setpropertyValueInt(byteBuffer.getInt());
rVal.setpropertyValueInt(ByteStreamUtils.popIntFromByteQueue(byteBuffer)); rVal.settreeState(byteBuffer.getInt());
rVal.settreeState(ByteStreamUtils.popIntFromByteQueue(byteBuffer));
return rVal; return rVal;
} }
@ -800,20 +677,22 @@ public class EntityMessage extends NetworkMessage {
/** /**
* Parses a message of type attackUpdate * Parses a message of type attackUpdate
*/ */
public static EntityMessage parseattackUpdateMessage(CircularByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,CircularByteBuffer>> customParserMap){ public static EntityMessage parseattackUpdateMessage(ByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,ByteBuffer>> customParserMap){
if(byteBuffer.remaining() < 72){
return null;
}
EntityMessage rVal = (EntityMessage)pool.get(MessageType.ENTITY_MESSAGE); EntityMessage rVal = (EntityMessage)pool.get(MessageType.ENTITY_MESSAGE);
rVal.messageType = EntityMessageType.ATTACKUPDATE; rVal.messageType = EntityMessageType.ATTACKUPDATE;
EntityMessage.stripPacketHeader(byteBuffer); rVal.setentityID(byteBuffer.getInt());
rVal.setentityID(ByteStreamUtils.popIntFromByteQueue(byteBuffer)); rVal.settime(byteBuffer.getLong());
rVal.settime(ByteStreamUtils.popLongFromByteQueue(byteBuffer)); rVal.setpositionX(byteBuffer.getDouble());
rVal.setpositionX(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer)); rVal.setpositionY(byteBuffer.getDouble());
rVal.setpositionY(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer)); rVal.setpositionZ(byteBuffer.getDouble());
rVal.setpositionZ(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer)); rVal.setrotationX(byteBuffer.getDouble());
rVal.setrotationX(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer)); rVal.setrotationY(byteBuffer.getDouble());
rVal.setrotationY(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer)); rVal.setrotationZ(byteBuffer.getDouble());
rVal.setrotationZ(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer)); rVal.setvelocity(byteBuffer.getDouble());
rVal.setvelocity(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer)); rVal.settreeState(byteBuffer.getInt());
rVal.settreeState(ByteStreamUtils.popIntFromByteQueue(byteBuffer));
return rVal; return rVal;
} }
@ -838,10 +717,12 @@ public class EntityMessage extends NetworkMessage {
/** /**
* Parses a message of type startAttack * Parses a message of type startAttack
*/ */
public static EntityMessage parsestartAttackMessage(CircularByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,CircularByteBuffer>> customParserMap){ public static EntityMessage parsestartAttackMessage(ByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,ByteBuffer>> customParserMap){
if(byteBuffer.remaining() < 0){
return null;
}
EntityMessage rVal = (EntityMessage)pool.get(MessageType.ENTITY_MESSAGE); EntityMessage rVal = (EntityMessage)pool.get(MessageType.ENTITY_MESSAGE);
rVal.messageType = EntityMessageType.STARTATTACK; rVal.messageType = EntityMessageType.STARTATTACK;
EntityMessage.stripPacketHeader(byteBuffer);
return rVal; return rVal;
} }
@ -856,12 +737,14 @@ public class EntityMessage extends NetworkMessage {
/** /**
* Parses a message of type Kill * Parses a message of type Kill
*/ */
public static EntityMessage parseKillMessage(CircularByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,CircularByteBuffer>> customParserMap){ public static EntityMessage parseKillMessage(ByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,ByteBuffer>> customParserMap){
if(byteBuffer.remaining() < 12){
return null;
}
EntityMessage rVal = (EntityMessage)pool.get(MessageType.ENTITY_MESSAGE); EntityMessage rVal = (EntityMessage)pool.get(MessageType.ENTITY_MESSAGE);
rVal.messageType = EntityMessageType.KILL; rVal.messageType = EntityMessageType.KILL;
EntityMessage.stripPacketHeader(byteBuffer); rVal.settime(byteBuffer.getLong());
rVal.settime(ByteStreamUtils.popLongFromByteQueue(byteBuffer)); rVal.setentityID(byteBuffer.getInt());
rVal.setentityID(ByteStreamUtils.popIntFromByteQueue(byteBuffer));
return rVal; return rVal;
} }
@ -878,11 +761,13 @@ public class EntityMessage extends NetworkMessage {
/** /**
* Parses a message of type Destroy * Parses a message of type Destroy
*/ */
public static EntityMessage parseDestroyMessage(CircularByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,CircularByteBuffer>> customParserMap){ public static EntityMessage parseDestroyMessage(ByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,ByteBuffer>> customParserMap){
if(byteBuffer.remaining() < 4){
return null;
}
EntityMessage rVal = (EntityMessage)pool.get(MessageType.ENTITY_MESSAGE); EntityMessage rVal = (EntityMessage)pool.get(MessageType.ENTITY_MESSAGE);
rVal.messageType = EntityMessageType.DESTROY; rVal.messageType = EntityMessageType.DESTROY;
EntityMessage.stripPacketHeader(byteBuffer); rVal.setentityID(byteBuffer.getInt());
rVal.setentityID(ByteStreamUtils.popIntFromByteQueue(byteBuffer));
return rVal; return rVal;
} }
@ -898,14 +783,16 @@ public class EntityMessage extends NetworkMessage {
/** /**
* Parses a message of type setProperty * Parses a message of type setProperty
*/ */
public static EntityMessage parsesetPropertyMessage(CircularByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,CircularByteBuffer>> customParserMap){ public static EntityMessage parsesetPropertyMessage(ByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,ByteBuffer>> customParserMap){
if(byteBuffer.remaining() < 20){
return null;
}
EntityMessage rVal = (EntityMessage)pool.get(MessageType.ENTITY_MESSAGE); EntityMessage rVal = (EntityMessage)pool.get(MessageType.ENTITY_MESSAGE);
rVal.messageType = EntityMessageType.SETPROPERTY; rVal.messageType = EntityMessageType.SETPROPERTY;
EntityMessage.stripPacketHeader(byteBuffer); rVal.setentityID(byteBuffer.getInt());
rVal.setentityID(ByteStreamUtils.popIntFromByteQueue(byteBuffer)); rVal.settime(byteBuffer.getLong());
rVal.settime(ByteStreamUtils.popLongFromByteQueue(byteBuffer)); rVal.setpropertyType(byteBuffer.getInt());
rVal.setpropertyType(ByteStreamUtils.popIntFromByteQueue(byteBuffer)); rVal.setpropertyValue(byteBuffer.getInt());
rVal.setpropertyValue(ByteStreamUtils.popIntFromByteQueue(byteBuffer));
return rVal; return rVal;
} }
@ -921,44 +808,26 @@ public class EntityMessage extends NetworkMessage {
return rVal; return rVal;
} }
/**
* Checks if a message of type attachEntityToEntity can be parsed from the byte stream
*/
public static boolean canParseattachEntityToEntityMessage(CircularByteBuffer byteBuffer){
int currentStreamLength = byteBuffer.getRemaining();
List<Byte> temporaryByteQueue = new LinkedList<Byte>();
if(currentStreamLength < 6){
return false;
}
int boneSize = 0;
if(currentStreamLength < 10){
return false;
} else {
temporaryByteQueue.add(byteBuffer.peek(6 + 0));
temporaryByteQueue.add(byteBuffer.peek(6 + 1));
temporaryByteQueue.add(byteBuffer.peek(6 + 2));
temporaryByteQueue.add(byteBuffer.peek(6 + 3));
boneSize = ByteStreamUtils.popIntFromByteQueue(temporaryByteQueue);
}
if(currentStreamLength < 10 + boneSize){
return false;
}
if(currentStreamLength < 14 + boneSize){
return false;
}
return true;
}
/** /**
* Parses a message of type attachEntityToEntity * Parses a message of type attachEntityToEntity
*/ */
public static EntityMessage parseattachEntityToEntityMessage(CircularByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,CircularByteBuffer>> customParserMap){ public static EntityMessage parseattachEntityToEntityMessage(ByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,ByteBuffer>> customParserMap){
if(byteBuffer.remaining() < 12){
return null;
}
int lenAccumulator = 0;
int bonelen = byteBuffer.getInt();
lenAccumulator = lenAccumulator + bonelen;
if(byteBuffer.remaining() < 12 + lenAccumulator){
return null;
}
EntityMessage rVal = (EntityMessage)pool.get(MessageType.ENTITY_MESSAGE); EntityMessage rVal = (EntityMessage)pool.get(MessageType.ENTITY_MESSAGE);
rVal.messageType = EntityMessageType.ATTACHENTITYTOENTITY; rVal.messageType = EntityMessageType.ATTACHENTITYTOENTITY;
EntityMessage.stripPacketHeader(byteBuffer); rVal.setentityID(byteBuffer.getInt());
rVal.setentityID(ByteStreamUtils.popIntFromByteQueue(byteBuffer)); if(bonelen > 0){
rVal.setbone(ByteStreamUtils.popStringFromByteQueue(byteBuffer)); rVal.setbone(ByteStreamUtils.popStringFromByteBuffer(byteBuffer, bonelen));
rVal.settargetID(ByteStreamUtils.popIntFromByteQueue(byteBuffer)); }
rVal.settargetID(byteBuffer.getInt());
return rVal; return rVal;
} }
@ -976,15 +845,17 @@ public class EntityMessage extends NetworkMessage {
/** /**
* Parses a message of type updateEntityViewDir * Parses a message of type updateEntityViewDir
*/ */
public static EntityMessage parseupdateEntityViewDirMessage(CircularByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,CircularByteBuffer>> customParserMap){ public static EntityMessage parseupdateEntityViewDirMessage(ByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,ByteBuffer>> customParserMap){
if(byteBuffer.remaining() < 32){
return null;
}
EntityMessage rVal = (EntityMessage)pool.get(MessageType.ENTITY_MESSAGE); EntityMessage rVal = (EntityMessage)pool.get(MessageType.ENTITY_MESSAGE);
rVal.messageType = EntityMessageType.UPDATEENTITYVIEWDIR; rVal.messageType = EntityMessageType.UPDATEENTITYVIEWDIR;
EntityMessage.stripPacketHeader(byteBuffer); rVal.setentityID(byteBuffer.getInt());
rVal.setentityID(ByteStreamUtils.popIntFromByteQueue(byteBuffer)); rVal.settime(byteBuffer.getLong());
rVal.settime(ByteStreamUtils.popLongFromByteQueue(byteBuffer)); rVal.setpropertyType(byteBuffer.getInt());
rVal.setpropertyType(ByteStreamUtils.popIntFromByteQueue(byteBuffer)); rVal.setyaw(byteBuffer.getDouble());
rVal.setyaw(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer)); rVal.setpitch(byteBuffer.getDouble());
rVal.setpitch(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer));
return rVal; return rVal;
} }
@ -1004,31 +875,33 @@ public class EntityMessage extends NetworkMessage {
/** /**
* Parses a message of type syncPhysics * Parses a message of type syncPhysics
*/ */
public static EntityMessage parsesyncPhysicsMessage(CircularByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,CircularByteBuffer>> customParserMap){ public static EntityMessage parsesyncPhysicsMessage(ByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,ByteBuffer>> customParserMap){
if(byteBuffer.remaining() < 164){
return null;
}
EntityMessage rVal = (EntityMessage)pool.get(MessageType.ENTITY_MESSAGE); EntityMessage rVal = (EntityMessage)pool.get(MessageType.ENTITY_MESSAGE);
rVal.messageType = EntityMessageType.SYNCPHYSICS; rVal.messageType = EntityMessageType.SYNCPHYSICS;
EntityMessage.stripPacketHeader(byteBuffer); rVal.setentityID(byteBuffer.getInt());
rVal.setentityID(ByteStreamUtils.popIntFromByteQueue(byteBuffer)); rVal.settime(byteBuffer.getLong());
rVal.settime(ByteStreamUtils.popLongFromByteQueue(byteBuffer)); rVal.setpositionX(byteBuffer.getDouble());
rVal.setpositionX(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer)); rVal.setpositionY(byteBuffer.getDouble());
rVal.setpositionY(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer)); rVal.setpositionZ(byteBuffer.getDouble());
rVal.setpositionZ(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer)); rVal.setrotationX(byteBuffer.getDouble());
rVal.setrotationX(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer)); rVal.setrotationY(byteBuffer.getDouble());
rVal.setrotationY(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer)); rVal.setrotationZ(byteBuffer.getDouble());
rVal.setrotationZ(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer)); rVal.setrotationW(byteBuffer.getDouble());
rVal.setrotationW(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer)); rVal.setlinVelX(byteBuffer.getDouble());
rVal.setlinVelX(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer)); rVal.setlinVelY(byteBuffer.getDouble());
rVal.setlinVelY(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer)); rVal.setlinVelZ(byteBuffer.getDouble());
rVal.setlinVelZ(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer)); rVal.setangVelX(byteBuffer.getDouble());
rVal.setangVelX(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer)); rVal.setangVelY(byteBuffer.getDouble());
rVal.setangVelY(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer)); rVal.setangVelZ(byteBuffer.getDouble());
rVal.setangVelZ(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer)); rVal.setlinForceX(byteBuffer.getDouble());
rVal.setlinForceX(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer)); rVal.setlinForceY(byteBuffer.getDouble());
rVal.setlinForceY(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer)); rVal.setlinForceZ(byteBuffer.getDouble());
rVal.setlinForceZ(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer)); rVal.setangForceX(byteBuffer.getDouble());
rVal.setangForceX(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer)); rVal.setangForceY(byteBuffer.getDouble());
rVal.setangForceY(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer)); rVal.setangForceZ(byteBuffer.getDouble());
rVal.setangForceZ(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer));
return rVal; return rVal;
} }
@ -1061,40 +934,25 @@ public class EntityMessage extends NetworkMessage {
return rVal; return rVal;
} }
/**
* Checks if a message of type interact can be parsed from the byte stream
*/
public static boolean canParseinteractMessage(CircularByteBuffer byteBuffer){
int currentStreamLength = byteBuffer.getRemaining();
List<Byte> temporaryByteQueue = new LinkedList<Byte>();
if(currentStreamLength < 6){
return false;
}
int interactionSignalSize = 0;
if(currentStreamLength < 10){
return false;
} else {
temporaryByteQueue.add(byteBuffer.peek(6 + 0));
temporaryByteQueue.add(byteBuffer.peek(6 + 1));
temporaryByteQueue.add(byteBuffer.peek(6 + 2));
temporaryByteQueue.add(byteBuffer.peek(6 + 3));
interactionSignalSize = ByteStreamUtils.popIntFromByteQueue(temporaryByteQueue);
}
if(currentStreamLength < 10 + interactionSignalSize){
return false;
}
return true;
}
/** /**
* Parses a message of type interact * Parses a message of type interact
*/ */
public static EntityMessage parseinteractMessage(CircularByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,CircularByteBuffer>> customParserMap){ public static EntityMessage parseinteractMessage(ByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,ByteBuffer>> customParserMap){
if(byteBuffer.remaining() < 8){
return null;
}
int lenAccumulator = 0;
int interactionSignallen = byteBuffer.getInt();
lenAccumulator = lenAccumulator + interactionSignallen;
if(byteBuffer.remaining() < 8 + lenAccumulator){
return null;
}
EntityMessage rVal = (EntityMessage)pool.get(MessageType.ENTITY_MESSAGE); EntityMessage rVal = (EntityMessage)pool.get(MessageType.ENTITY_MESSAGE);
rVal.messageType = EntityMessageType.INTERACT; rVal.messageType = EntityMessageType.INTERACT;
EntityMessage.stripPacketHeader(byteBuffer); rVal.setentityID(byteBuffer.getInt());
rVal.setentityID(ByteStreamUtils.popIntFromByteQueue(byteBuffer)); if(interactionSignallen > 0){
rVal.setinteractionSignal(ByteStreamUtils.popStringFromByteQueue(byteBuffer)); rVal.setinteractionSignal(ByteStreamUtils.popStringFromByteBuffer(byteBuffer, interactionSignallen));
}
return rVal; return rVal;
} }
@ -1498,10 +1356,20 @@ public class EntityMessage extends NetworkMessage {
@Override @Override
public void write(OutputStream stream) throws IOException { public void write(OutputStream stream) throws IOException {
switch(this.messageType){ switch(this.messageType){
case CREATE: case CREATE: {
//
//message header //message header
stream.write(TypeBytes.MESSAGE_TYPE_ENTITY); stream.write(TypeBytes.MESSAGE_TYPE_ENTITY);
stream.write(TypeBytes.ENTITY_MESSAGE_TYPE_CREATE); stream.write(TypeBytes.ENTITY_MESSAGE_TYPE_CREATE);
//
//Write variable length table in packet
ByteStreamUtils.writeInt(stream, entitySubtype.length());
ByteStreamUtils.writeInt(stream, creatureTemplate.length());
//
//Write body of packet
ByteStreamUtils.writeInt(stream, entityID); ByteStreamUtils.writeInt(stream, entityID);
ByteStreamUtils.writeInt(stream, entityCategory); ByteStreamUtils.writeInt(stream, entityCategory);
ByteStreamUtils.writeString(stream, entitySubtype); ByteStreamUtils.writeString(stream, entitySubtype);
@ -1513,11 +1381,16 @@ public class EntityMessage extends NetworkMessage {
ByteStreamUtils.writeDouble(stream, rotationY); ByteStreamUtils.writeDouble(stream, rotationY);
ByteStreamUtils.writeDouble(stream, rotationZ); ByteStreamUtils.writeDouble(stream, rotationZ);
ByteStreamUtils.writeDouble(stream, rotationW); ByteStreamUtils.writeDouble(stream, rotationW);
break; } break;
case MOVEUPDATE: case MOVEUPDATE: {
//
//message header //message header
stream.write(TypeBytes.MESSAGE_TYPE_ENTITY); stream.write(TypeBytes.MESSAGE_TYPE_ENTITY);
stream.write(TypeBytes.ENTITY_MESSAGE_TYPE_MOVEUPDATE); stream.write(TypeBytes.ENTITY_MESSAGE_TYPE_MOVEUPDATE);
//
//Write body of packet
ByteStreamUtils.writeInt(stream, entityID); ByteStreamUtils.writeInt(stream, entityID);
ByteStreamUtils.writeLong(stream, time); ByteStreamUtils.writeLong(stream, time);
ByteStreamUtils.writeDouble(stream, positionX); ByteStreamUtils.writeDouble(stream, positionX);
@ -1530,11 +1403,16 @@ public class EntityMessage extends NetworkMessage {
ByteStreamUtils.writeDouble(stream, velocity); ByteStreamUtils.writeDouble(stream, velocity);
ByteStreamUtils.writeInt(stream, propertyValueInt); ByteStreamUtils.writeInt(stream, propertyValueInt);
ByteStreamUtils.writeInt(stream, treeState); ByteStreamUtils.writeInt(stream, treeState);
break; } break;
case ATTACKUPDATE: case ATTACKUPDATE: {
//
//message header //message header
stream.write(TypeBytes.MESSAGE_TYPE_ENTITY); stream.write(TypeBytes.MESSAGE_TYPE_ENTITY);
stream.write(TypeBytes.ENTITY_MESSAGE_TYPE_ATTACKUPDATE); stream.write(TypeBytes.ENTITY_MESSAGE_TYPE_ATTACKUPDATE);
//
//Write body of packet
ByteStreamUtils.writeInt(stream, entityID); ByteStreamUtils.writeInt(stream, entityID);
ByteStreamUtils.writeLong(stream, time); ByteStreamUtils.writeLong(stream, time);
ByteStreamUtils.writeDouble(stream, positionX); ByteStreamUtils.writeDouble(stream, positionX);
@ -1545,56 +1423,95 @@ public class EntityMessage extends NetworkMessage {
ByteStreamUtils.writeDouble(stream, rotationZ); ByteStreamUtils.writeDouble(stream, rotationZ);
ByteStreamUtils.writeDouble(stream, velocity); ByteStreamUtils.writeDouble(stream, velocity);
ByteStreamUtils.writeInt(stream, treeState); ByteStreamUtils.writeInt(stream, treeState);
break; } break;
case STARTATTACK: case STARTATTACK: {
//
//message header //message header
stream.write(TypeBytes.MESSAGE_TYPE_ENTITY); stream.write(TypeBytes.MESSAGE_TYPE_ENTITY);
stream.write(TypeBytes.ENTITY_MESSAGE_TYPE_STARTATTACK); stream.write(TypeBytes.ENTITY_MESSAGE_TYPE_STARTATTACK);
break;
case KILL: //
//Write body of packet
} break;
case KILL: {
//
//message header //message header
stream.write(TypeBytes.MESSAGE_TYPE_ENTITY); stream.write(TypeBytes.MESSAGE_TYPE_ENTITY);
stream.write(TypeBytes.ENTITY_MESSAGE_TYPE_KILL); stream.write(TypeBytes.ENTITY_MESSAGE_TYPE_KILL);
//
//Write body of packet
ByteStreamUtils.writeLong(stream, time); ByteStreamUtils.writeLong(stream, time);
ByteStreamUtils.writeInt(stream, entityID); ByteStreamUtils.writeInt(stream, entityID);
break; } break;
case DESTROY: case DESTROY: {
//
//message header //message header
stream.write(TypeBytes.MESSAGE_TYPE_ENTITY); stream.write(TypeBytes.MESSAGE_TYPE_ENTITY);
stream.write(TypeBytes.ENTITY_MESSAGE_TYPE_DESTROY); stream.write(TypeBytes.ENTITY_MESSAGE_TYPE_DESTROY);
//
//Write body of packet
ByteStreamUtils.writeInt(stream, entityID); ByteStreamUtils.writeInt(stream, entityID);
break; } break;
case SETPROPERTY: case SETPROPERTY: {
//
//message header //message header
stream.write(TypeBytes.MESSAGE_TYPE_ENTITY); stream.write(TypeBytes.MESSAGE_TYPE_ENTITY);
stream.write(TypeBytes.ENTITY_MESSAGE_TYPE_SETPROPERTY); stream.write(TypeBytes.ENTITY_MESSAGE_TYPE_SETPROPERTY);
//
//Write body of packet
ByteStreamUtils.writeInt(stream, entityID); ByteStreamUtils.writeInt(stream, entityID);
ByteStreamUtils.writeLong(stream, time); ByteStreamUtils.writeLong(stream, time);
ByteStreamUtils.writeInt(stream, propertyType); ByteStreamUtils.writeInt(stream, propertyType);
ByteStreamUtils.writeInt(stream, propertyValue); ByteStreamUtils.writeInt(stream, propertyValue);
break; } break;
case ATTACHENTITYTOENTITY: case ATTACHENTITYTOENTITY: {
//
//message header //message header
stream.write(TypeBytes.MESSAGE_TYPE_ENTITY); stream.write(TypeBytes.MESSAGE_TYPE_ENTITY);
stream.write(TypeBytes.ENTITY_MESSAGE_TYPE_ATTACHENTITYTOENTITY); stream.write(TypeBytes.ENTITY_MESSAGE_TYPE_ATTACHENTITYTOENTITY);
//
//Write variable length table in packet
ByteStreamUtils.writeInt(stream, bone.length());
//
//Write body of packet
ByteStreamUtils.writeInt(stream, entityID); ByteStreamUtils.writeInt(stream, entityID);
ByteStreamUtils.writeString(stream, bone); ByteStreamUtils.writeString(stream, bone);
ByteStreamUtils.writeInt(stream, targetID); ByteStreamUtils.writeInt(stream, targetID);
break; } break;
case UPDATEENTITYVIEWDIR: case UPDATEENTITYVIEWDIR: {
//
//message header //message header
stream.write(TypeBytes.MESSAGE_TYPE_ENTITY); stream.write(TypeBytes.MESSAGE_TYPE_ENTITY);
stream.write(TypeBytes.ENTITY_MESSAGE_TYPE_UPDATEENTITYVIEWDIR); stream.write(TypeBytes.ENTITY_MESSAGE_TYPE_UPDATEENTITYVIEWDIR);
//
//Write body of packet
ByteStreamUtils.writeInt(stream, entityID); ByteStreamUtils.writeInt(stream, entityID);
ByteStreamUtils.writeLong(stream, time); ByteStreamUtils.writeLong(stream, time);
ByteStreamUtils.writeInt(stream, propertyType); ByteStreamUtils.writeInt(stream, propertyType);
ByteStreamUtils.writeDouble(stream, yaw); ByteStreamUtils.writeDouble(stream, yaw);
ByteStreamUtils.writeDouble(stream, pitch); ByteStreamUtils.writeDouble(stream, pitch);
break; } break;
case SYNCPHYSICS: case SYNCPHYSICS: {
//
//message header //message header
stream.write(TypeBytes.MESSAGE_TYPE_ENTITY); stream.write(TypeBytes.MESSAGE_TYPE_ENTITY);
stream.write(TypeBytes.ENTITY_MESSAGE_TYPE_SYNCPHYSICS); stream.write(TypeBytes.ENTITY_MESSAGE_TYPE_SYNCPHYSICS);
//
//Write body of packet
ByteStreamUtils.writeInt(stream, entityID); ByteStreamUtils.writeInt(stream, entityID);
ByteStreamUtils.writeLong(stream, time); ByteStreamUtils.writeLong(stream, time);
ByteStreamUtils.writeDouble(stream, positionX); ByteStreamUtils.writeDouble(stream, positionX);
@ -1616,14 +1533,23 @@ public class EntityMessage extends NetworkMessage {
ByteStreamUtils.writeDouble(stream, angForceX); ByteStreamUtils.writeDouble(stream, angForceX);
ByteStreamUtils.writeDouble(stream, angForceY); ByteStreamUtils.writeDouble(stream, angForceY);
ByteStreamUtils.writeDouble(stream, angForceZ); ByteStreamUtils.writeDouble(stream, angForceZ);
break; } break;
case INTERACT: case INTERACT: {
//
//message header //message header
stream.write(TypeBytes.MESSAGE_TYPE_ENTITY); stream.write(TypeBytes.MESSAGE_TYPE_ENTITY);
stream.write(TypeBytes.ENTITY_MESSAGE_TYPE_INTERACT); stream.write(TypeBytes.ENTITY_MESSAGE_TYPE_INTERACT);
//
//Write variable length table in packet
ByteStreamUtils.writeInt(stream, interactionSignal.length());
//
//Write body of packet
ByteStreamUtils.writeInt(stream, entityID); ByteStreamUtils.writeInt(stream, entityID);
ByteStreamUtils.writeString(stream, interactionSignal); ByteStreamUtils.writeString(stream, interactionSignal);
break; } break;
} }
} }

839
src/main/java/electrosphere/net/parser/net/message/InventoryMessage.java
View File

File diff suppressed because it is too large Load Diff

99
src/main/java/electrosphere/net/parser/net/message/LoreMessage.java
View File

@ -2,11 +2,8 @@ package electrosphere.net.parser.net.message;
import java.io.IOException; import java.io.IOException;
import java.io.OutputStream; import java.io.OutputStream;
import io.github.studiorailgun.CircularByteBuffer; import java.nio.ByteBuffer;
import electrosphere.net.parser.util.ByteStreamUtils; import electrosphere.net.parser.util.ByteStreamUtils;
import java.util.LinkedList;
import java.util.List;
import java.util.Map; import java.util.Map;
import java.util.function.BiConsumer; import java.util.function.BiConsumer;
@ -60,41 +57,15 @@ public class LoreMessage extends NetworkMessage {
this.data = data; this.data = data;
} }
/**
* Removes the packet header from the buffer
* @param byteBuffer The buffer
*/
static void stripPacketHeader(CircularByteBuffer byteBuffer){
byteBuffer.read(2);
}
/**
* Checks if this message can be parsed (ie are all bytes present)
* @param byteBuffer The buffer
* @param secondByte The second byte, signifying the subtype of the message
* @return true if the message can be parsed, false otherwise
*/
public static boolean canParseMessage(CircularByteBuffer byteBuffer, byte secondByte){
switch(secondByte){
case TypeBytes.LORE_MESSAGE_TYPE_REQUESTRACES:
if(byteBuffer.getRemaining() >= TypeBytes.LORE_MESSAGE_TYPE_REQUESTRACES_SIZE){
return true;
} else {
return false;
}
case TypeBytes.LORE_MESSAGE_TYPE_RESPONSERACES:
return LoreMessage.canParseResponseRacesMessage(byteBuffer);
}
return false;
}
/** /**
* Parses a message of type RequestRaces * Parses a message of type RequestRaces
*/ */
public static LoreMessage parseRequestRacesMessage(CircularByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,CircularByteBuffer>> customParserMap){ public static LoreMessage parseRequestRacesMessage(ByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,ByteBuffer>> customParserMap){
if(byteBuffer.remaining() < 0){
return null;
}
LoreMessage rVal = (LoreMessage)pool.get(MessageType.LORE_MESSAGE); LoreMessage rVal = (LoreMessage)pool.get(MessageType.LORE_MESSAGE);
rVal.messageType = LoreMessageType.REQUESTRACES; rVal.messageType = LoreMessageType.REQUESTRACES;
LoreMessage.stripPacketHeader(byteBuffer);
return rVal; return rVal;
} }
@ -106,36 +77,24 @@ public class LoreMessage extends NetworkMessage {
return rVal; return rVal;
} }
/**
* Checks if a message of type ResponseRaces can be parsed from the byte stream
*/
public static boolean canParseResponseRacesMessage(CircularByteBuffer byteBuffer){
int currentStreamLength = byteBuffer.getRemaining();
List<Byte> temporaryByteQueue = new LinkedList<Byte>();
int dataSize = 0;
if(currentStreamLength < 6){
return false;
} else {
temporaryByteQueue.add(byteBuffer.peek(2 + 0));
temporaryByteQueue.add(byteBuffer.peek(2 + 1));
temporaryByteQueue.add(byteBuffer.peek(2 + 2));
temporaryByteQueue.add(byteBuffer.peek(2 + 3));
dataSize = ByteStreamUtils.popIntFromByteQueue(temporaryByteQueue);
}
if(currentStreamLength < 6 + dataSize){
return false;
}
return true;
}
/** /**
* Parses a message of type ResponseRaces * Parses a message of type ResponseRaces
*/ */
public static LoreMessage parseResponseRacesMessage(CircularByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,CircularByteBuffer>> customParserMap){ public static LoreMessage parseResponseRacesMessage(ByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,ByteBuffer>> customParserMap){
if(byteBuffer.remaining() < 4){
return null;
}
int lenAccumulator = 0;
int datalen = byteBuffer.getInt();
lenAccumulator = lenAccumulator + datalen;
if(byteBuffer.remaining() < 4 + lenAccumulator){
return null;
}
LoreMessage rVal = (LoreMessage)pool.get(MessageType.LORE_MESSAGE); LoreMessage rVal = (LoreMessage)pool.get(MessageType.LORE_MESSAGE);
rVal.messageType = LoreMessageType.RESPONSERACES; rVal.messageType = LoreMessageType.RESPONSERACES;
LoreMessage.stripPacketHeader(byteBuffer); if(datalen > 0){
rVal.setdata(ByteStreamUtils.popStringFromByteQueue(byteBuffer)); rVal.setdata(ByteStreamUtils.popStringFromByteBuffer(byteBuffer, datalen));
}
return rVal; return rVal;
} }
@ -183,17 +142,31 @@ public class LoreMessage extends NetworkMessage {
@Override @Override
public void write(OutputStream stream) throws IOException { public void write(OutputStream stream) throws IOException {
switch(this.messageType){ switch(this.messageType){
case REQUESTRACES: case REQUESTRACES: {
//
//message header //message header
stream.write(TypeBytes.MESSAGE_TYPE_LORE); stream.write(TypeBytes.MESSAGE_TYPE_LORE);
stream.write(TypeBytes.LORE_MESSAGE_TYPE_REQUESTRACES); stream.write(TypeBytes.LORE_MESSAGE_TYPE_REQUESTRACES);
break;
case RESPONSERACES: //
//Write body of packet
} break;
case RESPONSERACES: {
//
//message header //message header
stream.write(TypeBytes.MESSAGE_TYPE_LORE); stream.write(TypeBytes.MESSAGE_TYPE_LORE);
stream.write(TypeBytes.LORE_MESSAGE_TYPE_RESPONSERACES); stream.write(TypeBytes.LORE_MESSAGE_TYPE_RESPONSERACES);
//
//Write variable length table in packet
ByteStreamUtils.writeInt(stream, data.length());
//
//Write body of packet
ByteStreamUtils.writeString(stream, data); ByteStreamUtils.writeString(stream, data);
break; } break;
} }
} }

190
src/main/java/electrosphere/net/parser/net/message/NetworkMessage.java
View File

@ -1,9 +1,8 @@
package electrosphere.net.parser.net.message; package electrosphere.net.parser.net.message;
import io.github.studiorailgun.CircularByteBuffer;
import java.io.IOException; import java.io.IOException;
import java.io.OutputStream; import java.io.OutputStream;
import java.nio.ByteBuffer;
import java.util.Map; import java.util.Map;
import java.util.List; import java.util.List;
import java.util.function.BiConsumer; import java.util.function.BiConsumer;
@ -72,454 +71,303 @@ public abstract class NetworkMessage {
* @param customParserMap The map of message type/subtype to parser * @param customParserMap The map of message type/subtype to parser
* @return The message if one is at the front of the byte stream, null otherwise * @return The message if one is at the front of the byte stream, null otherwise
*/ */
public static NetworkMessage parseBytestreamForMessage(CircularByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,CircularByteBuffer>> customParserMap){ public static NetworkMessage parseBytestreamForMessage(ByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,ByteBuffer>> customParserMap){
NetworkMessage rVal = null; NetworkMessage rVal = null;
byte firstByte; byte firstByte;
byte secondByte; byte secondByte;
if(byteBuffer.getRemaining() > 1){ int initialPosition = byteBuffer.position();
firstByte = byteBuffer.peek(); if(byteBuffer.remaining() >= 2){
firstByte = byteBuffer.get();
switch(firstByte){ switch(firstByte){
case TypeBytes.MESSAGE_TYPE_ENTITY: case TypeBytes.MESSAGE_TYPE_ENTITY:
secondByte = byteBuffer.peek(1); secondByte = byteBuffer.get();
switch(secondByte){ switch(secondByte){
case TypeBytes.ENTITY_MESSAGE_TYPE_CREATE: case TypeBytes.ENTITY_MESSAGE_TYPE_CREATE:
if(EntityMessage.canParseMessage(byteBuffer,secondByte)){
rVal = EntityMessage.parseCreateMessage(byteBuffer,pool,customParserMap); rVal = EntityMessage.parseCreateMessage(byteBuffer,pool,customParserMap);
}
break; break;
case TypeBytes.ENTITY_MESSAGE_TYPE_MOVEUPDATE: case TypeBytes.ENTITY_MESSAGE_TYPE_MOVEUPDATE:
if(EntityMessage.canParseMessage(byteBuffer,secondByte)){
rVal = EntityMessage.parsemoveUpdateMessage(byteBuffer,pool,customParserMap); rVal = EntityMessage.parsemoveUpdateMessage(byteBuffer,pool,customParserMap);
}
break; break;
case TypeBytes.ENTITY_MESSAGE_TYPE_ATTACKUPDATE: case TypeBytes.ENTITY_MESSAGE_TYPE_ATTACKUPDATE:
if(EntityMessage.canParseMessage(byteBuffer,secondByte)){
rVal = EntityMessage.parseattackUpdateMessage(byteBuffer,pool,customParserMap); rVal = EntityMessage.parseattackUpdateMessage(byteBuffer,pool,customParserMap);
}
break; break;
case TypeBytes.ENTITY_MESSAGE_TYPE_STARTATTACK: case TypeBytes.ENTITY_MESSAGE_TYPE_STARTATTACK:
if(EntityMessage.canParseMessage(byteBuffer,secondByte)){
rVal = EntityMessage.parsestartAttackMessage(byteBuffer,pool,customParserMap); rVal = EntityMessage.parsestartAttackMessage(byteBuffer,pool,customParserMap);
}
break; break;
case TypeBytes.ENTITY_MESSAGE_TYPE_KILL: case TypeBytes.ENTITY_MESSAGE_TYPE_KILL:
if(EntityMessage.canParseMessage(byteBuffer,secondByte)){
rVal = EntityMessage.parseKillMessage(byteBuffer,pool,customParserMap); rVal = EntityMessage.parseKillMessage(byteBuffer,pool,customParserMap);
}
break; break;
case TypeBytes.ENTITY_MESSAGE_TYPE_DESTROY: case TypeBytes.ENTITY_MESSAGE_TYPE_DESTROY:
if(EntityMessage.canParseMessage(byteBuffer,secondByte)){
rVal = EntityMessage.parseDestroyMessage(byteBuffer,pool,customParserMap); rVal = EntityMessage.parseDestroyMessage(byteBuffer,pool,customParserMap);
}
break; break;
case TypeBytes.ENTITY_MESSAGE_TYPE_SETPROPERTY: case TypeBytes.ENTITY_MESSAGE_TYPE_SETPROPERTY:
if(EntityMessage.canParseMessage(byteBuffer,secondByte)){
rVal = EntityMessage.parsesetPropertyMessage(byteBuffer,pool,customParserMap); rVal = EntityMessage.parsesetPropertyMessage(byteBuffer,pool,customParserMap);
}
break; break;
case TypeBytes.ENTITY_MESSAGE_TYPE_ATTACHENTITYTOENTITY: case TypeBytes.ENTITY_MESSAGE_TYPE_ATTACHENTITYTOENTITY:
if(EntityMessage.canParseMessage(byteBuffer,secondByte)){
rVal = EntityMessage.parseattachEntityToEntityMessage(byteBuffer,pool,customParserMap); rVal = EntityMessage.parseattachEntityToEntityMessage(byteBuffer,pool,customParserMap);
}
break; break;
case TypeBytes.ENTITY_MESSAGE_TYPE_UPDATEENTITYVIEWDIR: case TypeBytes.ENTITY_MESSAGE_TYPE_UPDATEENTITYVIEWDIR:
if(EntityMessage.canParseMessage(byteBuffer,secondByte)){
rVal = EntityMessage.parseupdateEntityViewDirMessage(byteBuffer,pool,customParserMap); rVal = EntityMessage.parseupdateEntityViewDirMessage(byteBuffer,pool,customParserMap);
}
break; break;
case TypeBytes.ENTITY_MESSAGE_TYPE_SYNCPHYSICS: case TypeBytes.ENTITY_MESSAGE_TYPE_SYNCPHYSICS:
if(EntityMessage.canParseMessage(byteBuffer,secondByte)){
rVal = EntityMessage.parsesyncPhysicsMessage(byteBuffer,pool,customParserMap); rVal = EntityMessage.parsesyncPhysicsMessage(byteBuffer,pool,customParserMap);
}
break; break;
case TypeBytes.ENTITY_MESSAGE_TYPE_INTERACT: case TypeBytes.ENTITY_MESSAGE_TYPE_INTERACT:
if(EntityMessage.canParseMessage(byteBuffer,secondByte)){
rVal = EntityMessage.parseinteractMessage(byteBuffer,pool,customParserMap); rVal = EntityMessage.parseinteractMessage(byteBuffer,pool,customParserMap);
}
break; break;
} }
break; break;
case TypeBytes.MESSAGE_TYPE_LORE: case TypeBytes.MESSAGE_TYPE_LORE:
secondByte = byteBuffer.peek(1); secondByte = byteBuffer.get();
switch(secondByte){ switch(secondByte){
case TypeBytes.LORE_MESSAGE_TYPE_REQUESTRACES: case TypeBytes.LORE_MESSAGE_TYPE_REQUESTRACES:
if(LoreMessage.canParseMessage(byteBuffer,secondByte)){
rVal = LoreMessage.parseRequestRacesMessage(byteBuffer,pool,customParserMap); rVal = LoreMessage.parseRequestRacesMessage(byteBuffer,pool,customParserMap);
}
break; break;
case TypeBytes.LORE_MESSAGE_TYPE_RESPONSERACES: case TypeBytes.LORE_MESSAGE_TYPE_RESPONSERACES:
if(LoreMessage.canParseMessage(byteBuffer,secondByte)){
rVal = LoreMessage.parseResponseRacesMessage(byteBuffer,pool,customParserMap); rVal = LoreMessage.parseResponseRacesMessage(byteBuffer,pool,customParserMap);
}
break; break;
} }
break; break;
case TypeBytes.MESSAGE_TYPE_PLAYER: case TypeBytes.MESSAGE_TYPE_PLAYER:
secondByte = byteBuffer.peek(1); secondByte = byteBuffer.get();
switch(secondByte){ switch(secondByte){
case TypeBytes.PLAYER_MESSAGE_TYPE_SET_ID: case TypeBytes.PLAYER_MESSAGE_TYPE_SET_ID:
if(PlayerMessage.canParseMessage(byteBuffer,secondByte)){
rVal = PlayerMessage.parseSet_IDMessage(byteBuffer,pool,customParserMap); rVal = PlayerMessage.parseSet_IDMessage(byteBuffer,pool,customParserMap);
}
break; break;
case TypeBytes.PLAYER_MESSAGE_TYPE_SETINITIALDISCRETEPOSITION: case TypeBytes.PLAYER_MESSAGE_TYPE_SETINITIALDISCRETEPOSITION:
if(PlayerMessage.canParseMessage(byteBuffer,secondByte)){
rVal = PlayerMessage.parseSetInitialDiscretePositionMessage(byteBuffer,pool,customParserMap); rVal = PlayerMessage.parseSetInitialDiscretePositionMessage(byteBuffer,pool,customParserMap);
}
break; break;
} }
break; break;
case TypeBytes.MESSAGE_TYPE_TERRAIN: case TypeBytes.MESSAGE_TYPE_TERRAIN:
secondByte = byteBuffer.peek(1); secondByte = byteBuffer.get();
switch(secondByte){ switch(secondByte){
case TypeBytes.TERRAIN_MESSAGE_TYPE_REQUESTMETADATA: case TypeBytes.TERRAIN_MESSAGE_TYPE_REQUESTMETADATA:
if(TerrainMessage.canParseMessage(byteBuffer,secondByte)){
rVal = TerrainMessage.parseRequestMetadataMessage(byteBuffer,pool,customParserMap); rVal = TerrainMessage.parseRequestMetadataMessage(byteBuffer,pool,customParserMap);
}
break; break;
case TypeBytes.TERRAIN_MESSAGE_TYPE_RESPONSEMETADATA: case TypeBytes.TERRAIN_MESSAGE_TYPE_RESPONSEMETADATA:
if(TerrainMessage.canParseMessage(byteBuffer,secondByte)){
rVal = TerrainMessage.parseResponseMetadataMessage(byteBuffer,pool,customParserMap); rVal = TerrainMessage.parseResponseMetadataMessage(byteBuffer,pool,customParserMap);
}
break; break;
case TypeBytes.TERRAIN_MESSAGE_TYPE_REQUESTEDITVOXEL: case TypeBytes.TERRAIN_MESSAGE_TYPE_REQUESTEDITVOXEL:
if(TerrainMessage.canParseMessage(byteBuffer,secondByte)){
rVal = TerrainMessage.parseRequestEditVoxelMessage(byteBuffer,pool,customParserMap); rVal = TerrainMessage.parseRequestEditVoxelMessage(byteBuffer,pool,customParserMap);
}
break; break;
case TypeBytes.TERRAIN_MESSAGE_TYPE_UPDATEVOXEL: case TypeBytes.TERRAIN_MESSAGE_TYPE_UPDATEVOXEL:
if(TerrainMessage.canParseMessage(byteBuffer,secondByte)){
rVal = TerrainMessage.parseUpdateVoxelMessage(byteBuffer,pool,customParserMap); rVal = TerrainMessage.parseUpdateVoxelMessage(byteBuffer,pool,customParserMap);
}
break; break;
case TypeBytes.TERRAIN_MESSAGE_TYPE_REQUESTUSETERRAINPALETTE: case TypeBytes.TERRAIN_MESSAGE_TYPE_REQUESTUSETERRAINPALETTE:
if(TerrainMessage.canParseMessage(byteBuffer,secondByte)){
rVal = TerrainMessage.parseRequestUseTerrainPaletteMessage(byteBuffer,pool,customParserMap); rVal = TerrainMessage.parseRequestUseTerrainPaletteMessage(byteBuffer,pool,customParserMap);
}
break; break;
case TypeBytes.TERRAIN_MESSAGE_TYPE_REQUESTDESTROYTERRAIN: case TypeBytes.TERRAIN_MESSAGE_TYPE_REQUESTDESTROYTERRAIN:
if(TerrainMessage.canParseMessage(byteBuffer,secondByte)){
rVal = TerrainMessage.parseRequestDestroyTerrainMessage(byteBuffer,pool,customParserMap); rVal = TerrainMessage.parseRequestDestroyTerrainMessage(byteBuffer,pool,customParserMap);
}
break; break;
case TypeBytes.TERRAIN_MESSAGE_TYPE_SPAWNPOSITION: case TypeBytes.TERRAIN_MESSAGE_TYPE_SPAWNPOSITION:
if(TerrainMessage.canParseMessage(byteBuffer,secondByte)){
rVal = TerrainMessage.parseSpawnPositionMessage(byteBuffer,pool,customParserMap); rVal = TerrainMessage.parseSpawnPositionMessage(byteBuffer,pool,customParserMap);
}
break; break;
case TypeBytes.TERRAIN_MESSAGE_TYPE_REQUESTCHUNKDATA: case TypeBytes.TERRAIN_MESSAGE_TYPE_REQUESTCHUNKDATA:
if(TerrainMessage.canParseMessage(byteBuffer,secondByte)){
rVal = TerrainMessage.parseRequestChunkDataMessage(byteBuffer,pool,customParserMap); rVal = TerrainMessage.parseRequestChunkDataMessage(byteBuffer,pool,customParserMap);
}
break; break;
case TypeBytes.TERRAIN_MESSAGE_TYPE_SENDCHUNKDATA: case TypeBytes.TERRAIN_MESSAGE_TYPE_SENDCHUNKDATA:
if(TerrainMessage.canParseMessage(byteBuffer,secondByte)){
rVal = TerrainMessage.parsesendChunkDataMessage(byteBuffer,pool,customParserMap); rVal = TerrainMessage.parsesendChunkDataMessage(byteBuffer,pool,customParserMap);
}
break; break;
case TypeBytes.TERRAIN_MESSAGE_TYPE_REQUESTREDUCEDCHUNKDATA: case TypeBytes.TERRAIN_MESSAGE_TYPE_REQUESTREDUCEDCHUNKDATA:
if(TerrainMessage.canParseMessage(byteBuffer,secondByte)){
rVal = TerrainMessage.parseRequestReducedChunkDataMessage(byteBuffer,pool,customParserMap); rVal = TerrainMessage.parseRequestReducedChunkDataMessage(byteBuffer,pool,customParserMap);
}
break; break;
case TypeBytes.TERRAIN_MESSAGE_TYPE_SENDREDUCEDCHUNKDATA: case TypeBytes.TERRAIN_MESSAGE_TYPE_SENDREDUCEDCHUNKDATA:
if(TerrainMessage.canParseMessage(byteBuffer,secondByte)){
rVal = TerrainMessage.parseSendReducedChunkDataMessage(byteBuffer,pool,customParserMap); rVal = TerrainMessage.parseSendReducedChunkDataMessage(byteBuffer,pool,customParserMap);
}
break; break;
case TypeBytes.TERRAIN_MESSAGE_TYPE_REQUESTREDUCEDBLOCKDATA: case TypeBytes.TERRAIN_MESSAGE_TYPE_REQUESTREDUCEDBLOCKDATA:
if(TerrainMessage.canParseMessage(byteBuffer,secondByte)){
rVal = TerrainMessage.parseRequestReducedBlockDataMessage(byteBuffer,pool,customParserMap); rVal = TerrainMessage.parseRequestReducedBlockDataMessage(byteBuffer,pool,customParserMap);
}
break; break;
case TypeBytes.TERRAIN_MESSAGE_TYPE_SENDREDUCEDBLOCKDATA: case TypeBytes.TERRAIN_MESSAGE_TYPE_SENDREDUCEDBLOCKDATA:
if(TerrainMessage.canParseMessage(byteBuffer,secondByte)){
rVal = TerrainMessage.parseSendReducedBlockDataMessage(byteBuffer,pool,customParserMap); rVal = TerrainMessage.parseSendReducedBlockDataMessage(byteBuffer,pool,customParserMap);
}
break; break;
case TypeBytes.TERRAIN_MESSAGE_TYPE_UPDATEBLOCK: case TypeBytes.TERRAIN_MESSAGE_TYPE_UPDATEBLOCK:
if(TerrainMessage.canParseMessage(byteBuffer,secondByte)){
rVal = TerrainMessage.parseUpdateBlockMessage(byteBuffer,pool,customParserMap); rVal = TerrainMessage.parseUpdateBlockMessage(byteBuffer,pool,customParserMap);
}
break; break;
case TypeBytes.TERRAIN_MESSAGE_TYPE_REQUESTFLUIDDATA: case TypeBytes.TERRAIN_MESSAGE_TYPE_REQUESTFLUIDDATA:
if(TerrainMessage.canParseMessage(byteBuffer,secondByte)){
rVal = TerrainMessage.parseRequestFluidDataMessage(byteBuffer,pool,customParserMap); rVal = TerrainMessage.parseRequestFluidDataMessage(byteBuffer,pool,customParserMap);
}
break; break;
case TypeBytes.TERRAIN_MESSAGE_TYPE_SENDFLUIDDATA: case TypeBytes.TERRAIN_MESSAGE_TYPE_SENDFLUIDDATA:
if(TerrainMessage.canParseMessage(byteBuffer,secondByte)){
rVal = TerrainMessage.parsesendFluidDataMessage(byteBuffer,pool,customParserMap); rVal = TerrainMessage.parsesendFluidDataMessage(byteBuffer,pool,customParserMap);
}
break; break;
case TypeBytes.TERRAIN_MESSAGE_TYPE_UPDATEFLUIDDATA: case TypeBytes.TERRAIN_MESSAGE_TYPE_UPDATEFLUIDDATA:
if(TerrainMessage.canParseMessage(byteBuffer,secondByte)){
rVal = TerrainMessage.parseupdateFluidDataMessage(byteBuffer,pool,customParserMap); rVal = TerrainMessage.parseupdateFluidDataMessage(byteBuffer,pool,customParserMap);
}
break; break;
case TypeBytes.TERRAIN_MESSAGE_TYPE_REQUESTEDITBLOCK: case TypeBytes.TERRAIN_MESSAGE_TYPE_REQUESTEDITBLOCK:
if(TerrainMessage.canParseMessage(byteBuffer,secondByte)){
rVal = TerrainMessage.parseRequestEditBlockMessage(byteBuffer,pool,customParserMap); rVal = TerrainMessage.parseRequestEditBlockMessage(byteBuffer,pool,customParserMap);
}
break; break;
case TypeBytes.TERRAIN_MESSAGE_TYPE_REQUESTPLACEFAB: case TypeBytes.TERRAIN_MESSAGE_TYPE_REQUESTPLACEFAB:
if(TerrainMessage.canParseMessage(byteBuffer,secondByte)){
rVal = TerrainMessage.parseRequestPlaceFabMessage(byteBuffer,pool,customParserMap); rVal = TerrainMessage.parseRequestPlaceFabMessage(byteBuffer,pool,customParserMap);
}
break; break;
} }
break; break;
case TypeBytes.MESSAGE_TYPE_SERVER: case TypeBytes.MESSAGE_TYPE_SERVER:
secondByte = byteBuffer.peek(1); secondByte = byteBuffer.get();
switch(secondByte){ switch(secondByte){
case TypeBytes.SERVER_MESSAGE_TYPE_PING: case TypeBytes.SERVER_MESSAGE_TYPE_PING:
if(ServerMessage.canParseMessage(byteBuffer,secondByte)){
rVal = ServerMessage.parsePingMessage(byteBuffer,pool,customParserMap); rVal = ServerMessage.parsePingMessage(byteBuffer,pool,customParserMap);
}
break; break;
case TypeBytes.SERVER_MESSAGE_TYPE_PONG: case TypeBytes.SERVER_MESSAGE_TYPE_PONG:
if(ServerMessage.canParseMessage(byteBuffer,secondByte)){
rVal = ServerMessage.parsePongMessage(byteBuffer,pool,customParserMap); rVal = ServerMessage.parsePongMessage(byteBuffer,pool,customParserMap);
}
break; break;
case TypeBytes.SERVER_MESSAGE_TYPE_DISCONNECT: case TypeBytes.SERVER_MESSAGE_TYPE_DISCONNECT:
if(ServerMessage.canParseMessage(byteBuffer,secondByte)){
rVal = ServerMessage.parseDisconnectMessage(byteBuffer,pool,customParserMap); rVal = ServerMessage.parseDisconnectMessage(byteBuffer,pool,customParserMap);
}
break; break;
} }
break; break;
case TypeBytes.MESSAGE_TYPE_AUTH: case TypeBytes.MESSAGE_TYPE_AUTH:
secondByte = byteBuffer.peek(1); secondByte = byteBuffer.get();
switch(secondByte){ switch(secondByte){
case TypeBytes.AUTH_MESSAGE_TYPE_AUTHREQUEST: case TypeBytes.AUTH_MESSAGE_TYPE_AUTHREQUEST:
if(AuthMessage.canParseMessage(byteBuffer,secondByte)){
rVal = AuthMessage.parseAuthRequestMessage(byteBuffer,pool,customParserMap); rVal = AuthMessage.parseAuthRequestMessage(byteBuffer,pool,customParserMap);
}
break; break;
case TypeBytes.AUTH_MESSAGE_TYPE_AUTHDETAILS: case TypeBytes.AUTH_MESSAGE_TYPE_AUTHDETAILS:
if(AuthMessage.canParseMessage(byteBuffer,secondByte)){
rVal = AuthMessage.parseAuthDetailsMessage(byteBuffer,pool,customParserMap); rVal = AuthMessage.parseAuthDetailsMessage(byteBuffer,pool,customParserMap);
}
break; break;
case TypeBytes.AUTH_MESSAGE_TYPE_AUTHSUCCESS: case TypeBytes.AUTH_MESSAGE_TYPE_AUTHSUCCESS:
if(AuthMessage.canParseMessage(byteBuffer,secondByte)){
rVal = AuthMessage.parseAuthSuccessMessage(byteBuffer,pool,customParserMap); rVal = AuthMessage.parseAuthSuccessMessage(byteBuffer,pool,customParserMap);
}
break; break;
case TypeBytes.AUTH_MESSAGE_TYPE_AUTHFAILURE: case TypeBytes.AUTH_MESSAGE_TYPE_AUTHFAILURE:
if(AuthMessage.canParseMessage(byteBuffer,secondByte)){
rVal = AuthMessage.parseAuthFailureMessage(byteBuffer,pool,customParserMap); rVal = AuthMessage.parseAuthFailureMessage(byteBuffer,pool,customParserMap);
}
break; break;
} }
break; break;
case TypeBytes.MESSAGE_TYPE_CHARACTER: case TypeBytes.MESSAGE_TYPE_CHARACTER:
secondByte = byteBuffer.peek(1); secondByte = byteBuffer.get();
switch(secondByte){ switch(secondByte){
case TypeBytes.CHARACTER_MESSAGE_TYPE_REQUESTCHARACTERLIST: case TypeBytes.CHARACTER_MESSAGE_TYPE_REQUESTCHARACTERLIST:
if(CharacterMessage.canParseMessage(byteBuffer,secondByte)){
rVal = CharacterMessage.parseRequestCharacterListMessage(byteBuffer,pool,customParserMap); rVal = CharacterMessage.parseRequestCharacterListMessage(byteBuffer,pool,customParserMap);
}
break; break;
case TypeBytes.CHARACTER_MESSAGE_TYPE_RESPONSECHARACTERLIST: case TypeBytes.CHARACTER_MESSAGE_TYPE_RESPONSECHARACTERLIST:
if(CharacterMessage.canParseMessage(byteBuffer,secondByte)){
rVal = CharacterMessage.parseResponseCharacterListMessage(byteBuffer,pool,customParserMap); rVal = CharacterMessage.parseResponseCharacterListMessage(byteBuffer,pool,customParserMap);
}
break; break;
case TypeBytes.CHARACTER_MESSAGE_TYPE_REQUESTCREATECHARACTER: case TypeBytes.CHARACTER_MESSAGE_TYPE_REQUESTCREATECHARACTER:
if(CharacterMessage.canParseMessage(byteBuffer,secondByte)){
rVal = CharacterMessage.parseRequestCreateCharacterMessage(byteBuffer,pool,customParserMap); rVal = CharacterMessage.parseRequestCreateCharacterMessage(byteBuffer,pool,customParserMap);
}
break; break;
case TypeBytes.CHARACTER_MESSAGE_TYPE_RESPONSECREATECHARACTERSUCCESS: case TypeBytes.CHARACTER_MESSAGE_TYPE_RESPONSECREATECHARACTERSUCCESS:
if(CharacterMessage.canParseMessage(byteBuffer,secondByte)){
rVal = CharacterMessage.parseResponseCreateCharacterSuccessMessage(byteBuffer,pool,customParserMap); rVal = CharacterMessage.parseResponseCreateCharacterSuccessMessage(byteBuffer,pool,customParserMap);
}
break; break;
case TypeBytes.CHARACTER_MESSAGE_TYPE_RESPONSECREATECHARACTERFAILURE: case TypeBytes.CHARACTER_MESSAGE_TYPE_RESPONSECREATECHARACTERFAILURE:
if(CharacterMessage.canParseMessage(byteBuffer,secondByte)){
rVal = CharacterMessage.parseResponseCreateCharacterFailureMessage(byteBuffer,pool,customParserMap); rVal = CharacterMessage.parseResponseCreateCharacterFailureMessage(byteBuffer,pool,customParserMap);
}
break; break;
case TypeBytes.CHARACTER_MESSAGE_TYPE_REQUESTSPAWNCHARACTER: case TypeBytes.CHARACTER_MESSAGE_TYPE_REQUESTSPAWNCHARACTER:
if(CharacterMessage.canParseMessage(byteBuffer,secondByte)){
rVal = CharacterMessage.parseRequestSpawnCharacterMessage(byteBuffer,pool,customParserMap); rVal = CharacterMessage.parseRequestSpawnCharacterMessage(byteBuffer,pool,customParserMap);
}
break; break;
case TypeBytes.CHARACTER_MESSAGE_TYPE_RESPONSESPAWNCHARACTER: case TypeBytes.CHARACTER_MESSAGE_TYPE_RESPONSESPAWNCHARACTER:
if(CharacterMessage.canParseMessage(byteBuffer,secondByte)){
rVal = CharacterMessage.parseResponseSpawnCharacterMessage(byteBuffer,pool,customParserMap); rVal = CharacterMessage.parseResponseSpawnCharacterMessage(byteBuffer,pool,customParserMap);
}
break; break;
case TypeBytes.CHARACTER_MESSAGE_TYPE_EDITORSWAP: case TypeBytes.CHARACTER_MESSAGE_TYPE_EDITORSWAP:
if(CharacterMessage.canParseMessage(byteBuffer,secondByte)){
rVal = CharacterMessage.parseEditorSwapMessage(byteBuffer,pool,customParserMap); rVal = CharacterMessage.parseEditorSwapMessage(byteBuffer,pool,customParserMap);
}
break; break;
} }
break; break;
case TypeBytes.MESSAGE_TYPE_INVENTORY: case TypeBytes.MESSAGE_TYPE_INVENTORY:
secondByte = byteBuffer.peek(1); secondByte = byteBuffer.get();
switch(secondByte){ switch(secondByte){
case TypeBytes.INVENTORY_MESSAGE_TYPE_ADDITEMTOINVENTORY: case TypeBytes.INVENTORY_MESSAGE_TYPE_ADDITEMTOINVENTORY:
if(InventoryMessage.canParseMessage(byteBuffer,secondByte)){
rVal = InventoryMessage.parseaddItemToInventoryMessage(byteBuffer,pool,customParserMap); rVal = InventoryMessage.parseaddItemToInventoryMessage(byteBuffer,pool,customParserMap);
}
break; break;
case TypeBytes.INVENTORY_MESSAGE_TYPE_REMOVEITEMFROMINVENTORY: case TypeBytes.INVENTORY_MESSAGE_TYPE_REMOVEITEMFROMINVENTORY:
if(InventoryMessage.canParseMessage(byteBuffer,secondByte)){
rVal = InventoryMessage.parseremoveItemFromInventoryMessage(byteBuffer,pool,customParserMap); rVal = InventoryMessage.parseremoveItemFromInventoryMessage(byteBuffer,pool,customParserMap);
}
break; break;
case TypeBytes.INVENTORY_MESSAGE_TYPE_CLIENTREQUESTEQUIPITEM: case TypeBytes.INVENTORY_MESSAGE_TYPE_CLIENTREQUESTEQUIPITEM:
if(InventoryMessage.canParseMessage(byteBuffer,secondByte)){
rVal = InventoryMessage.parseclientRequestEquipItemMessage(byteBuffer,pool,customParserMap); rVal = InventoryMessage.parseclientRequestEquipItemMessage(byteBuffer,pool,customParserMap);
}
break; break;
case TypeBytes.INVENTORY_MESSAGE_TYPE_SERVERCOMMANDMOVEITEMCONTAINER: case TypeBytes.INVENTORY_MESSAGE_TYPE_SERVERCOMMANDMOVEITEMCONTAINER:
if(InventoryMessage.canParseMessage(byteBuffer,secondByte)){
rVal = InventoryMessage.parseserverCommandMoveItemContainerMessage(byteBuffer,pool,customParserMap); rVal = InventoryMessage.parseserverCommandMoveItemContainerMessage(byteBuffer,pool,customParserMap);
}
break; break;
case TypeBytes.INVENTORY_MESSAGE_TYPE_SERVERCOMMANDEQUIPITEM: case TypeBytes.INVENTORY_MESSAGE_TYPE_SERVERCOMMANDEQUIPITEM:
if(InventoryMessage.canParseMessage(byteBuffer,secondByte)){
rVal = InventoryMessage.parseserverCommandEquipItemMessage(byteBuffer,pool,customParserMap); rVal = InventoryMessage.parseserverCommandEquipItemMessage(byteBuffer,pool,customParserMap);
}
break; break;
case TypeBytes.INVENTORY_MESSAGE_TYPE_SERVERCOMMANDUNEQUIPITEM: case TypeBytes.INVENTORY_MESSAGE_TYPE_SERVERCOMMANDUNEQUIPITEM:
if(InventoryMessage.canParseMessage(byteBuffer,secondByte)){
rVal = InventoryMessage.parseserverCommandUnequipItemMessage(byteBuffer,pool,customParserMap); rVal = InventoryMessage.parseserverCommandUnequipItemMessage(byteBuffer,pool,customParserMap);
}
break; break;
case TypeBytes.INVENTORY_MESSAGE_TYPE_CLIENTREQUESTUNEQUIPITEM: case TypeBytes.INVENTORY_MESSAGE_TYPE_CLIENTREQUESTUNEQUIPITEM:
if(InventoryMessage.canParseMessage(byteBuffer,secondByte)){
rVal = InventoryMessage.parseclientRequestUnequipItemMessage(byteBuffer,pool,customParserMap); rVal = InventoryMessage.parseclientRequestUnequipItemMessage(byteBuffer,pool,customParserMap);
}
break; break;
case TypeBytes.INVENTORY_MESSAGE_TYPE_CLIENTREQUESTSTOREITEM: case TypeBytes.INVENTORY_MESSAGE_TYPE_CLIENTREQUESTSTOREITEM:
if(InventoryMessage.canParseMessage(byteBuffer,secondByte)){
rVal = InventoryMessage.parseclientRequestStoreItemMessage(byteBuffer,pool,customParserMap); rVal = InventoryMessage.parseclientRequestStoreItemMessage(byteBuffer,pool,customParserMap);
}
break; break;
case TypeBytes.INVENTORY_MESSAGE_TYPE_SERVERCOMMANDSTOREITEM: case TypeBytes.INVENTORY_MESSAGE_TYPE_SERVERCOMMANDSTOREITEM:
if(InventoryMessage.canParseMessage(byteBuffer,secondByte)){
rVal = InventoryMessage.parseserverCommandStoreItemMessage(byteBuffer,pool,customParserMap); rVal = InventoryMessage.parseserverCommandStoreItemMessage(byteBuffer,pool,customParserMap);
}
break; break;
case TypeBytes.INVENTORY_MESSAGE_TYPE_CLIENTREQUESTWATCHINVENTORY: case TypeBytes.INVENTORY_MESSAGE_TYPE_CLIENTREQUESTWATCHINVENTORY:
if(InventoryMessage.canParseMessage(byteBuffer,secondByte)){
rVal = InventoryMessage.parseclientRequestWatchInventoryMessage(byteBuffer,pool,customParserMap); rVal = InventoryMessage.parseclientRequestWatchInventoryMessage(byteBuffer,pool,customParserMap);
}
break; break;
case TypeBytes.INVENTORY_MESSAGE_TYPE_CLIENTREQUESTUNWATCHINVENTORY: case TypeBytes.INVENTORY_MESSAGE_TYPE_CLIENTREQUESTUNWATCHINVENTORY:
if(InventoryMessage.canParseMessage(byteBuffer,secondByte)){
rVal = InventoryMessage.parseclientRequestUnwatchInventoryMessage(byteBuffer,pool,customParserMap); rVal = InventoryMessage.parseclientRequestUnwatchInventoryMessage(byteBuffer,pool,customParserMap);
}
break; break;
case TypeBytes.INVENTORY_MESSAGE_TYPE_CLIENTREQUESTADDTOOLBAR: case TypeBytes.INVENTORY_MESSAGE_TYPE_CLIENTREQUESTADDTOOLBAR:
if(InventoryMessage.canParseMessage(byteBuffer,secondByte)){
rVal = InventoryMessage.parseclientRequestAddToolbarMessage(byteBuffer,pool,customParserMap); rVal = InventoryMessage.parseclientRequestAddToolbarMessage(byteBuffer,pool,customParserMap);
}
break; break;
case TypeBytes.INVENTORY_MESSAGE_TYPE_CLIENTREQUESTADDNATURAL: case TypeBytes.INVENTORY_MESSAGE_TYPE_CLIENTREQUESTADDNATURAL:
if(InventoryMessage.canParseMessage(byteBuffer,secondByte)){
rVal = InventoryMessage.parseclientRequestAddNaturalMessage(byteBuffer,pool,customParserMap); rVal = InventoryMessage.parseclientRequestAddNaturalMessage(byteBuffer,pool,customParserMap);
}
break; break;
case TypeBytes.INVENTORY_MESSAGE_TYPE_CLIENTUPDATETOOLBAR: case TypeBytes.INVENTORY_MESSAGE_TYPE_CLIENTUPDATETOOLBAR:
if(InventoryMessage.canParseMessage(byteBuffer,secondByte)){
rVal = InventoryMessage.parseclientUpdateToolbarMessage(byteBuffer,pool,customParserMap); rVal = InventoryMessage.parseclientUpdateToolbarMessage(byteBuffer,pool,customParserMap);
}
break; break;
case TypeBytes.INVENTORY_MESSAGE_TYPE_CLIENTREQUESTPERFORMITEMACTION: case TypeBytes.INVENTORY_MESSAGE_TYPE_CLIENTREQUESTPERFORMITEMACTION:
if(InventoryMessage.canParseMessage(byteBuffer,secondByte)){
rVal = InventoryMessage.parseclientRequestPerformItemActionMessage(byteBuffer,pool,customParserMap); rVal = InventoryMessage.parseclientRequestPerformItemActionMessage(byteBuffer,pool,customParserMap);
}
break; break;
case TypeBytes.INVENTORY_MESSAGE_TYPE_CLIENTREQUESTCRAFT: case TypeBytes.INVENTORY_MESSAGE_TYPE_CLIENTREQUESTCRAFT:
if(InventoryMessage.canParseMessage(byteBuffer,secondByte)){
rVal = InventoryMessage.parseclientRequestCraftMessage(byteBuffer,pool,customParserMap); rVal = InventoryMessage.parseclientRequestCraftMessage(byteBuffer,pool,customParserMap);
}
break; break;
case TypeBytes.INVENTORY_MESSAGE_TYPE_SERVERUPDATEITEMCHARGES: case TypeBytes.INVENTORY_MESSAGE_TYPE_SERVERUPDATEITEMCHARGES:
if(InventoryMessage.canParseMessage(byteBuffer,secondByte)){
rVal = InventoryMessage.parseserverUpdateItemChargesMessage(byteBuffer,pool,customParserMap); rVal = InventoryMessage.parseserverUpdateItemChargesMessage(byteBuffer,pool,customParserMap);
}
break; break;
} }
break; break;
case TypeBytes.MESSAGE_TYPE_SYNCHRONIZATION: case TypeBytes.MESSAGE_TYPE_SYNCHRONIZATION:
secondByte = byteBuffer.peek(1); secondByte = byteBuffer.get();
switch(secondByte){ switch(secondByte){
case TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_UPDATECLIENTSTATE: case TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_UPDATECLIENTSTATE:
if(SynchronizationMessage.canParseMessage(byteBuffer,secondByte)){
rVal = SynchronizationMessage.parseUpdateClientStateMessage(byteBuffer,pool,customParserMap); rVal = SynchronizationMessage.parseUpdateClientStateMessage(byteBuffer,pool,customParserMap);
}
break; break;
case TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_UPDATECLIENTSTRINGSTATE: case TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_UPDATECLIENTSTRINGSTATE:
if(SynchronizationMessage.canParseMessage(byteBuffer,secondByte)){
rVal = SynchronizationMessage.parseUpdateClientStringStateMessage(byteBuffer,pool,customParserMap); rVal = SynchronizationMessage.parseUpdateClientStringStateMessage(byteBuffer,pool,customParserMap);
}
break; break;
case TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_UPDATECLIENTINTSTATE: case TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_UPDATECLIENTINTSTATE:
if(SynchronizationMessage.canParseMessage(byteBuffer,secondByte)){
rVal = SynchronizationMessage.parseUpdateClientIntStateMessage(byteBuffer,pool,customParserMap); rVal = SynchronizationMessage.parseUpdateClientIntStateMessage(byteBuffer,pool,customParserMap);
}
break; break;
case TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_UPDATECLIENTLONGSTATE: case TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_UPDATECLIENTLONGSTATE:
if(SynchronizationMessage.canParseMessage(byteBuffer,secondByte)){
rVal = SynchronizationMessage.parseUpdateClientLongStateMessage(byteBuffer,pool,customParserMap); rVal = SynchronizationMessage.parseUpdateClientLongStateMessage(byteBuffer,pool,customParserMap);
}
break; break;
case TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_UPDATECLIENTFLOATSTATE: case TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_UPDATECLIENTFLOATSTATE:
if(SynchronizationMessage.canParseMessage(byteBuffer,secondByte)){
rVal = SynchronizationMessage.parseUpdateClientFloatStateMessage(byteBuffer,pool,customParserMap); rVal = SynchronizationMessage.parseUpdateClientFloatStateMessage(byteBuffer,pool,customParserMap);
}
break; break;
case TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_UPDATECLIENTDOUBLESTATE: case TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_UPDATECLIENTDOUBLESTATE:
if(SynchronizationMessage.canParseMessage(byteBuffer,secondByte)){
rVal = SynchronizationMessage.parseUpdateClientDoubleStateMessage(byteBuffer,pool,customParserMap); rVal = SynchronizationMessage.parseUpdateClientDoubleStateMessage(byteBuffer,pool,customParserMap);
}
break; break;
case TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_CLIENTREQUESTBTREEACTION: case TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_CLIENTREQUESTBTREEACTION:
if(SynchronizationMessage.canParseMessage(byteBuffer,secondByte)){
rVal = SynchronizationMessage.parseClientRequestBTreeActionMessage(byteBuffer,pool,customParserMap); rVal = SynchronizationMessage.parseClientRequestBTreeActionMessage(byteBuffer,pool,customParserMap);
}
break; break;
case TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_SERVERNOTIFYBTREETRANSITION: case TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_SERVERNOTIFYBTREETRANSITION:
if(SynchronizationMessage.canParseMessage(byteBuffer,secondByte)){
rVal = SynchronizationMessage.parseServerNotifyBTreeTransitionMessage(byteBuffer,pool,customParserMap); rVal = SynchronizationMessage.parseServerNotifyBTreeTransitionMessage(byteBuffer,pool,customParserMap);
}
break; break;
case TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_ATTACHTREE: case TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_ATTACHTREE:
if(SynchronizationMessage.canParseMessage(byteBuffer,secondByte)){
rVal = SynchronizationMessage.parseAttachTreeMessage(byteBuffer,pool,customParserMap); rVal = SynchronizationMessage.parseAttachTreeMessage(byteBuffer,pool,customParserMap);
}
break; break;
case TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_DETATCHTREE: case TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_DETATCHTREE:
if(SynchronizationMessage.canParseMessage(byteBuffer,secondByte)){
rVal = SynchronizationMessage.parseDetatchTreeMessage(byteBuffer,pool,customParserMap); rVal = SynchronizationMessage.parseDetatchTreeMessage(byteBuffer,pool,customParserMap);
}
break; break;
case TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_LOADSCENE: case TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_LOADSCENE:
if(SynchronizationMessage.canParseMessage(byteBuffer,secondByte)){
rVal = SynchronizationMessage.parseLoadSceneMessage(byteBuffer,pool,customParserMap); rVal = SynchronizationMessage.parseLoadSceneMessage(byteBuffer,pool,customParserMap);
}
break; break;
} }
break; break;
case TypeBytes.MESSAGE_TYPE_COMBAT: case TypeBytes.MESSAGE_TYPE_COMBAT:
secondByte = byteBuffer.peek(1); secondByte = byteBuffer.get();
switch(secondByte){ switch(secondByte){
case TypeBytes.COMBAT_MESSAGE_TYPE_SERVERREPORTHITBOXCOLLISION: case TypeBytes.COMBAT_MESSAGE_TYPE_SERVERREPORTHITBOXCOLLISION:
if(CombatMessage.canParseMessage(byteBuffer,secondByte)){
rVal = CombatMessage.parseserverReportHitboxCollisionMessage(byteBuffer,pool,customParserMap); rVal = CombatMessage.parseserverReportHitboxCollisionMessage(byteBuffer,pool,customParserMap);
}
break; break;
} }
break; break;
} }
if(rVal == null){
//failed to read the message
byteBuffer.position(initialPosition);
}
} }
return rVal; return rVal;
} }

72
src/main/java/electrosphere/net/parser/net/message/PlayerMessage.java
View File

@ -2,7 +2,7 @@ package electrosphere.net.parser.net.message;
import java.io.IOException; import java.io.IOException;
import java.io.OutputStream; import java.io.OutputStream;
import io.github.studiorailgun.CircularByteBuffer; import java.nio.ByteBuffer;
import electrosphere.net.parser.util.ByteStreamUtils; import electrosphere.net.parser.util.ByteStreamUtils;
import java.util.Map; import java.util.Map;
import java.util.function.BiConsumer; import java.util.function.BiConsumer;
@ -102,46 +102,16 @@ public class PlayerMessage extends NetworkMessage {
this.initialDiscretePositionZ = initialDiscretePositionZ; this.initialDiscretePositionZ = initialDiscretePositionZ;
} }
/**
* Removes the packet header from the buffer
* @param byteBuffer The buffer
*/
static void stripPacketHeader(CircularByteBuffer byteBuffer){
byteBuffer.read(2);
}
/**
* Checks if this message can be parsed (ie are all bytes present)
* @param byteBuffer The buffer
* @param secondByte The second byte, signifying the subtype of the message
* @return true if the message can be parsed, false otherwise
*/
public static boolean canParseMessage(CircularByteBuffer byteBuffer, byte secondByte){
switch(secondByte){
case TypeBytes.PLAYER_MESSAGE_TYPE_SET_ID:
if(byteBuffer.getRemaining() >= TypeBytes.PLAYER_MESSAGE_TYPE_SET_ID_SIZE){
return true;
} else {
return false;
}
case TypeBytes.PLAYER_MESSAGE_TYPE_SETINITIALDISCRETEPOSITION:
if(byteBuffer.getRemaining() >= TypeBytes.PLAYER_MESSAGE_TYPE_SETINITIALDISCRETEPOSITION_SIZE){
return true;
} else {
return false;
}
}
return false;
}
/** /**
* Parses a message of type Set_ID * Parses a message of type Set_ID
*/ */
public static PlayerMessage parseSet_IDMessage(CircularByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,CircularByteBuffer>> customParserMap){ public static PlayerMessage parseSet_IDMessage(ByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,ByteBuffer>> customParserMap){
if(byteBuffer.remaining() < 4){
return null;
}
PlayerMessage rVal = (PlayerMessage)pool.get(MessageType.PLAYER_MESSAGE); PlayerMessage rVal = (PlayerMessage)pool.get(MessageType.PLAYER_MESSAGE);
rVal.messageType = PlayerMessageType.SET_ID; rVal.messageType = PlayerMessageType.SET_ID;
PlayerMessage.stripPacketHeader(byteBuffer); rVal.setplayerID(byteBuffer.getInt());
rVal.setplayerID(ByteStreamUtils.popIntFromByteQueue(byteBuffer));
return rVal; return rVal;
} }
@ -157,13 +127,15 @@ public class PlayerMessage extends NetworkMessage {
/** /**
* Parses a message of type SetInitialDiscretePosition * Parses a message of type SetInitialDiscretePosition
*/ */
public static PlayerMessage parseSetInitialDiscretePositionMessage(CircularByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,CircularByteBuffer>> customParserMap){ public static PlayerMessage parseSetInitialDiscretePositionMessage(ByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,ByteBuffer>> customParserMap){
if(byteBuffer.remaining() < 12){
return null;
}
PlayerMessage rVal = (PlayerMessage)pool.get(MessageType.PLAYER_MESSAGE); PlayerMessage rVal = (PlayerMessage)pool.get(MessageType.PLAYER_MESSAGE);
rVal.messageType = PlayerMessageType.SETINITIALDISCRETEPOSITION; rVal.messageType = PlayerMessageType.SETINITIALDISCRETEPOSITION;
PlayerMessage.stripPacketHeader(byteBuffer); rVal.setinitialDiscretePositionX(byteBuffer.getInt());
rVal.setinitialDiscretePositionX(ByteStreamUtils.popIntFromByteQueue(byteBuffer)); rVal.setinitialDiscretePositionY(byteBuffer.getInt());
rVal.setinitialDiscretePositionY(ByteStreamUtils.popIntFromByteQueue(byteBuffer)); rVal.setinitialDiscretePositionZ(byteBuffer.getInt());
rVal.setinitialDiscretePositionZ(ByteStreamUtils.popIntFromByteQueue(byteBuffer));
return rVal; return rVal;
} }
@ -220,20 +192,30 @@ public class PlayerMessage extends NetworkMessage {
@Override @Override
public void write(OutputStream stream) throws IOException { public void write(OutputStream stream) throws IOException {
switch(this.messageType){ switch(this.messageType){
case SET_ID: case SET_ID: {
//
//message header //message header
stream.write(TypeBytes.MESSAGE_TYPE_PLAYER); stream.write(TypeBytes.MESSAGE_TYPE_PLAYER);
stream.write(TypeBytes.PLAYER_MESSAGE_TYPE_SET_ID); stream.write(TypeBytes.PLAYER_MESSAGE_TYPE_SET_ID);
//
//Write body of packet
ByteStreamUtils.writeInt(stream, playerID); ByteStreamUtils.writeInt(stream, playerID);
break; } break;
case SETINITIALDISCRETEPOSITION: case SETINITIALDISCRETEPOSITION: {
//
//message header //message header
stream.write(TypeBytes.MESSAGE_TYPE_PLAYER); stream.write(TypeBytes.MESSAGE_TYPE_PLAYER);
stream.write(TypeBytes.PLAYER_MESSAGE_TYPE_SETINITIALDISCRETEPOSITION); stream.write(TypeBytes.PLAYER_MESSAGE_TYPE_SETINITIALDISCRETEPOSITION);
//
//Write body of packet
ByteStreamUtils.writeInt(stream, initialDiscretePositionX); ByteStreamUtils.writeInt(stream, initialDiscretePositionX);
ByteStreamUtils.writeInt(stream, initialDiscretePositionY); ByteStreamUtils.writeInt(stream, initialDiscretePositionY);
ByteStreamUtils.writeInt(stream, initialDiscretePositionZ); ByteStreamUtils.writeInt(stream, initialDiscretePositionZ);
break; } break;
} }
} }

85
src/main/java/electrosphere/net/parser/net/message/ServerMessage.java
View File

@ -2,7 +2,7 @@ package electrosphere.net.parser.net.message;
import java.io.IOException; import java.io.IOException;
import java.io.OutputStream; import java.io.OutputStream;
import io.github.studiorailgun.CircularByteBuffer; import java.nio.ByteBuffer;
import java.util.Map; import java.util.Map;
import java.util.function.BiConsumer; import java.util.function.BiConsumer;
@ -42,51 +42,15 @@ public class ServerMessage extends NetworkMessage {
return this.messageType; return this.messageType;
} }
/**
* Removes the packet header from the buffer
* @param byteBuffer The buffer
*/
static void stripPacketHeader(CircularByteBuffer byteBuffer){
byteBuffer.read(2);
}
/**
* Checks if this message can be parsed (ie are all bytes present)
* @param byteBuffer The buffer
* @param secondByte The second byte, signifying the subtype of the message
* @return true if the message can be parsed, false otherwise
*/
public static boolean canParseMessage(CircularByteBuffer byteBuffer, byte secondByte){
switch(secondByte){
case TypeBytes.SERVER_MESSAGE_TYPE_PING:
if(byteBuffer.getRemaining() >= TypeBytes.SERVER_MESSAGE_TYPE_PING_SIZE){
return true;
} else {
return false;
}
case TypeBytes.SERVER_MESSAGE_TYPE_PONG:
if(byteBuffer.getRemaining() >= TypeBytes.SERVER_MESSAGE_TYPE_PONG_SIZE){
return true;
} else {
return false;
}
case TypeBytes.SERVER_MESSAGE_TYPE_DISCONNECT:
if(byteBuffer.getRemaining() >= TypeBytes.SERVER_MESSAGE_TYPE_DISCONNECT_SIZE){
return true;
} else {
return false;
}
}
return false;
}
/** /**
* Parses a message of type Ping * Parses a message of type Ping
*/ */
public static ServerMessage parsePingMessage(CircularByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,CircularByteBuffer>> customParserMap){ public static ServerMessage parsePingMessage(ByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,ByteBuffer>> customParserMap){
if(byteBuffer.remaining() < 0){
return null;
}
ServerMessage rVal = (ServerMessage)pool.get(MessageType.SERVER_MESSAGE); ServerMessage rVal = (ServerMessage)pool.get(MessageType.SERVER_MESSAGE);
rVal.messageType = ServerMessageType.PING; rVal.messageType = ServerMessageType.PING;
ServerMessage.stripPacketHeader(byteBuffer);
return rVal; return rVal;
} }
@ -101,10 +65,12 @@ public class ServerMessage extends NetworkMessage {
/** /**
* Parses a message of type Pong * Parses a message of type Pong
*/ */
public static ServerMessage parsePongMessage(CircularByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,CircularByteBuffer>> customParserMap){ public static ServerMessage parsePongMessage(ByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,ByteBuffer>> customParserMap){
if(byteBuffer.remaining() < 0){
return null;
}
ServerMessage rVal = (ServerMessage)pool.get(MessageType.SERVER_MESSAGE); ServerMessage rVal = (ServerMessage)pool.get(MessageType.SERVER_MESSAGE);
rVal.messageType = ServerMessageType.PONG; rVal.messageType = ServerMessageType.PONG;
ServerMessage.stripPacketHeader(byteBuffer);
return rVal; return rVal;
} }
@ -119,10 +85,12 @@ public class ServerMessage extends NetworkMessage {
/** /**
* Parses a message of type Disconnect * Parses a message of type Disconnect
*/ */
public static ServerMessage parseDisconnectMessage(CircularByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,CircularByteBuffer>> customParserMap){ public static ServerMessage parseDisconnectMessage(ByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,ByteBuffer>> customParserMap){
if(byteBuffer.remaining() < 0){
return null;
}
ServerMessage rVal = (ServerMessage)pool.get(MessageType.SERVER_MESSAGE); ServerMessage rVal = (ServerMessage)pool.get(MessageType.SERVER_MESSAGE);
rVal.messageType = ServerMessageType.DISCONNECT; rVal.messageType = ServerMessageType.DISCONNECT;
ServerMessage.stripPacketHeader(byteBuffer);
return rVal; return rVal;
} }
@ -166,21 +134,36 @@ public class ServerMessage extends NetworkMessage {
@Override @Override
public void write(OutputStream stream) throws IOException { public void write(OutputStream stream) throws IOException {
switch(this.messageType){ switch(this.messageType){
case PING: case PING: {
//
//message header //message header
stream.write(TypeBytes.MESSAGE_TYPE_SERVER); stream.write(TypeBytes.MESSAGE_TYPE_SERVER);
stream.write(TypeBytes.SERVER_MESSAGE_TYPE_PING); stream.write(TypeBytes.SERVER_MESSAGE_TYPE_PING);
break;
case PONG: //
//Write body of packet
} break;
case PONG: {
//
//message header //message header
stream.write(TypeBytes.MESSAGE_TYPE_SERVER); stream.write(TypeBytes.MESSAGE_TYPE_SERVER);
stream.write(TypeBytes.SERVER_MESSAGE_TYPE_PONG); stream.write(TypeBytes.SERVER_MESSAGE_TYPE_PONG);
break;
case DISCONNECT: //
//Write body of packet
} break;
case DISCONNECT: {
//
//message header //message header
stream.write(TypeBytes.MESSAGE_TYPE_SERVER); stream.write(TypeBytes.MESSAGE_TYPE_SERVER);
stream.write(TypeBytes.SERVER_MESSAGE_TYPE_DISCONNECT); stream.write(TypeBytes.SERVER_MESSAGE_TYPE_DISCONNECT);
break;
//
//Write body of packet
} break;
} }
} }

397
src/main/java/electrosphere/net/parser/net/message/SynchronizationMessage.java
View File

@ -2,11 +2,8 @@ package electrosphere.net.parser.net.message;
import java.io.IOException; import java.io.IOException;
import java.io.OutputStream; import java.io.OutputStream;
import io.github.studiorailgun.CircularByteBuffer; import java.nio.ByteBuffer;
import electrosphere.net.parser.util.ByteStreamUtils; import electrosphere.net.parser.util.ByteStreamUtils;
import java.util.LinkedList;
import java.util.List;
import java.util.Map; import java.util.Map;
import java.util.function.BiConsumer; import java.util.function.BiConsumer;
@ -189,95 +186,19 @@ public class SynchronizationMessage extends NetworkMessage {
this.doubleValue = doubleValue; this.doubleValue = doubleValue;
} }
/**
* Removes the packet header from the buffer
* @param byteBuffer The buffer
*/
static void stripPacketHeader(CircularByteBuffer byteBuffer){
byteBuffer.read(2);
}
/**
* Checks if this message can be parsed (ie are all bytes present)
* @param byteBuffer The buffer
* @param secondByte The second byte, signifying the subtype of the message
* @return true if the message can be parsed, false otherwise
*/
public static boolean canParseMessage(CircularByteBuffer byteBuffer, byte secondByte){
switch(secondByte){
case TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_UPDATECLIENTSTATE:
if(byteBuffer.getRemaining() >= TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_UPDATECLIENTSTATE_SIZE){
return true;
} else {
return false;
}
case TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_UPDATECLIENTSTRINGSTATE:
return SynchronizationMessage.canParseUpdateClientStringStateMessage(byteBuffer);
case TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_UPDATECLIENTINTSTATE:
if(byteBuffer.getRemaining() >= TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_UPDATECLIENTINTSTATE_SIZE){
return true;
} else {
return false;
}
case TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_UPDATECLIENTLONGSTATE:
if(byteBuffer.getRemaining() >= TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_UPDATECLIENTLONGSTATE_SIZE){
return true;
} else {
return false;
}
case TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_UPDATECLIENTFLOATSTATE:
if(byteBuffer.getRemaining() >= TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_UPDATECLIENTFLOATSTATE_SIZE){
return true;
} else {
return false;
}
case TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_UPDATECLIENTDOUBLESTATE:
if(byteBuffer.getRemaining() >= TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_UPDATECLIENTDOUBLESTATE_SIZE){
return true;
} else {
return false;
}
case TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_CLIENTREQUESTBTREEACTION:
if(byteBuffer.getRemaining() >= TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_CLIENTREQUESTBTREEACTION_SIZE){
return true;
} else {
return false;
}
case TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_SERVERNOTIFYBTREETRANSITION:
if(byteBuffer.getRemaining() >= TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_SERVERNOTIFYBTREETRANSITION_SIZE){
return true;
} else {
return false;
}
case TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_ATTACHTREE:
if(byteBuffer.getRemaining() >= TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_ATTACHTREE_SIZE){
return true;
} else {
return false;
}
case TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_DETATCHTREE:
if(byteBuffer.getRemaining() >= TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_DETATCHTREE_SIZE){
return true;
} else {
return false;
}
case TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_LOADSCENE:
return SynchronizationMessage.canParseLoadSceneMessage(byteBuffer);
}
return false;
}
/** /**
* Parses a message of type UpdateClientState * Parses a message of type UpdateClientState
*/ */
public static SynchronizationMessage parseUpdateClientStateMessage(CircularByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,CircularByteBuffer>> customParserMap){ public static SynchronizationMessage parseUpdateClientStateMessage(ByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,ByteBuffer>> customParserMap){
if(byteBuffer.remaining() < 16){
return null;
}
SynchronizationMessage rVal = (SynchronizationMessage)pool.get(MessageType.SYNCHRONIZATION_MESSAGE); SynchronizationMessage rVal = (SynchronizationMessage)pool.get(MessageType.SYNCHRONIZATION_MESSAGE);
rVal.messageType = SynchronizationMessageType.UPDATECLIENTSTATE; rVal.messageType = SynchronizationMessageType.UPDATECLIENTSTATE;
SynchronizationMessage.stripPacketHeader(byteBuffer); rVal.setentityId(byteBuffer.getInt());
rVal.setentityId(ByteStreamUtils.popIntFromByteQueue(byteBuffer)); rVal.setbTreeId(byteBuffer.getInt());
rVal.setbTreeId(ByteStreamUtils.popIntFromByteQueue(byteBuffer)); rVal.setfieldId(byteBuffer.getInt());
rVal.setfieldId(ByteStreamUtils.popIntFromByteQueue(byteBuffer)); rVal.setbTreeValue(byteBuffer.getInt());
rVal.setbTreeValue(ByteStreamUtils.popIntFromByteQueue(byteBuffer));
return rVal; return rVal;
} }
@ -293,48 +214,27 @@ public class SynchronizationMessage extends NetworkMessage {
return rVal; return rVal;
} }
/**
* Checks if a message of type UpdateClientStringState can be parsed from the byte stream
*/
public static boolean canParseUpdateClientStringStateMessage(CircularByteBuffer byteBuffer){
int currentStreamLength = byteBuffer.getRemaining();
List<Byte> temporaryByteQueue = new LinkedList<Byte>();
if(currentStreamLength < 6){
return false;
}
if(currentStreamLength < 10){
return false;
}
if(currentStreamLength < 14){
return false;
}
int stringValueSize = 0;
if(currentStreamLength < 18){
return false;
} else {
temporaryByteQueue.add(byteBuffer.peek(14 + 0));
temporaryByteQueue.add(byteBuffer.peek(14 + 1));
temporaryByteQueue.add(byteBuffer.peek(14 + 2));
temporaryByteQueue.add(byteBuffer.peek(14 + 3));
stringValueSize = ByteStreamUtils.popIntFromByteQueue(temporaryByteQueue);
}
if(currentStreamLength < 18 + stringValueSize){
return false;
}
return true;
}
/** /**
* Parses a message of type UpdateClientStringState * Parses a message of type UpdateClientStringState
*/ */
public static SynchronizationMessage parseUpdateClientStringStateMessage(CircularByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,CircularByteBuffer>> customParserMap){ public static SynchronizationMessage parseUpdateClientStringStateMessage(ByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,ByteBuffer>> customParserMap){
if(byteBuffer.remaining() < 16){
return null;
}
int lenAccumulator = 0;
int stringValuelen = byteBuffer.getInt();
lenAccumulator = lenAccumulator + stringValuelen;
if(byteBuffer.remaining() < 16 + lenAccumulator){
return null;
}
SynchronizationMessage rVal = (SynchronizationMessage)pool.get(MessageType.SYNCHRONIZATION_MESSAGE); SynchronizationMessage rVal = (SynchronizationMessage)pool.get(MessageType.SYNCHRONIZATION_MESSAGE);
rVal.messageType = SynchronizationMessageType.UPDATECLIENTSTRINGSTATE; rVal.messageType = SynchronizationMessageType.UPDATECLIENTSTRINGSTATE;
SynchronizationMessage.stripPacketHeader(byteBuffer); rVal.setentityId(byteBuffer.getInt());
rVal.setentityId(ByteStreamUtils.popIntFromByteQueue(byteBuffer)); rVal.setbTreeId(byteBuffer.getInt());
rVal.setbTreeId(ByteStreamUtils.popIntFromByteQueue(byteBuffer)); rVal.setfieldId(byteBuffer.getInt());
rVal.setfieldId(ByteStreamUtils.popIntFromByteQueue(byteBuffer)); if(stringValuelen > 0){
rVal.setstringValue(ByteStreamUtils.popStringFromByteQueue(byteBuffer)); rVal.setstringValue(ByteStreamUtils.popStringFromByteBuffer(byteBuffer, stringValuelen));
}
return rVal; return rVal;
} }
@ -353,14 +253,16 @@ public class SynchronizationMessage extends NetworkMessage {
/** /**
* Parses a message of type UpdateClientIntState * Parses a message of type UpdateClientIntState
*/ */
public static SynchronizationMessage parseUpdateClientIntStateMessage(CircularByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,CircularByteBuffer>> customParserMap){ public static SynchronizationMessage parseUpdateClientIntStateMessage(ByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,ByteBuffer>> customParserMap){
if(byteBuffer.remaining() < 16){
return null;
}
SynchronizationMessage rVal = (SynchronizationMessage)pool.get(MessageType.SYNCHRONIZATION_MESSAGE); SynchronizationMessage rVal = (SynchronizationMessage)pool.get(MessageType.SYNCHRONIZATION_MESSAGE);
rVal.messageType = SynchronizationMessageType.UPDATECLIENTINTSTATE; rVal.messageType = SynchronizationMessageType.UPDATECLIENTINTSTATE;
SynchronizationMessage.stripPacketHeader(byteBuffer); rVal.setentityId(byteBuffer.getInt());
rVal.setentityId(ByteStreamUtils.popIntFromByteQueue(byteBuffer)); rVal.setbTreeId(byteBuffer.getInt());
rVal.setbTreeId(ByteStreamUtils.popIntFromByteQueue(byteBuffer)); rVal.setfieldId(byteBuffer.getInt());
rVal.setfieldId(ByteStreamUtils.popIntFromByteQueue(byteBuffer)); rVal.setintValue(byteBuffer.getInt());
rVal.setintValue(ByteStreamUtils.popIntFromByteQueue(byteBuffer));
return rVal; return rVal;
} }
@ -379,14 +281,16 @@ public class SynchronizationMessage extends NetworkMessage {
/** /**
* Parses a message of type UpdateClientLongState * Parses a message of type UpdateClientLongState
*/ */
public static SynchronizationMessage parseUpdateClientLongStateMessage(CircularByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,CircularByteBuffer>> customParserMap){ public static SynchronizationMessage parseUpdateClientLongStateMessage(ByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,ByteBuffer>> customParserMap){
if(byteBuffer.remaining() < 20){
return null;
}
SynchronizationMessage rVal = (SynchronizationMessage)pool.get(MessageType.SYNCHRONIZATION_MESSAGE); SynchronizationMessage rVal = (SynchronizationMessage)pool.get(MessageType.SYNCHRONIZATION_MESSAGE);
rVal.messageType = SynchronizationMessageType.UPDATECLIENTLONGSTATE; rVal.messageType = SynchronizationMessageType.UPDATECLIENTLONGSTATE;
SynchronizationMessage.stripPacketHeader(byteBuffer); rVal.setentityId(byteBuffer.getInt());
rVal.setentityId(ByteStreamUtils.popIntFromByteQueue(byteBuffer)); rVal.setbTreeId(byteBuffer.getInt());
rVal.setbTreeId(ByteStreamUtils.popIntFromByteQueue(byteBuffer)); rVal.setfieldId(byteBuffer.getInt());
rVal.setfieldId(ByteStreamUtils.popIntFromByteQueue(byteBuffer)); rVal.setlongValue(byteBuffer.getLong());
rVal.setlongValue(ByteStreamUtils.popLongFromByteQueue(byteBuffer));
return rVal; return rVal;
} }
@ -405,14 +309,16 @@ public class SynchronizationMessage extends NetworkMessage {
/** /**
* Parses a message of type UpdateClientFloatState * Parses a message of type UpdateClientFloatState
*/ */
public static SynchronizationMessage parseUpdateClientFloatStateMessage(CircularByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,CircularByteBuffer>> customParserMap){ public static SynchronizationMessage parseUpdateClientFloatStateMessage(ByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,ByteBuffer>> customParserMap){
if(byteBuffer.remaining() < 16){
return null;
}
SynchronizationMessage rVal = (SynchronizationMessage)pool.get(MessageType.SYNCHRONIZATION_MESSAGE); SynchronizationMessage rVal = (SynchronizationMessage)pool.get(MessageType.SYNCHRONIZATION_MESSAGE);
rVal.messageType = SynchronizationMessageType.UPDATECLIENTFLOATSTATE; rVal.messageType = SynchronizationMessageType.UPDATECLIENTFLOATSTATE;
SynchronizationMessage.stripPacketHeader(byteBuffer); rVal.setentityId(byteBuffer.getInt());
rVal.setentityId(ByteStreamUtils.popIntFromByteQueue(byteBuffer)); rVal.setbTreeId(byteBuffer.getInt());
rVal.setbTreeId(ByteStreamUtils.popIntFromByteQueue(byteBuffer)); rVal.setfieldId(byteBuffer.getInt());
rVal.setfieldId(ByteStreamUtils.popIntFromByteQueue(byteBuffer)); rVal.setfloatValue(byteBuffer.getFloat());
rVal.setfloatValue(ByteStreamUtils.popFloatFromByteQueue(byteBuffer));
return rVal; return rVal;
} }
@ -431,14 +337,16 @@ public class SynchronizationMessage extends NetworkMessage {
/** /**
* Parses a message of type UpdateClientDoubleState * Parses a message of type UpdateClientDoubleState
*/ */
public static SynchronizationMessage parseUpdateClientDoubleStateMessage(CircularByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,CircularByteBuffer>> customParserMap){ public static SynchronizationMessage parseUpdateClientDoubleStateMessage(ByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,ByteBuffer>> customParserMap){
if(byteBuffer.remaining() < 20){
return null;
}
SynchronizationMessage rVal = (SynchronizationMessage)pool.get(MessageType.SYNCHRONIZATION_MESSAGE); SynchronizationMessage rVal = (SynchronizationMessage)pool.get(MessageType.SYNCHRONIZATION_MESSAGE);
rVal.messageType = SynchronizationMessageType.UPDATECLIENTDOUBLESTATE; rVal.messageType = SynchronizationMessageType.UPDATECLIENTDOUBLESTATE;
SynchronizationMessage.stripPacketHeader(byteBuffer); rVal.setentityId(byteBuffer.getInt());
rVal.setentityId(ByteStreamUtils.popIntFromByteQueue(byteBuffer)); rVal.setbTreeId(byteBuffer.getInt());
rVal.setbTreeId(ByteStreamUtils.popIntFromByteQueue(byteBuffer)); rVal.setfieldId(byteBuffer.getInt());
rVal.setfieldId(ByteStreamUtils.popIntFromByteQueue(byteBuffer)); rVal.setdoubleValue(byteBuffer.getDouble());
rVal.setdoubleValue(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer));
return rVal; return rVal;
} }
@ -457,13 +365,15 @@ public class SynchronizationMessage extends NetworkMessage {
/** /**
* Parses a message of type ClientRequestBTreeAction * Parses a message of type ClientRequestBTreeAction
*/ */
public static SynchronizationMessage parseClientRequestBTreeActionMessage(CircularByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,CircularByteBuffer>> customParserMap){ public static SynchronizationMessage parseClientRequestBTreeActionMessage(ByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,ByteBuffer>> customParserMap){
if(byteBuffer.remaining() < 12){
return null;
}
SynchronizationMessage rVal = (SynchronizationMessage)pool.get(MessageType.SYNCHRONIZATION_MESSAGE); SynchronizationMessage rVal = (SynchronizationMessage)pool.get(MessageType.SYNCHRONIZATION_MESSAGE);
rVal.messageType = SynchronizationMessageType.CLIENTREQUESTBTREEACTION; rVal.messageType = SynchronizationMessageType.CLIENTREQUESTBTREEACTION;
SynchronizationMessage.stripPacketHeader(byteBuffer); rVal.setentityId(byteBuffer.getInt());
rVal.setentityId(ByteStreamUtils.popIntFromByteQueue(byteBuffer)); rVal.setbTreeId(byteBuffer.getInt());
rVal.setbTreeId(ByteStreamUtils.popIntFromByteQueue(byteBuffer)); rVal.setbTreeValue(byteBuffer.getInt());
rVal.setbTreeValue(ByteStreamUtils.popIntFromByteQueue(byteBuffer));
return rVal; return rVal;
} }
@ -481,14 +391,16 @@ public class SynchronizationMessage extends NetworkMessage {
/** /**
* Parses a message of type ServerNotifyBTreeTransition * Parses a message of type ServerNotifyBTreeTransition
*/ */
public static SynchronizationMessage parseServerNotifyBTreeTransitionMessage(CircularByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,CircularByteBuffer>> customParserMap){ public static SynchronizationMessage parseServerNotifyBTreeTransitionMessage(ByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,ByteBuffer>> customParserMap){
if(byteBuffer.remaining() < 16){
return null;
}
SynchronizationMessage rVal = (SynchronizationMessage)pool.get(MessageType.SYNCHRONIZATION_MESSAGE); SynchronizationMessage rVal = (SynchronizationMessage)pool.get(MessageType.SYNCHRONIZATION_MESSAGE);
rVal.messageType = SynchronizationMessageType.SERVERNOTIFYBTREETRANSITION; rVal.messageType = SynchronizationMessageType.SERVERNOTIFYBTREETRANSITION;
SynchronizationMessage.stripPacketHeader(byteBuffer); rVal.setentityId(byteBuffer.getInt());
rVal.setentityId(ByteStreamUtils.popIntFromByteQueue(byteBuffer)); rVal.setbTreeId(byteBuffer.getInt());
rVal.setbTreeId(ByteStreamUtils.popIntFromByteQueue(byteBuffer)); rVal.setfieldId(byteBuffer.getInt());
rVal.setfieldId(ByteStreamUtils.popIntFromByteQueue(byteBuffer)); rVal.setbTreeValue(byteBuffer.getInt());
rVal.setbTreeValue(ByteStreamUtils.popIntFromByteQueue(byteBuffer));
return rVal; return rVal;
} }
@ -507,12 +419,14 @@ public class SynchronizationMessage extends NetworkMessage {
/** /**
* Parses a message of type AttachTree * Parses a message of type AttachTree
*/ */
public static SynchronizationMessage parseAttachTreeMessage(CircularByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,CircularByteBuffer>> customParserMap){ public static SynchronizationMessage parseAttachTreeMessage(ByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,ByteBuffer>> customParserMap){
if(byteBuffer.remaining() < 8){
return null;
}
SynchronizationMessage rVal = (SynchronizationMessage)pool.get(MessageType.SYNCHRONIZATION_MESSAGE); SynchronizationMessage rVal = (SynchronizationMessage)pool.get(MessageType.SYNCHRONIZATION_MESSAGE);
rVal.messageType = SynchronizationMessageType.ATTACHTREE; rVal.messageType = SynchronizationMessageType.ATTACHTREE;
SynchronizationMessage.stripPacketHeader(byteBuffer); rVal.setentityId(byteBuffer.getInt());
rVal.setentityId(ByteStreamUtils.popIntFromByteQueue(byteBuffer)); rVal.setbTreeId(byteBuffer.getInt());
rVal.setbTreeId(ByteStreamUtils.popIntFromByteQueue(byteBuffer));
return rVal; return rVal;
} }
@ -529,12 +443,14 @@ public class SynchronizationMessage extends NetworkMessage {
/** /**
* Parses a message of type DetatchTree * Parses a message of type DetatchTree
*/ */
public static SynchronizationMessage parseDetatchTreeMessage(CircularByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,CircularByteBuffer>> customParserMap){ public static SynchronizationMessage parseDetatchTreeMessage(ByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,ByteBuffer>> customParserMap){
if(byteBuffer.remaining() < 8){
return null;
}
SynchronizationMessage rVal = (SynchronizationMessage)pool.get(MessageType.SYNCHRONIZATION_MESSAGE); SynchronizationMessage rVal = (SynchronizationMessage)pool.get(MessageType.SYNCHRONIZATION_MESSAGE);
rVal.messageType = SynchronizationMessageType.DETATCHTREE; rVal.messageType = SynchronizationMessageType.DETATCHTREE;
SynchronizationMessage.stripPacketHeader(byteBuffer); rVal.setentityId(byteBuffer.getInt());
rVal.setentityId(ByteStreamUtils.popIntFromByteQueue(byteBuffer)); rVal.setbTreeId(byteBuffer.getInt());
rVal.setbTreeId(ByteStreamUtils.popIntFromByteQueue(byteBuffer));
return rVal; return rVal;
} }
@ -548,36 +464,24 @@ public class SynchronizationMessage extends NetworkMessage {
return rVal; return rVal;
} }
/**
* Checks if a message of type LoadScene can be parsed from the byte stream
*/
public static boolean canParseLoadSceneMessage(CircularByteBuffer byteBuffer){
int currentStreamLength = byteBuffer.getRemaining();
List<Byte> temporaryByteQueue = new LinkedList<Byte>();
int stringValueSize = 0;
if(currentStreamLength < 6){
return false;
} else {
temporaryByteQueue.add(byteBuffer.peek(2 + 0));
temporaryByteQueue.add(byteBuffer.peek(2 + 1));
temporaryByteQueue.add(byteBuffer.peek(2 + 2));
temporaryByteQueue.add(byteBuffer.peek(2 + 3));
stringValueSize = ByteStreamUtils.popIntFromByteQueue(temporaryByteQueue);
}
if(currentStreamLength < 6 + stringValueSize){
return false;
}
return true;
}
/** /**
* Parses a message of type LoadScene * Parses a message of type LoadScene
*/ */
public static SynchronizationMessage parseLoadSceneMessage(CircularByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,CircularByteBuffer>> customParserMap){ public static SynchronizationMessage parseLoadSceneMessage(ByteBuffer byteBuffer, MessagePool pool, Map<Short,BiConsumer<NetworkMessage,ByteBuffer>> customParserMap){
if(byteBuffer.remaining() < 4){
return null;
}
int lenAccumulator = 0;
int stringValuelen = byteBuffer.getInt();
lenAccumulator = lenAccumulator + stringValuelen;
if(byteBuffer.remaining() < 4 + lenAccumulator){
return null;
}
SynchronizationMessage rVal = (SynchronizationMessage)pool.get(MessageType.SYNCHRONIZATION_MESSAGE); SynchronizationMessage rVal = (SynchronizationMessage)pool.get(MessageType.SYNCHRONIZATION_MESSAGE);
rVal.messageType = SynchronizationMessageType.LOADSCENE; rVal.messageType = SynchronizationMessageType.LOADSCENE;
SynchronizationMessage.stripPacketHeader(byteBuffer); if(stringValuelen > 0){
rVal.setstringValue(ByteStreamUtils.popStringFromByteQueue(byteBuffer)); rVal.setstringValue(ByteStreamUtils.popStringFromByteBuffer(byteBuffer, stringValuelen));
}
return rVal; return rVal;
} }
@ -831,97 +735,160 @@ public class SynchronizationMessage extends NetworkMessage {
@Override @Override
public void write(OutputStream stream) throws IOException { public void write(OutputStream stream) throws IOException {
switch(this.messageType){ switch(this.messageType){
case UPDATECLIENTSTATE: case UPDATECLIENTSTATE: {
//
//message header //message header
stream.write(TypeBytes.MESSAGE_TYPE_SYNCHRONIZATION); stream.write(TypeBytes.MESSAGE_TYPE_SYNCHRONIZATION);
stream.write(TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_UPDATECLIENTSTATE); stream.write(TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_UPDATECLIENTSTATE);
//
//Write body of packet
ByteStreamUtils.writeInt(stream, entityId); ByteStreamUtils.writeInt(stream, entityId);
ByteStreamUtils.writeInt(stream, bTreeId); ByteStreamUtils.writeInt(stream, bTreeId);
ByteStreamUtils.writeInt(stream, fieldId); ByteStreamUtils.writeInt(stream, fieldId);
ByteStreamUtils.writeInt(stream, bTreeValue); ByteStreamUtils.writeInt(stream, bTreeValue);
break; } break;
case UPDATECLIENTSTRINGSTATE: case UPDATECLIENTSTRINGSTATE: {
//
//message header //message header
stream.write(TypeBytes.MESSAGE_TYPE_SYNCHRONIZATION); stream.write(TypeBytes.MESSAGE_TYPE_SYNCHRONIZATION);
stream.write(TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_UPDATECLIENTSTRINGSTATE); stream.write(TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_UPDATECLIENTSTRINGSTATE);
//
//Write variable length table in packet
ByteStreamUtils.writeInt(stream, stringValue.length());
//
//Write body of packet
ByteStreamUtils.writeInt(stream, entityId); ByteStreamUtils.writeInt(stream, entityId);
ByteStreamUtils.writeInt(stream, bTreeId); ByteStreamUtils.writeInt(stream, bTreeId);
ByteStreamUtils.writeInt(stream, fieldId); ByteStreamUtils.writeInt(stream, fieldId);
ByteStreamUtils.writeString(stream, stringValue); ByteStreamUtils.writeString(stream, stringValue);
break; } break;
case UPDATECLIENTINTSTATE: case UPDATECLIENTINTSTATE: {
//
//message header //message header
stream.write(TypeBytes.MESSAGE_TYPE_SYNCHRONIZATION); stream.write(TypeBytes.MESSAGE_TYPE_SYNCHRONIZATION);
stream.write(TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_UPDATECLIENTINTSTATE); stream.write(TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_UPDATECLIENTINTSTATE);
//
//Write body of packet
ByteStreamUtils.writeInt(stream, entityId); ByteStreamUtils.writeInt(stream, entityId);
ByteStreamUtils.writeInt(stream, bTreeId); ByteStreamUtils.writeInt(stream, bTreeId);
ByteStreamUtils.writeInt(stream, fieldId); ByteStreamUtils.writeInt(stream, fieldId);
ByteStreamUtils.writeInt(stream, intValue); ByteStreamUtils.writeInt(stream, intValue);
break; } break;
case UPDATECLIENTLONGSTATE: case UPDATECLIENTLONGSTATE: {
//
//message header //message header
stream.write(TypeBytes.MESSAGE_TYPE_SYNCHRONIZATION); stream.write(TypeBytes.MESSAGE_TYPE_SYNCHRONIZATION);
stream.write(TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_UPDATECLIENTLONGSTATE); stream.write(TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_UPDATECLIENTLONGSTATE);
//
//Write body of packet
ByteStreamUtils.writeInt(stream, entityId); ByteStreamUtils.writeInt(stream, entityId);
ByteStreamUtils.writeInt(stream, bTreeId); ByteStreamUtils.writeInt(stream, bTreeId);
ByteStreamUtils.writeInt(stream, fieldId); ByteStreamUtils.writeInt(stream, fieldId);
ByteStreamUtils.writeLong(stream, longValue); ByteStreamUtils.writeLong(stream, longValue);
break; } break;
case UPDATECLIENTFLOATSTATE: case UPDATECLIENTFLOATSTATE: {
//
//message header //message header
stream.write(TypeBytes.MESSAGE_TYPE_SYNCHRONIZATION); stream.write(TypeBytes.MESSAGE_TYPE_SYNCHRONIZATION);
stream.write(TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_UPDATECLIENTFLOATSTATE); stream.write(TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_UPDATECLIENTFLOATSTATE);
//
//Write body of packet
ByteStreamUtils.writeInt(stream, entityId); ByteStreamUtils.writeInt(stream, entityId);
ByteStreamUtils.writeInt(stream, bTreeId); ByteStreamUtils.writeInt(stream, bTreeId);
ByteStreamUtils.writeInt(stream, fieldId); ByteStreamUtils.writeInt(stream, fieldId);
ByteStreamUtils.writeFloat(stream, floatValue); ByteStreamUtils.writeFloat(stream, floatValue);
break; } break;
case UPDATECLIENTDOUBLESTATE: case UPDATECLIENTDOUBLESTATE: {
//
//message header //message header
stream.write(TypeBytes.MESSAGE_TYPE_SYNCHRONIZATION); stream.write(TypeBytes.MESSAGE_TYPE_SYNCHRONIZATION);
stream.write(TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_UPDATECLIENTDOUBLESTATE); stream.write(TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_UPDATECLIENTDOUBLESTATE);
//
//Write body of packet
ByteStreamUtils.writeInt(stream, entityId); ByteStreamUtils.writeInt(stream, entityId);
ByteStreamUtils.writeInt(stream, bTreeId); ByteStreamUtils.writeInt(stream, bTreeId);
ByteStreamUtils.writeInt(stream, fieldId); ByteStreamUtils.writeInt(stream, fieldId);
ByteStreamUtils.writeDouble(stream, doubleValue); ByteStreamUtils.writeDouble(stream, doubleValue);
break; } break;
case CLIENTREQUESTBTREEACTION: case CLIENTREQUESTBTREEACTION: {
//
//message header //message header
stream.write(TypeBytes.MESSAGE_TYPE_SYNCHRONIZATION); stream.write(TypeBytes.MESSAGE_TYPE_SYNCHRONIZATION);
stream.write(TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_CLIENTREQUESTBTREEACTION); stream.write(TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_CLIENTREQUESTBTREEACTION);
//
//Write body of packet
ByteStreamUtils.writeInt(stream, entityId); ByteStreamUtils.writeInt(stream, entityId);
ByteStreamUtils.writeInt(stream, bTreeId); ByteStreamUtils.writeInt(stream, bTreeId);
ByteStreamUtils.writeInt(stream, bTreeValue); ByteStreamUtils.writeInt(stream, bTreeValue);
break; } break;
case SERVERNOTIFYBTREETRANSITION: case SERVERNOTIFYBTREETRANSITION: {
//
//message header //message header
stream.write(TypeBytes.MESSAGE_TYPE_SYNCHRONIZATION); stream.write(TypeBytes.MESSAGE_TYPE_SYNCHRONIZATION);
stream.write(TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_SERVERNOTIFYBTREETRANSITION); stream.write(TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_SERVERNOTIFYBTREETRANSITION);
//
//Write body of packet
ByteStreamUtils.writeInt(stream, entityId); ByteStreamUtils.writeInt(stream, entityId);
ByteStreamUtils.writeInt(stream, bTreeId); ByteStreamUtils.writeInt(stream, bTreeId);
ByteStreamUtils.writeInt(stream, fieldId); ByteStreamUtils.writeInt(stream, fieldId);
ByteStreamUtils.writeInt(stream, bTreeValue); ByteStreamUtils.writeInt(stream, bTreeValue);
break; } break;
case ATTACHTREE: case ATTACHTREE: {
//
//message header //message header
stream.write(TypeBytes.MESSAGE_TYPE_SYNCHRONIZATION); stream.write(TypeBytes.MESSAGE_TYPE_SYNCHRONIZATION);
stream.write(TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_ATTACHTREE); stream.write(TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_ATTACHTREE);
//
//Write body of packet
ByteStreamUtils.writeInt(stream, entityId); ByteStreamUtils.writeInt(stream, entityId);
ByteStreamUtils.writeInt(stream, bTreeId); ByteStreamUtils.writeInt(stream, bTreeId);
break; } break;
case DETATCHTREE: case DETATCHTREE: {
//
//message header //message header
stream.write(TypeBytes.MESSAGE_TYPE_SYNCHRONIZATION); stream.write(TypeBytes.MESSAGE_TYPE_SYNCHRONIZATION);
stream.write(TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_DETATCHTREE); stream.write(TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_DETATCHTREE);
//
//Write body of packet
ByteStreamUtils.writeInt(stream, entityId); ByteStreamUtils.writeInt(stream, entityId);
ByteStreamUtils.writeInt(stream, bTreeId); ByteStreamUtils.writeInt(stream, bTreeId);
break; } break;
case LOADSCENE: case LOADSCENE: {
//
//message header //message header
stream.write(TypeBytes.MESSAGE_TYPE_SYNCHRONIZATION); stream.write(TypeBytes.MESSAGE_TYPE_SYNCHRONIZATION);
stream.write(TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_LOADSCENE); stream.write(TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_LOADSCENE);
//
//Write variable length table in packet
ByteStreamUtils.writeInt(stream, stringValue.length());
//
//Write body of packet
ByteStreamUtils.writeString(stream, stringValue); ByteStreamUtils.writeString(stream, stringValue);
break; } break;
} }
} }

875
src/main/java/electrosphere/net/parser/net/message/TerrainMessage.java
View File

File diff suppressed because it is too large Load Diff

66
src/main/java/electrosphere/net/parser/net/raw/NetworkParser.java
View File

@ -2,10 +2,10 @@ package electrosphere.net.parser.net.raw;
import electrosphere.net.parser.net.message.MessagePool; import electrosphere.net.parser.net.message.MessagePool;
import electrosphere.net.parser.net.message.NetworkMessage; import electrosphere.net.parser.net.message.NetworkMessage;
import io.github.studiorailgun.CircularByteBuffer;
import java.io.IOException; import java.io.IOException;
import java.io.InputStream; import java.io.InputStream;
import java.io.OutputStream; import java.io.OutputStream;
import java.nio.ByteBuffer;
import java.util.HashMap; import java.util.HashMap;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
@ -55,7 +55,7 @@ public class NetworkParser {
/** /**
* The byte buffer for storing incoming bytes * The byte buffer for storing incoming bytes
*/ */
private CircularByteBuffer incomingByteBuffer = new CircularByteBuffer(CIRCULAR_BUFFER_SIZE); private ByteBuffer incomingByteBuffer = ByteBuffer.allocate(CIRCULAR_BUFFER_SIZE);
/** /**
* The block array used to read blocks of bytes in * The block array used to read blocks of bytes in
@ -67,6 +67,11 @@ public class NetworkParser {
*/ */
private long totalBytesRead = 0; private long totalBytesRead = 0;
/**
* Number of bytes preserved between read calls
*/
private int existingBytes = 0;
/** /**
* If set to true, the parser will automatically release messages on send. * If set to true, the parser will automatically release messages on send.
* Otherwise, will not release when the message is sent. * Otherwise, will not release when the message is sent.
@ -76,7 +81,7 @@ public class NetworkParser {
/** /**
* The map of messasge type -> custom function to produce the message from a byte stream * The map of messasge type -> custom function to produce the message from a byte stream
*/ */
private Map<Short,BiConsumer<NetworkMessage,CircularByteBuffer>> customParserMap = new HashMap<Short,BiConsumer<NetworkMessage,CircularByteBuffer>>(); private Map<Short,BiConsumer<NetworkMessage,ByteBuffer>> customParserMap = new HashMap<Short,BiConsumer<NetworkMessage,ByteBuffer>>();
/** /**
@ -95,20 +100,61 @@ public class NetworkParser {
public void readMessagesIn() throws IOException { public void readMessagesIn() throws IOException {
//read in bytes //read in bytes
int bytesRead = 0; int bytesRead = 0;
while(incomingStream.available() > 0){ if(incomingStream.available() > 0){
// nextValue = incomingStream.read(); //error check
bytesRead = incomingStream.read(readBuffer, 0, READ_BLOCK_SIZE); if(incomingByteBuffer.position() > 0){
if(bytesRead > 0){ String message = "Invalid position!\n" +
incomingByteBuffer.add(readBuffer, bytesRead); "position: " + incomingByteBuffer.position() + "\n" +
"limit: " + incomingByteBuffer.limit() + "\n" +
"remaining: " + incomingByteBuffer.remaining() + "\n" +
"byte [0]: " + incomingByteBuffer.get(0) + "\n" +
"byte [1]: " + incomingByteBuffer.get(1) + "\n" +
"";
throw new Error(message);
} }
//make sure we have room to write
incomingByteBuffer.limit(CIRCULAR_BUFFER_SIZE);
incomingByteBuffer.position(existingBytes);
//read bytes into buffer
bytesRead = incomingStream.read(readBuffer, 0, READ_BLOCK_SIZE);
incomingByteBuffer.put(readBuffer, 0, bytesRead);
//fake flip
incomingByteBuffer.position(0);
incomingByteBuffer.limit(existingBytes + bytesRead);
existingBytes = existingBytes + bytesRead;
//tracking
totalBytesRead = totalBytesRead + bytesRead; totalBytesRead = totalBytesRead + bytesRead;
} }
//parse byte queue for messages //parse byte queue for messages
//for each message, append to clientIncomingMessageQueue //for each message, append to clientIncomingMessageQueue
NetworkMessage newMessage; NetworkMessage newMessage;
while((newMessage = NetworkMessage.parseBytestreamForMessage(incomingByteBuffer,this.pool,this.customParserMap))!=null){ if(existingBytes > 0 || bytesRead > 0){
while((newMessage = NetworkMessage.parseBytestreamForMessage(incomingByteBuffer,this.pool,this.customParserMap)) != null){
incomingMessageQueue.add(newMessage); incomingMessageQueue.add(newMessage);
} }
//compact the byte buffer
incomingByteBuffer.compact();
existingBytes = incomingByteBuffer.position();
incomingByteBuffer.position(0);
incomingByteBuffer.limit(existingBytes);
//error check
if(CIRCULAR_BUFFER_SIZE - existingBytes < READ_BLOCK_SIZE){
String message = "Failed to parse messages!\n" +
"position: " + incomingByteBuffer.position() + "\n" +
"limit: " + incomingByteBuffer.limit() + "\n" +
"remaining: " + incomingByteBuffer.remaining() + "\n" +
"byte [0]: " + incomingByteBuffer.get(0) + "\n" +
"byte [1]: " + incomingByteBuffer.get(1) + "\n" +
"";
throw new Error(message);
}
}
} }
/** /**
@ -204,7 +250,7 @@ public class NetworkParser {
* @param messageSubtype The subtype of the message * @param messageSubtype The subtype of the message
* @param parserFunc The parser function * @param parserFunc The parser function
*/ */
public void registerCustomParser(byte messageType, byte messageSubtype, BiConsumer<NetworkMessage,CircularByteBuffer> parserFunc){ public void registerCustomParser(byte messageType, byte messageSubtype, BiConsumer<NetworkMessage,ByteBuffer> parserFunc){
short pair = (short)((messageType << 4) & messageSubtype); short pair = (short)((messageType << 4) & messageSubtype);
this.customParserMap.put(pair,parserFunc); this.customParserMap.put(pair,parserFunc);
} }

15
src/main/java/electrosphere/net/parser/util/ByteStreamUtils.java
View File

@ -82,6 +82,13 @@ public class ByteStreamUtils {
return rVal; return rVal;
} }
public static String popStringFromByteBuffer(ByteBuffer buff, int len){
byte[] dest = new byte[len];
buff.get(dest, 0, len);
String rVal = new String(dest);
return rVal;
}
public static byte[] popByteArrayFromByteQueue(List<Byte> queue){ public static byte[] popByteArrayFromByteQueue(List<Byte> queue){
int length = popIntFromByteQueue(queue); int length = popIntFromByteQueue(queue);
byte[] bytes = new byte[length]; byte[] bytes = new byte[length];
@ -91,6 +98,12 @@ public class ByteStreamUtils {
return bytes; return bytes;
} }
public static byte[] popByteArrayFromByteBuffer(ByteBuffer buff, int len){
byte[] dest = new byte[len];
buff.get(dest, 0, len);
return dest;
}
public static double popDoubleFromByteQueue(List<Byte> queue){ public static double popDoubleFromByteQueue(List<Byte> queue){
double rVal = -1; double rVal = -1;
bufferLock.acquireUninterruptibly(); bufferLock.acquireUninterruptibly();
@ -359,8 +372,6 @@ public class ByteStreamUtils {
} }
public static void writeString(OutputStream stream, String s) throws IOException { public static void writeString(OutputStream stream, String s) throws IOException {
int length = s.length();
writeInt(stream, length);
byte[] stringBytes = s.getBytes(); byte[] stringBytes = s.getBytes();
stream.write(stringBytes); stream.write(stringBytes);
} }