NetArranger no allocation on read block
Some checks failed
studiorailgun/Renderer/pipeline/head There was a failure building this commit
Some checks failed
studiorailgun/Renderer/pipeline/head There was a failure building this commit
This commit is contained in:
austin
parent
ac13a458fd
commit
0d77c4e571
@ -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.ServerMessage.ServerMessageType;
|
||||
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.InputStream;
|
||||
import java.io.OutputStream;
|
||||
import java.net.Socket;
|
||||
import java.nio.ByteBuffer;
|
||||
import java.util.LinkedList;
|
||||
import java.util.List;
|
||||
import java.util.concurrent.TimeUnit;
|
||||
@ -178,32 +177,33 @@ public class ClientNetworking implements Runnable {
|
||||
|
||||
//
|
||||
//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;
|
||||
castMessage.setworldX(ByteStreamUtils.popIntFromByteQueue(buff));
|
||||
castMessage.setworldY(ByteStreamUtils.popIntFromByteQueue(buff));
|
||||
castMessage.setworldZ(ByteStreamUtils.popIntFromByteQueue(buff));
|
||||
castMessage.setchunkResolution(ByteStreamUtils.popIntFromByteQueue(buff));
|
||||
castMessage.sethomogenousValue(ByteStreamUtils.popIntFromByteQueue(buff));
|
||||
//strip the byte stream header
|
||||
ByteStreamUtils.popIntFromByteQueue(buff);
|
||||
//get meta data
|
||||
castMessage.setworldX(buff.getInt());
|
||||
castMessage.setworldY(buff.getInt());
|
||||
castMessage.setworldZ(buff.getInt());
|
||||
castMessage.setchunkResolution(buff.getInt());
|
||||
castMessage.sethomogenousValue(buff.getInt());
|
||||
|
||||
//get main data blob
|
||||
if(castMessage.gethomogenousValue() == BlockChunkData.NOT_HOMOGENOUS){
|
||||
//read types from byte stream
|
||||
short[] types = BlockChunkPool.getShort();
|
||||
for(int i = 0; i < BlockChunkData.TOTAL_DATA_WIDTH; i++){
|
||||
types[i] = ByteStreamUtils.popShortFromByteQueue(buff);
|
||||
types[i] = buff.getShort();
|
||||
}
|
||||
//read metadata from byte stream
|
||||
short[] metadata = BlockChunkPool.getShort();
|
||||
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>();
|
||||
extraData.add(types);
|
||||
extraData.add(metadata);
|
||||
castMessage.setExtraData(extraData);
|
||||
} else {
|
||||
buff.read(1);
|
||||
buff.get();
|
||||
}
|
||||
});
|
||||
|
||||
|
||||
@ -2,11 +2,8 @@ package electrosphere.net.parser.net.message;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.io.OutputStream;
|
||||
import io.github.studiorailgun.CircularByteBuffer;
|
||||
import java.nio.ByteBuffer;
|
||||
import electrosphere.net.parser.util.ByteStreamUtils;
|
||||
import java.util.LinkedList;
|
||||
import java.util.List;
|
||||
|
||||
import java.util.Map;
|
||||
import java.util.function.BiConsumer;
|
||||
|
||||
@ -77,53 +74,15 @@ public class AuthMessage extends NetworkMessage {
|
||||
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
|
||||
*/
|
||||
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);
|
||||
rVal.messageType = AuthMessageType.AUTHREQUEST;
|
||||
AuthMessage.stripPacketHeader(byteBuffer);
|
||||
return rVal;
|
||||
}
|
||||
|
||||
@ -135,50 +94,29 @@ public class AuthMessage extends NetworkMessage {
|
||||
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
|
||||
*/
|
||||
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);
|
||||
rVal.messageType = AuthMessageType.AUTHDETAILS;
|
||||
AuthMessage.stripPacketHeader(byteBuffer);
|
||||
rVal.setuser(ByteStreamUtils.popStringFromByteQueue(byteBuffer));
|
||||
rVal.setpass(ByteStreamUtils.popStringFromByteQueue(byteBuffer));
|
||||
if(userlen > 0){
|
||||
rVal.setuser(ByteStreamUtils.popStringFromByteBuffer(byteBuffer, userlen));
|
||||
}
|
||||
if(passlen > 0){
|
||||
rVal.setpass(ByteStreamUtils.popStringFromByteBuffer(byteBuffer, passlen));
|
||||
}
|
||||
return rVal;
|
||||
}
|
||||
|
||||
@ -195,10 +133,12 @@ public class AuthMessage extends NetworkMessage {
|
||||
/**
|
||||
* 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);
|
||||
rVal.messageType = AuthMessageType.AUTHSUCCESS;
|
||||
AuthMessage.stripPacketHeader(byteBuffer);
|
||||
return rVal;
|
||||
}
|
||||
|
||||
@ -213,10 +153,12 @@ public class AuthMessage extends NetworkMessage {
|
||||
/**
|
||||
* 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);
|
||||
rVal.messageType = AuthMessageType.AUTHFAILURE;
|
||||
AuthMessage.stripPacketHeader(byteBuffer);
|
||||
return rVal;
|
||||
}
|
||||
|
||||
@ -285,28 +227,53 @@ public class AuthMessage extends NetworkMessage {
|
||||
@Override
|
||||
public void write(OutputStream stream) throws IOException {
|
||||
switch(this.messageType){
|
||||
case AUTHREQUEST:
|
||||
case AUTHREQUEST: {
|
||||
|
||||
//
|
||||
//message header
|
||||
stream.write(TypeBytes.MESSAGE_TYPE_AUTH);
|
||||
stream.write(TypeBytes.AUTH_MESSAGE_TYPE_AUTHREQUEST);
|
||||
break;
|
||||
case AUTHDETAILS:
|
||||
|
||||
//
|
||||
//Write body of packet
|
||||
} break;
|
||||
case AUTHDETAILS: {
|
||||
|
||||
//
|
||||
//message header
|
||||
stream.write(TypeBytes.MESSAGE_TYPE_AUTH);
|
||||
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, pass);
|
||||
break;
|
||||
case AUTHSUCCESS:
|
||||
} break;
|
||||
case AUTHSUCCESS: {
|
||||
|
||||
//
|
||||
//message header
|
||||
stream.write(TypeBytes.MESSAGE_TYPE_AUTH);
|
||||
stream.write(TypeBytes.AUTH_MESSAGE_TYPE_AUTHSUCCESS);
|
||||
break;
|
||||
case AUTHFAILURE:
|
||||
|
||||
//
|
||||
//Write body of packet
|
||||
} break;
|
||||
case AUTHFAILURE: {
|
||||
|
||||
//
|
||||
//message header
|
||||
stream.write(TypeBytes.MESSAGE_TYPE_AUTH);
|
||||
stream.write(TypeBytes.AUTH_MESSAGE_TYPE_AUTHFAILURE);
|
||||
break;
|
||||
|
||||
//
|
||||
//Write body of packet
|
||||
} break;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -2,11 +2,8 @@ package electrosphere.net.parser.net.message;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.io.OutputStream;
|
||||
import io.github.studiorailgun.CircularByteBuffer;
|
||||
import java.nio.ByteBuffer;
|
||||
import electrosphere.net.parser.util.ByteStreamUtils;
|
||||
import java.util.LinkedList;
|
||||
import java.util.List;
|
||||
|
||||
import java.util.Map;
|
||||
import java.util.function.BiConsumer;
|
||||
|
||||
@ -66,65 +63,15 @@ public class CharacterMessage extends NetworkMessage {
|
||||
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
|
||||
*/
|
||||
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);
|
||||
rVal.messageType = CharacterMessageType.REQUESTCHARACTERLIST;
|
||||
CharacterMessage.stripPacketHeader(byteBuffer);
|
||||
return rVal;
|
||||
}
|
||||
|
||||
@ -136,36 +83,24 @@ public class CharacterMessage extends NetworkMessage {
|
||||
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
|
||||
*/
|
||||
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);
|
||||
rVal.messageType = CharacterMessageType.RESPONSECHARACTERLIST;
|
||||
CharacterMessage.stripPacketHeader(byteBuffer);
|
||||
rVal.setdata(ByteStreamUtils.popStringFromByteQueue(byteBuffer));
|
||||
if(datalen > 0){
|
||||
rVal.setdata(ByteStreamUtils.popStringFromByteBuffer(byteBuffer, datalen));
|
||||
}
|
||||
return rVal;
|
||||
}
|
||||
|
||||
@ -178,36 +113,24 @@ public class CharacterMessage extends NetworkMessage {
|
||||
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
|
||||
*/
|
||||
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);
|
||||
rVal.messageType = CharacterMessageType.REQUESTCREATECHARACTER;
|
||||
CharacterMessage.stripPacketHeader(byteBuffer);
|
||||
rVal.setdata(ByteStreamUtils.popStringFromByteQueue(byteBuffer));
|
||||
if(datalen > 0){
|
||||
rVal.setdata(ByteStreamUtils.popStringFromByteBuffer(byteBuffer, datalen));
|
||||
}
|
||||
return rVal;
|
||||
}
|
||||
|
||||
@ -223,10 +146,12 @@ public class CharacterMessage extends NetworkMessage {
|
||||
/**
|
||||
* 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);
|
||||
rVal.messageType = CharacterMessageType.RESPONSECREATECHARACTERSUCCESS;
|
||||
CharacterMessage.stripPacketHeader(byteBuffer);
|
||||
return rVal;
|
||||
}
|
||||
|
||||
@ -241,10 +166,12 @@ public class CharacterMessage extends NetworkMessage {
|
||||
/**
|
||||
* 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);
|
||||
rVal.messageType = CharacterMessageType.RESPONSECREATECHARACTERFAILURE;
|
||||
CharacterMessage.stripPacketHeader(byteBuffer);
|
||||
return rVal;
|
||||
}
|
||||
|
||||
@ -256,36 +183,24 @@ public class CharacterMessage extends NetworkMessage {
|
||||
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
|
||||
*/
|
||||
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);
|
||||
rVal.messageType = CharacterMessageType.REQUESTSPAWNCHARACTER;
|
||||
CharacterMessage.stripPacketHeader(byteBuffer);
|
||||
rVal.setdata(ByteStreamUtils.popStringFromByteQueue(byteBuffer));
|
||||
if(datalen > 0){
|
||||
rVal.setdata(ByteStreamUtils.popStringFromByteBuffer(byteBuffer, datalen));
|
||||
}
|
||||
return rVal;
|
||||
}
|
||||
|
||||
@ -298,36 +213,24 @@ public class CharacterMessage extends NetworkMessage {
|
||||
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
|
||||
*/
|
||||
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);
|
||||
rVal.messageType = CharacterMessageType.RESPONSESPAWNCHARACTER;
|
||||
CharacterMessage.stripPacketHeader(byteBuffer);
|
||||
rVal.setdata(ByteStreamUtils.popStringFromByteQueue(byteBuffer));
|
||||
if(datalen > 0){
|
||||
rVal.setdata(ByteStreamUtils.popStringFromByteBuffer(byteBuffer, datalen));
|
||||
}
|
||||
return rVal;
|
||||
}
|
||||
|
||||
@ -343,10 +246,12 @@ public class CharacterMessage extends NetworkMessage {
|
||||
/**
|
||||
* 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);
|
||||
rVal.messageType = CharacterMessageType.EDITORSWAP;
|
||||
CharacterMessage.stripPacketHeader(byteBuffer);
|
||||
return rVal;
|
||||
}
|
||||
|
||||
@ -459,50 +364,106 @@ public class CharacterMessage extends NetworkMessage {
|
||||
@Override
|
||||
public void write(OutputStream stream) throws IOException {
|
||||
switch(this.messageType){
|
||||
case REQUESTCHARACTERLIST:
|
||||
case REQUESTCHARACTERLIST: {
|
||||
|
||||
//
|
||||
//message header
|
||||
stream.write(TypeBytes.MESSAGE_TYPE_CHARACTER);
|
||||
stream.write(TypeBytes.CHARACTER_MESSAGE_TYPE_REQUESTCHARACTERLIST);
|
||||
break;
|
||||
case RESPONSECHARACTERLIST:
|
||||
|
||||
//
|
||||
//Write body of packet
|
||||
} break;
|
||||
case RESPONSECHARACTERLIST: {
|
||||
|
||||
//
|
||||
//message header
|
||||
stream.write(TypeBytes.MESSAGE_TYPE_CHARACTER);
|
||||
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);
|
||||
break;
|
||||
case REQUESTCREATECHARACTER:
|
||||
} break;
|
||||
case REQUESTCREATECHARACTER: {
|
||||
|
||||
//
|
||||
//message header
|
||||
stream.write(TypeBytes.MESSAGE_TYPE_CHARACTER);
|
||||
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);
|
||||
break;
|
||||
case RESPONSECREATECHARACTERSUCCESS:
|
||||
} break;
|
||||
case RESPONSECREATECHARACTERSUCCESS: {
|
||||
|
||||
//
|
||||
//message header
|
||||
stream.write(TypeBytes.MESSAGE_TYPE_CHARACTER);
|
||||
stream.write(TypeBytes.CHARACTER_MESSAGE_TYPE_RESPONSECREATECHARACTERSUCCESS);
|
||||
break;
|
||||
case RESPONSECREATECHARACTERFAILURE:
|
||||
|
||||
//
|
||||
//Write body of packet
|
||||
} break;
|
||||
case RESPONSECREATECHARACTERFAILURE: {
|
||||
|
||||
//
|
||||
//message header
|
||||
stream.write(TypeBytes.MESSAGE_TYPE_CHARACTER);
|
||||
stream.write(TypeBytes.CHARACTER_MESSAGE_TYPE_RESPONSECREATECHARACTERFAILURE);
|
||||
break;
|
||||
case REQUESTSPAWNCHARACTER:
|
||||
|
||||
//
|
||||
//Write body of packet
|
||||
} break;
|
||||
case REQUESTSPAWNCHARACTER: {
|
||||
|
||||
//
|
||||
//message header
|
||||
stream.write(TypeBytes.MESSAGE_TYPE_CHARACTER);
|
||||
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);
|
||||
break;
|
||||
case RESPONSESPAWNCHARACTER:
|
||||
} break;
|
||||
case RESPONSESPAWNCHARACTER: {
|
||||
|
||||
//
|
||||
//message header
|
||||
stream.write(TypeBytes.MESSAGE_TYPE_CHARACTER);
|
||||
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);
|
||||
break;
|
||||
case EDITORSWAP:
|
||||
} break;
|
||||
case EDITORSWAP: {
|
||||
|
||||
//
|
||||
//message header
|
||||
stream.write(TypeBytes.MESSAGE_TYPE_CHARACTER);
|
||||
stream.write(TypeBytes.CHARACTER_MESSAGE_TYPE_EDITORSWAP);
|
||||
break;
|
||||
|
||||
//
|
||||
//Write body of packet
|
||||
} break;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -2,11 +2,8 @@ package electrosphere.net.parser.net.message;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.io.OutputStream;
|
||||
import io.github.studiorailgun.CircularByteBuffer;
|
||||
import java.nio.ByteBuffer;
|
||||
import electrosphere.net.parser.util.ByteStreamUtils;
|
||||
import java.util.LinkedList;
|
||||
import java.util.List;
|
||||
|
||||
import java.util.Map;
|
||||
import java.util.function.BiConsumer;
|
||||
|
||||
@ -224,96 +221,35 @@ public class CombatMessage extends NetworkMessage {
|
||||
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
|
||||
*/
|
||||
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);
|
||||
rVal.messageType = CombatMessageType.SERVERREPORTHITBOXCOLLISION;
|
||||
CombatMessage.stripPacketHeader(byteBuffer);
|
||||
rVal.setentityID(ByteStreamUtils.popIntFromByteQueue(byteBuffer));
|
||||
rVal.setreceiverEntityID(ByteStreamUtils.popIntFromByteQueue(byteBuffer));
|
||||
rVal.settime(ByteStreamUtils.popLongFromByteQueue(byteBuffer));
|
||||
rVal.sethitboxType(ByteStreamUtils.popStringFromByteQueue(byteBuffer));
|
||||
rVal.sethurtboxType(ByteStreamUtils.popStringFromByteQueue(byteBuffer));
|
||||
rVal.setpositionX(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer));
|
||||
rVal.setpositionY(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer));
|
||||
rVal.setpositionZ(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer));
|
||||
rVal.setentityID(byteBuffer.getInt());
|
||||
rVal.setreceiverEntityID(byteBuffer.getInt());
|
||||
rVal.settime(byteBuffer.getLong());
|
||||
if(hitboxTypelen > 0){
|
||||
rVal.sethitboxType(ByteStreamUtils.popStringFromByteBuffer(byteBuffer, hitboxTypelen));
|
||||
}
|
||||
if(hurtboxTypelen > 0){
|
||||
rVal.sethurtboxType(ByteStreamUtils.popStringFromByteBuffer(byteBuffer, hurtboxTypelen));
|
||||
}
|
||||
rVal.setpositionX(byteBuffer.getDouble());
|
||||
rVal.setpositionY(byteBuffer.getDouble());
|
||||
rVal.setpositionZ(byteBuffer.getDouble());
|
||||
return rVal;
|
||||
}
|
||||
|
||||
@ -393,10 +329,20 @@ public class CombatMessage extends NetworkMessage {
|
||||
@Override
|
||||
public void write(OutputStream stream) throws IOException {
|
||||
switch(this.messageType){
|
||||
case SERVERREPORTHITBOXCOLLISION:
|
||||
case SERVERREPORTHITBOXCOLLISION: {
|
||||
|
||||
//
|
||||
//message header
|
||||
stream.write(TypeBytes.MESSAGE_TYPE_COMBAT);
|
||||
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, receiverEntityID);
|
||||
ByteStreamUtils.writeLong(stream, time);
|
||||
@ -405,7 +351,7 @@ public class CombatMessage extends NetworkMessage {
|
||||
ByteStreamUtils.writeDouble(stream, positionX);
|
||||
ByteStreamUtils.writeDouble(stream, positionY);
|
||||
ByteStreamUtils.writeDouble(stream, positionZ);
|
||||
break;
|
||||
} break;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -2,11 +2,8 @@ package electrosphere.net.parser.net.message;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.io.OutputStream;
|
||||
import io.github.studiorailgun.CircularByteBuffer;
|
||||
import java.nio.ByteBuffer;
|
||||
import electrosphere.net.parser.util.ByteStreamUtils;
|
||||
import java.util.LinkedList;
|
||||
import java.util.List;
|
||||
|
||||
import java.util.Map;
|
||||
import java.util.function.BiConsumer;
|
||||
|
||||
@ -579,160 +576,38 @@ public class EntityMessage extends NetworkMessage {
|
||||
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
|
||||
*/
|
||||
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);
|
||||
rVal.messageType = EntityMessageType.CREATE;
|
||||
EntityMessage.stripPacketHeader(byteBuffer);
|
||||
rVal.setentityID(ByteStreamUtils.popIntFromByteQueue(byteBuffer));
|
||||
rVal.setentityCategory(ByteStreamUtils.popIntFromByteQueue(byteBuffer));
|
||||
rVal.setentitySubtype(ByteStreamUtils.popStringFromByteQueue(byteBuffer));
|
||||
rVal.setcreatureTemplate(ByteStreamUtils.popStringFromByteQueue(byteBuffer));
|
||||
rVal.setpositionX(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer));
|
||||
rVal.setpositionY(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer));
|
||||
rVal.setpositionZ(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer));
|
||||
rVal.setrotationX(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer));
|
||||
rVal.setrotationY(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer));
|
||||
rVal.setrotationZ(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer));
|
||||
rVal.setrotationW(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer));
|
||||
rVal.setentityID(byteBuffer.getInt());
|
||||
rVal.setentityCategory(byteBuffer.getInt());
|
||||
if(entitySubtypelen > 0){
|
||||
rVal.setentitySubtype(ByteStreamUtils.popStringFromByteBuffer(byteBuffer, entitySubtypelen));
|
||||
}
|
||||
if(creatureTemplatelen > 0){
|
||||
rVal.setcreatureTemplate(ByteStreamUtils.popStringFromByteBuffer(byteBuffer, creatureTemplatelen));
|
||||
}
|
||||
rVal.setpositionX(byteBuffer.getDouble());
|
||||
rVal.setpositionY(byteBuffer.getDouble());
|
||||
rVal.setpositionZ(byteBuffer.getDouble());
|
||||
rVal.setrotationX(byteBuffer.getDouble());
|
||||
rVal.setrotationY(byteBuffer.getDouble());
|
||||
rVal.setrotationZ(byteBuffer.getDouble());
|
||||
rVal.setrotationW(byteBuffer.getDouble());
|
||||
return rVal;
|
||||
}
|
||||
|
||||
@ -758,22 +633,24 @@ public class EntityMessage extends NetworkMessage {
|
||||
/**
|
||||
* 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);
|
||||
rVal.messageType = EntityMessageType.MOVEUPDATE;
|
||||
EntityMessage.stripPacketHeader(byteBuffer);
|
||||
rVal.setentityID(ByteStreamUtils.popIntFromByteQueue(byteBuffer));
|
||||
rVal.settime(ByteStreamUtils.popLongFromByteQueue(byteBuffer));
|
||||
rVal.setpositionX(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer));
|
||||
rVal.setpositionY(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer));
|
||||
rVal.setpositionZ(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer));
|
||||
rVal.setrotationX(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer));
|
||||
rVal.setrotationY(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer));
|
||||
rVal.setrotationZ(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer));
|
||||
rVal.setrotationW(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer));
|
||||
rVal.setvelocity(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer));
|
||||
rVal.setpropertyValueInt(ByteStreamUtils.popIntFromByteQueue(byteBuffer));
|
||||
rVal.settreeState(ByteStreamUtils.popIntFromByteQueue(byteBuffer));
|
||||
rVal.setentityID(byteBuffer.getInt());
|
||||
rVal.settime(byteBuffer.getLong());
|
||||
rVal.setpositionX(byteBuffer.getDouble());
|
||||
rVal.setpositionY(byteBuffer.getDouble());
|
||||
rVal.setpositionZ(byteBuffer.getDouble());
|
||||
rVal.setrotationX(byteBuffer.getDouble());
|
||||
rVal.setrotationY(byteBuffer.getDouble());
|
||||
rVal.setrotationZ(byteBuffer.getDouble());
|
||||
rVal.setrotationW(byteBuffer.getDouble());
|
||||
rVal.setvelocity(byteBuffer.getDouble());
|
||||
rVal.setpropertyValueInt(byteBuffer.getInt());
|
||||
rVal.settreeState(byteBuffer.getInt());
|
||||
return rVal;
|
||||
}
|
||||
|
||||
@ -800,20 +677,22 @@ public class EntityMessage extends NetworkMessage {
|
||||
/**
|
||||
* 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);
|
||||
rVal.messageType = EntityMessageType.ATTACKUPDATE;
|
||||
EntityMessage.stripPacketHeader(byteBuffer);
|
||||
rVal.setentityID(ByteStreamUtils.popIntFromByteQueue(byteBuffer));
|
||||
rVal.settime(ByteStreamUtils.popLongFromByteQueue(byteBuffer));
|
||||
rVal.setpositionX(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer));
|
||||
rVal.setpositionY(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer));
|
||||
rVal.setpositionZ(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer));
|
||||
rVal.setrotationX(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer));
|
||||
rVal.setrotationY(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer));
|
||||
rVal.setrotationZ(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer));
|
||||
rVal.setvelocity(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer));
|
||||
rVal.settreeState(ByteStreamUtils.popIntFromByteQueue(byteBuffer));
|
||||
rVal.setentityID(byteBuffer.getInt());
|
||||
rVal.settime(byteBuffer.getLong());
|
||||
rVal.setpositionX(byteBuffer.getDouble());
|
||||
rVal.setpositionY(byteBuffer.getDouble());
|
||||
rVal.setpositionZ(byteBuffer.getDouble());
|
||||
rVal.setrotationX(byteBuffer.getDouble());
|
||||
rVal.setrotationY(byteBuffer.getDouble());
|
||||
rVal.setrotationZ(byteBuffer.getDouble());
|
||||
rVal.setvelocity(byteBuffer.getDouble());
|
||||
rVal.settreeState(byteBuffer.getInt());
|
||||
return rVal;
|
||||
}
|
||||
|
||||
@ -838,10 +717,12 @@ public class EntityMessage extends NetworkMessage {
|
||||
/**
|
||||
* 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);
|
||||
rVal.messageType = EntityMessageType.STARTATTACK;
|
||||
EntityMessage.stripPacketHeader(byteBuffer);
|
||||
return rVal;
|
||||
}
|
||||
|
||||
@ -856,12 +737,14 @@ public class EntityMessage extends NetworkMessage {
|
||||
/**
|
||||
* 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);
|
||||
rVal.messageType = EntityMessageType.KILL;
|
||||
EntityMessage.stripPacketHeader(byteBuffer);
|
||||
rVal.settime(ByteStreamUtils.popLongFromByteQueue(byteBuffer));
|
||||
rVal.setentityID(ByteStreamUtils.popIntFromByteQueue(byteBuffer));
|
||||
rVal.settime(byteBuffer.getLong());
|
||||
rVal.setentityID(byteBuffer.getInt());
|
||||
return rVal;
|
||||
}
|
||||
|
||||
@ -878,11 +761,13 @@ public class EntityMessage extends NetworkMessage {
|
||||
/**
|
||||
* 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);
|
||||
rVal.messageType = EntityMessageType.DESTROY;
|
||||
EntityMessage.stripPacketHeader(byteBuffer);
|
||||
rVal.setentityID(ByteStreamUtils.popIntFromByteQueue(byteBuffer));
|
||||
rVal.setentityID(byteBuffer.getInt());
|
||||
return rVal;
|
||||
}
|
||||
|
||||
@ -898,14 +783,16 @@ public class EntityMessage extends NetworkMessage {
|
||||
/**
|
||||
* 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);
|
||||
rVal.messageType = EntityMessageType.SETPROPERTY;
|
||||
EntityMessage.stripPacketHeader(byteBuffer);
|
||||
rVal.setentityID(ByteStreamUtils.popIntFromByteQueue(byteBuffer));
|
||||
rVal.settime(ByteStreamUtils.popLongFromByteQueue(byteBuffer));
|
||||
rVal.setpropertyType(ByteStreamUtils.popIntFromByteQueue(byteBuffer));
|
||||
rVal.setpropertyValue(ByteStreamUtils.popIntFromByteQueue(byteBuffer));
|
||||
rVal.setentityID(byteBuffer.getInt());
|
||||
rVal.settime(byteBuffer.getLong());
|
||||
rVal.setpropertyType(byteBuffer.getInt());
|
||||
rVal.setpropertyValue(byteBuffer.getInt());
|
||||
return rVal;
|
||||
}
|
||||
|
||||
@ -921,44 +808,26 @@ public class EntityMessage extends NetworkMessage {
|
||||
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
|
||||
*/
|
||||
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);
|
||||
rVal.messageType = EntityMessageType.ATTACHENTITYTOENTITY;
|
||||
EntityMessage.stripPacketHeader(byteBuffer);
|
||||
rVal.setentityID(ByteStreamUtils.popIntFromByteQueue(byteBuffer));
|
||||
rVal.setbone(ByteStreamUtils.popStringFromByteQueue(byteBuffer));
|
||||
rVal.settargetID(ByteStreamUtils.popIntFromByteQueue(byteBuffer));
|
||||
rVal.setentityID(byteBuffer.getInt());
|
||||
if(bonelen > 0){
|
||||
rVal.setbone(ByteStreamUtils.popStringFromByteBuffer(byteBuffer, bonelen));
|
||||
}
|
||||
rVal.settargetID(byteBuffer.getInt());
|
||||
return rVal;
|
||||
}
|
||||
|
||||
@ -976,15 +845,17 @@ public class EntityMessage extends NetworkMessage {
|
||||
/**
|
||||
* 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);
|
||||
rVal.messageType = EntityMessageType.UPDATEENTITYVIEWDIR;
|
||||
EntityMessage.stripPacketHeader(byteBuffer);
|
||||
rVal.setentityID(ByteStreamUtils.popIntFromByteQueue(byteBuffer));
|
||||
rVal.settime(ByteStreamUtils.popLongFromByteQueue(byteBuffer));
|
||||
rVal.setpropertyType(ByteStreamUtils.popIntFromByteQueue(byteBuffer));
|
||||
rVal.setyaw(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer));
|
||||
rVal.setpitch(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer));
|
||||
rVal.setentityID(byteBuffer.getInt());
|
||||
rVal.settime(byteBuffer.getLong());
|
||||
rVal.setpropertyType(byteBuffer.getInt());
|
||||
rVal.setyaw(byteBuffer.getDouble());
|
||||
rVal.setpitch(byteBuffer.getDouble());
|
||||
return rVal;
|
||||
}
|
||||
|
||||
@ -1004,31 +875,33 @@ public class EntityMessage extends NetworkMessage {
|
||||
/**
|
||||
* 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);
|
||||
rVal.messageType = EntityMessageType.SYNCPHYSICS;
|
||||
EntityMessage.stripPacketHeader(byteBuffer);
|
||||
rVal.setentityID(ByteStreamUtils.popIntFromByteQueue(byteBuffer));
|
||||
rVal.settime(ByteStreamUtils.popLongFromByteQueue(byteBuffer));
|
||||
rVal.setpositionX(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer));
|
||||
rVal.setpositionY(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer));
|
||||
rVal.setpositionZ(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer));
|
||||
rVal.setrotationX(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer));
|
||||
rVal.setrotationY(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer));
|
||||
rVal.setrotationZ(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer));
|
||||
rVal.setrotationW(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer));
|
||||
rVal.setlinVelX(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer));
|
||||
rVal.setlinVelY(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer));
|
||||
rVal.setlinVelZ(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer));
|
||||
rVal.setangVelX(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer));
|
||||
rVal.setangVelY(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer));
|
||||
rVal.setangVelZ(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer));
|
||||
rVal.setlinForceX(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer));
|
||||
rVal.setlinForceY(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer));
|
||||
rVal.setlinForceZ(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer));
|
||||
rVal.setangForceX(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer));
|
||||
rVal.setangForceY(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer));
|
||||
rVal.setangForceZ(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer));
|
||||
rVal.setentityID(byteBuffer.getInt());
|
||||
rVal.settime(byteBuffer.getLong());
|
||||
rVal.setpositionX(byteBuffer.getDouble());
|
||||
rVal.setpositionY(byteBuffer.getDouble());
|
||||
rVal.setpositionZ(byteBuffer.getDouble());
|
||||
rVal.setrotationX(byteBuffer.getDouble());
|
||||
rVal.setrotationY(byteBuffer.getDouble());
|
||||
rVal.setrotationZ(byteBuffer.getDouble());
|
||||
rVal.setrotationW(byteBuffer.getDouble());
|
||||
rVal.setlinVelX(byteBuffer.getDouble());
|
||||
rVal.setlinVelY(byteBuffer.getDouble());
|
||||
rVal.setlinVelZ(byteBuffer.getDouble());
|
||||
rVal.setangVelX(byteBuffer.getDouble());
|
||||
rVal.setangVelY(byteBuffer.getDouble());
|
||||
rVal.setangVelZ(byteBuffer.getDouble());
|
||||
rVal.setlinForceX(byteBuffer.getDouble());
|
||||
rVal.setlinForceY(byteBuffer.getDouble());
|
||||
rVal.setlinForceZ(byteBuffer.getDouble());
|
||||
rVal.setangForceX(byteBuffer.getDouble());
|
||||
rVal.setangForceY(byteBuffer.getDouble());
|
||||
rVal.setangForceZ(byteBuffer.getDouble());
|
||||
return rVal;
|
||||
}
|
||||
|
||||
@ -1061,40 +934,25 @@ public class EntityMessage extends NetworkMessage {
|
||||
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
|
||||
*/
|
||||
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);
|
||||
rVal.messageType = EntityMessageType.INTERACT;
|
||||
EntityMessage.stripPacketHeader(byteBuffer);
|
||||
rVal.setentityID(ByteStreamUtils.popIntFromByteQueue(byteBuffer));
|
||||
rVal.setinteractionSignal(ByteStreamUtils.popStringFromByteQueue(byteBuffer));
|
||||
rVal.setentityID(byteBuffer.getInt());
|
||||
if(interactionSignallen > 0){
|
||||
rVal.setinteractionSignal(ByteStreamUtils.popStringFromByteBuffer(byteBuffer, interactionSignallen));
|
||||
}
|
||||
return rVal;
|
||||
}
|
||||
|
||||
@ -1498,10 +1356,20 @@ public class EntityMessage extends NetworkMessage {
|
||||
@Override
|
||||
public void write(OutputStream stream) throws IOException {
|
||||
switch(this.messageType){
|
||||
case CREATE:
|
||||
case CREATE: {
|
||||
|
||||
//
|
||||
//message header
|
||||
stream.write(TypeBytes.MESSAGE_TYPE_ENTITY);
|
||||
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, entityCategory);
|
||||
ByteStreamUtils.writeString(stream, entitySubtype);
|
||||
@ -1513,11 +1381,16 @@ public class EntityMessage extends NetworkMessage {
|
||||
ByteStreamUtils.writeDouble(stream, rotationY);
|
||||
ByteStreamUtils.writeDouble(stream, rotationZ);
|
||||
ByteStreamUtils.writeDouble(stream, rotationW);
|
||||
break;
|
||||
case MOVEUPDATE:
|
||||
} break;
|
||||
case MOVEUPDATE: {
|
||||
|
||||
//
|
||||
//message header
|
||||
stream.write(TypeBytes.MESSAGE_TYPE_ENTITY);
|
||||
stream.write(TypeBytes.ENTITY_MESSAGE_TYPE_MOVEUPDATE);
|
||||
|
||||
//
|
||||
//Write body of packet
|
||||
ByteStreamUtils.writeInt(stream, entityID);
|
||||
ByteStreamUtils.writeLong(stream, time);
|
||||
ByteStreamUtils.writeDouble(stream, positionX);
|
||||
@ -1530,11 +1403,16 @@ public class EntityMessage extends NetworkMessage {
|
||||
ByteStreamUtils.writeDouble(stream, velocity);
|
||||
ByteStreamUtils.writeInt(stream, propertyValueInt);
|
||||
ByteStreamUtils.writeInt(stream, treeState);
|
||||
break;
|
||||
case ATTACKUPDATE:
|
||||
} break;
|
||||
case ATTACKUPDATE: {
|
||||
|
||||
//
|
||||
//message header
|
||||
stream.write(TypeBytes.MESSAGE_TYPE_ENTITY);
|
||||
stream.write(TypeBytes.ENTITY_MESSAGE_TYPE_ATTACKUPDATE);
|
||||
|
||||
//
|
||||
//Write body of packet
|
||||
ByteStreamUtils.writeInt(stream, entityID);
|
||||
ByteStreamUtils.writeLong(stream, time);
|
||||
ByteStreamUtils.writeDouble(stream, positionX);
|
||||
@ -1545,56 +1423,95 @@ public class EntityMessage extends NetworkMessage {
|
||||
ByteStreamUtils.writeDouble(stream, rotationZ);
|
||||
ByteStreamUtils.writeDouble(stream, velocity);
|
||||
ByteStreamUtils.writeInt(stream, treeState);
|
||||
break;
|
||||
case STARTATTACK:
|
||||
} break;
|
||||
case STARTATTACK: {
|
||||
|
||||
//
|
||||
//message header
|
||||
stream.write(TypeBytes.MESSAGE_TYPE_ENTITY);
|
||||
stream.write(TypeBytes.ENTITY_MESSAGE_TYPE_STARTATTACK);
|
||||
break;
|
||||
case KILL:
|
||||
|
||||
//
|
||||
//Write body of packet
|
||||
} break;
|
||||
case KILL: {
|
||||
|
||||
//
|
||||
//message header
|
||||
stream.write(TypeBytes.MESSAGE_TYPE_ENTITY);
|
||||
stream.write(TypeBytes.ENTITY_MESSAGE_TYPE_KILL);
|
||||
|
||||
//
|
||||
//Write body of packet
|
||||
ByteStreamUtils.writeLong(stream, time);
|
||||
ByteStreamUtils.writeInt(stream, entityID);
|
||||
break;
|
||||
case DESTROY:
|
||||
} break;
|
||||
case DESTROY: {
|
||||
|
||||
//
|
||||
//message header
|
||||
stream.write(TypeBytes.MESSAGE_TYPE_ENTITY);
|
||||
stream.write(TypeBytes.ENTITY_MESSAGE_TYPE_DESTROY);
|
||||
|
||||
//
|
||||
//Write body of packet
|
||||
ByteStreamUtils.writeInt(stream, entityID);
|
||||
break;
|
||||
case SETPROPERTY:
|
||||
} break;
|
||||
case SETPROPERTY: {
|
||||
|
||||
//
|
||||
//message header
|
||||
stream.write(TypeBytes.MESSAGE_TYPE_ENTITY);
|
||||
stream.write(TypeBytes.ENTITY_MESSAGE_TYPE_SETPROPERTY);
|
||||
|
||||
//
|
||||
//Write body of packet
|
||||
ByteStreamUtils.writeInt(stream, entityID);
|
||||
ByteStreamUtils.writeLong(stream, time);
|
||||
ByteStreamUtils.writeInt(stream, propertyType);
|
||||
ByteStreamUtils.writeInt(stream, propertyValue);
|
||||
break;
|
||||
case ATTACHENTITYTOENTITY:
|
||||
} break;
|
||||
case ATTACHENTITYTOENTITY: {
|
||||
|
||||
//
|
||||
//message header
|
||||
stream.write(TypeBytes.MESSAGE_TYPE_ENTITY);
|
||||
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.writeString(stream, bone);
|
||||
ByteStreamUtils.writeInt(stream, targetID);
|
||||
break;
|
||||
case UPDATEENTITYVIEWDIR:
|
||||
} break;
|
||||
case UPDATEENTITYVIEWDIR: {
|
||||
|
||||
//
|
||||
//message header
|
||||
stream.write(TypeBytes.MESSAGE_TYPE_ENTITY);
|
||||
stream.write(TypeBytes.ENTITY_MESSAGE_TYPE_UPDATEENTITYVIEWDIR);
|
||||
|
||||
//
|
||||
//Write body of packet
|
||||
ByteStreamUtils.writeInt(stream, entityID);
|
||||
ByteStreamUtils.writeLong(stream, time);
|
||||
ByteStreamUtils.writeInt(stream, propertyType);
|
||||
ByteStreamUtils.writeDouble(stream, yaw);
|
||||
ByteStreamUtils.writeDouble(stream, pitch);
|
||||
break;
|
||||
case SYNCPHYSICS:
|
||||
} break;
|
||||
case SYNCPHYSICS: {
|
||||
|
||||
//
|
||||
//message header
|
||||
stream.write(TypeBytes.MESSAGE_TYPE_ENTITY);
|
||||
stream.write(TypeBytes.ENTITY_MESSAGE_TYPE_SYNCPHYSICS);
|
||||
|
||||
//
|
||||
//Write body of packet
|
||||
ByteStreamUtils.writeInt(stream, entityID);
|
||||
ByteStreamUtils.writeLong(stream, time);
|
||||
ByteStreamUtils.writeDouble(stream, positionX);
|
||||
@ -1616,14 +1533,23 @@ public class EntityMessage extends NetworkMessage {
|
||||
ByteStreamUtils.writeDouble(stream, angForceX);
|
||||
ByteStreamUtils.writeDouble(stream, angForceY);
|
||||
ByteStreamUtils.writeDouble(stream, angForceZ);
|
||||
break;
|
||||
case INTERACT:
|
||||
} break;
|
||||
case INTERACT: {
|
||||
|
||||
//
|
||||
//message header
|
||||
stream.write(TypeBytes.MESSAGE_TYPE_ENTITY);
|
||||
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.writeString(stream, interactionSignal);
|
||||
break;
|
||||
} break;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -2,11 +2,8 @@ package electrosphere.net.parser.net.message;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.io.OutputStream;
|
||||
import io.github.studiorailgun.CircularByteBuffer;
|
||||
import java.nio.ByteBuffer;
|
||||
import electrosphere.net.parser.util.ByteStreamUtils;
|
||||
import java.util.LinkedList;
|
||||
import java.util.List;
|
||||
|
||||
import java.util.Map;
|
||||
import java.util.function.BiConsumer;
|
||||
|
||||
@ -60,41 +57,15 @@ public class LoreMessage extends NetworkMessage {
|
||||
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
|
||||
*/
|
||||
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);
|
||||
rVal.messageType = LoreMessageType.REQUESTRACES;
|
||||
LoreMessage.stripPacketHeader(byteBuffer);
|
||||
return rVal;
|
||||
}
|
||||
|
||||
@ -106,36 +77,24 @@ public class LoreMessage extends NetworkMessage {
|
||||
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
|
||||
*/
|
||||
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);
|
||||
rVal.messageType = LoreMessageType.RESPONSERACES;
|
||||
LoreMessage.stripPacketHeader(byteBuffer);
|
||||
rVal.setdata(ByteStreamUtils.popStringFromByteQueue(byteBuffer));
|
||||
if(datalen > 0){
|
||||
rVal.setdata(ByteStreamUtils.popStringFromByteBuffer(byteBuffer, datalen));
|
||||
}
|
||||
return rVal;
|
||||
}
|
||||
|
||||
@ -183,17 +142,31 @@ public class LoreMessage extends NetworkMessage {
|
||||
@Override
|
||||
public void write(OutputStream stream) throws IOException {
|
||||
switch(this.messageType){
|
||||
case REQUESTRACES:
|
||||
case REQUESTRACES: {
|
||||
|
||||
//
|
||||
//message header
|
||||
stream.write(TypeBytes.MESSAGE_TYPE_LORE);
|
||||
stream.write(TypeBytes.LORE_MESSAGE_TYPE_REQUESTRACES);
|
||||
break;
|
||||
case RESPONSERACES:
|
||||
|
||||
//
|
||||
//Write body of packet
|
||||
} break;
|
||||
case RESPONSERACES: {
|
||||
|
||||
//
|
||||
//message header
|
||||
stream.write(TypeBytes.MESSAGE_TYPE_LORE);
|
||||
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);
|
||||
break;
|
||||
} break;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -1,9 +1,8 @@
|
||||
package electrosphere.net.parser.net.message;
|
||||
|
||||
import io.github.studiorailgun.CircularByteBuffer;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.io.OutputStream;
|
||||
import java.nio.ByteBuffer;
|
||||
import java.util.Map;
|
||||
import java.util.List;
|
||||
import java.util.function.BiConsumer;
|
||||
@ -72,454 +71,303 @@ public abstract class NetworkMessage {
|
||||
* @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
|
||||
*/
|
||||
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;
|
||||
byte firstByte;
|
||||
byte secondByte;
|
||||
if(byteBuffer.getRemaining() > 1){
|
||||
firstByte = byteBuffer.peek();
|
||||
int initialPosition = byteBuffer.position();
|
||||
if(byteBuffer.remaining() >= 2){
|
||||
firstByte = byteBuffer.get();
|
||||
switch(firstByte){
|
||||
case TypeBytes.MESSAGE_TYPE_ENTITY:
|
||||
secondByte = byteBuffer.peek(1);
|
||||
secondByte = byteBuffer.get();
|
||||
switch(secondByte){
|
||||
case TypeBytes.ENTITY_MESSAGE_TYPE_CREATE:
|
||||
if(EntityMessage.canParseMessage(byteBuffer,secondByte)){
|
||||
rVal = EntityMessage.parseCreateMessage(byteBuffer,pool,customParserMap);
|
||||
}
|
||||
rVal = EntityMessage.parseCreateMessage(byteBuffer,pool,customParserMap);
|
||||
break;
|
||||
case TypeBytes.ENTITY_MESSAGE_TYPE_MOVEUPDATE:
|
||||
if(EntityMessage.canParseMessage(byteBuffer,secondByte)){
|
||||
rVal = EntityMessage.parsemoveUpdateMessage(byteBuffer,pool,customParserMap);
|
||||
}
|
||||
rVal = EntityMessage.parsemoveUpdateMessage(byteBuffer,pool,customParserMap);
|
||||
break;
|
||||
case TypeBytes.ENTITY_MESSAGE_TYPE_ATTACKUPDATE:
|
||||
if(EntityMessage.canParseMessage(byteBuffer,secondByte)){
|
||||
rVal = EntityMessage.parseattackUpdateMessage(byteBuffer,pool,customParserMap);
|
||||
}
|
||||
rVal = EntityMessage.parseattackUpdateMessage(byteBuffer,pool,customParserMap);
|
||||
break;
|
||||
case TypeBytes.ENTITY_MESSAGE_TYPE_STARTATTACK:
|
||||
if(EntityMessage.canParseMessage(byteBuffer,secondByte)){
|
||||
rVal = EntityMessage.parsestartAttackMessage(byteBuffer,pool,customParserMap);
|
||||
}
|
||||
rVal = EntityMessage.parsestartAttackMessage(byteBuffer,pool,customParserMap);
|
||||
break;
|
||||
case TypeBytes.ENTITY_MESSAGE_TYPE_KILL:
|
||||
if(EntityMessage.canParseMessage(byteBuffer,secondByte)){
|
||||
rVal = EntityMessage.parseKillMessage(byteBuffer,pool,customParserMap);
|
||||
}
|
||||
rVal = EntityMessage.parseKillMessage(byteBuffer,pool,customParserMap);
|
||||
break;
|
||||
case TypeBytes.ENTITY_MESSAGE_TYPE_DESTROY:
|
||||
if(EntityMessage.canParseMessage(byteBuffer,secondByte)){
|
||||
rVal = EntityMessage.parseDestroyMessage(byteBuffer,pool,customParserMap);
|
||||
}
|
||||
rVal = EntityMessage.parseDestroyMessage(byteBuffer,pool,customParserMap);
|
||||
break;
|
||||
case TypeBytes.ENTITY_MESSAGE_TYPE_SETPROPERTY:
|
||||
if(EntityMessage.canParseMessage(byteBuffer,secondByte)){
|
||||
rVal = EntityMessage.parsesetPropertyMessage(byteBuffer,pool,customParserMap);
|
||||
}
|
||||
rVal = EntityMessage.parsesetPropertyMessage(byteBuffer,pool,customParserMap);
|
||||
break;
|
||||
case TypeBytes.ENTITY_MESSAGE_TYPE_ATTACHENTITYTOENTITY:
|
||||
if(EntityMessage.canParseMessage(byteBuffer,secondByte)){
|
||||
rVal = EntityMessage.parseattachEntityToEntityMessage(byteBuffer,pool,customParserMap);
|
||||
}
|
||||
rVal = EntityMessage.parseattachEntityToEntityMessage(byteBuffer,pool,customParserMap);
|
||||
break;
|
||||
case TypeBytes.ENTITY_MESSAGE_TYPE_UPDATEENTITYVIEWDIR:
|
||||
if(EntityMessage.canParseMessage(byteBuffer,secondByte)){
|
||||
rVal = EntityMessage.parseupdateEntityViewDirMessage(byteBuffer,pool,customParserMap);
|
||||
}
|
||||
rVal = EntityMessage.parseupdateEntityViewDirMessage(byteBuffer,pool,customParserMap);
|
||||
break;
|
||||
case TypeBytes.ENTITY_MESSAGE_TYPE_SYNCPHYSICS:
|
||||
if(EntityMessage.canParseMessage(byteBuffer,secondByte)){
|
||||
rVal = EntityMessage.parsesyncPhysicsMessage(byteBuffer,pool,customParserMap);
|
||||
}
|
||||
rVal = EntityMessage.parsesyncPhysicsMessage(byteBuffer,pool,customParserMap);
|
||||
break;
|
||||
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;
|
||||
case TypeBytes.MESSAGE_TYPE_LORE:
|
||||
secondByte = byteBuffer.peek(1);
|
||||
secondByte = byteBuffer.get();
|
||||
switch(secondByte){
|
||||
case TypeBytes.LORE_MESSAGE_TYPE_REQUESTRACES:
|
||||
if(LoreMessage.canParseMessage(byteBuffer,secondByte)){
|
||||
rVal = LoreMessage.parseRequestRacesMessage(byteBuffer,pool,customParserMap);
|
||||
}
|
||||
rVal = LoreMessage.parseRequestRacesMessage(byteBuffer,pool,customParserMap);
|
||||
break;
|
||||
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;
|
||||
case TypeBytes.MESSAGE_TYPE_PLAYER:
|
||||
secondByte = byteBuffer.peek(1);
|
||||
secondByte = byteBuffer.get();
|
||||
switch(secondByte){
|
||||
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;
|
||||
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;
|
||||
case TypeBytes.MESSAGE_TYPE_TERRAIN:
|
||||
secondByte = byteBuffer.peek(1);
|
||||
secondByte = byteBuffer.get();
|
||||
switch(secondByte){
|
||||
case TypeBytes.TERRAIN_MESSAGE_TYPE_REQUESTMETADATA:
|
||||
if(TerrainMessage.canParseMessage(byteBuffer,secondByte)){
|
||||
rVal = TerrainMessage.parseRequestMetadataMessage(byteBuffer,pool,customParserMap);
|
||||
}
|
||||
rVal = TerrainMessage.parseRequestMetadataMessage(byteBuffer,pool,customParserMap);
|
||||
break;
|
||||
case TypeBytes.TERRAIN_MESSAGE_TYPE_RESPONSEMETADATA:
|
||||
if(TerrainMessage.canParseMessage(byteBuffer,secondByte)){
|
||||
rVal = TerrainMessage.parseResponseMetadataMessage(byteBuffer,pool,customParserMap);
|
||||
}
|
||||
rVal = TerrainMessage.parseResponseMetadataMessage(byteBuffer,pool,customParserMap);
|
||||
break;
|
||||
case TypeBytes.TERRAIN_MESSAGE_TYPE_REQUESTEDITVOXEL:
|
||||
if(TerrainMessage.canParseMessage(byteBuffer,secondByte)){
|
||||
rVal = TerrainMessage.parseRequestEditVoxelMessage(byteBuffer,pool,customParserMap);
|
||||
}
|
||||
rVal = TerrainMessage.parseRequestEditVoxelMessage(byteBuffer,pool,customParserMap);
|
||||
break;
|
||||
case TypeBytes.TERRAIN_MESSAGE_TYPE_UPDATEVOXEL:
|
||||
if(TerrainMessage.canParseMessage(byteBuffer,secondByte)){
|
||||
rVal = TerrainMessage.parseUpdateVoxelMessage(byteBuffer,pool,customParserMap);
|
||||
}
|
||||
rVal = TerrainMessage.parseUpdateVoxelMessage(byteBuffer,pool,customParserMap);
|
||||
break;
|
||||
case TypeBytes.TERRAIN_MESSAGE_TYPE_REQUESTUSETERRAINPALETTE:
|
||||
if(TerrainMessage.canParseMessage(byteBuffer,secondByte)){
|
||||
rVal = TerrainMessage.parseRequestUseTerrainPaletteMessage(byteBuffer,pool,customParserMap);
|
||||
}
|
||||
rVal = TerrainMessage.parseRequestUseTerrainPaletteMessage(byteBuffer,pool,customParserMap);
|
||||
break;
|
||||
case TypeBytes.TERRAIN_MESSAGE_TYPE_REQUESTDESTROYTERRAIN:
|
||||
if(TerrainMessage.canParseMessage(byteBuffer,secondByte)){
|
||||
rVal = TerrainMessage.parseRequestDestroyTerrainMessage(byteBuffer,pool,customParserMap);
|
||||
}
|
||||
rVal = TerrainMessage.parseRequestDestroyTerrainMessage(byteBuffer,pool,customParserMap);
|
||||
break;
|
||||
case TypeBytes.TERRAIN_MESSAGE_TYPE_SPAWNPOSITION:
|
||||
if(TerrainMessage.canParseMessage(byteBuffer,secondByte)){
|
||||
rVal = TerrainMessage.parseSpawnPositionMessage(byteBuffer,pool,customParserMap);
|
||||
}
|
||||
rVal = TerrainMessage.parseSpawnPositionMessage(byteBuffer,pool,customParserMap);
|
||||
break;
|
||||
case TypeBytes.TERRAIN_MESSAGE_TYPE_REQUESTCHUNKDATA:
|
||||
if(TerrainMessage.canParseMessage(byteBuffer,secondByte)){
|
||||
rVal = TerrainMessage.parseRequestChunkDataMessage(byteBuffer,pool,customParserMap);
|
||||
}
|
||||
rVal = TerrainMessage.parseRequestChunkDataMessage(byteBuffer,pool,customParserMap);
|
||||
break;
|
||||
case TypeBytes.TERRAIN_MESSAGE_TYPE_SENDCHUNKDATA:
|
||||
if(TerrainMessage.canParseMessage(byteBuffer,secondByte)){
|
||||
rVal = TerrainMessage.parsesendChunkDataMessage(byteBuffer,pool,customParserMap);
|
||||
}
|
||||
rVal = TerrainMessage.parsesendChunkDataMessage(byteBuffer,pool,customParserMap);
|
||||
break;
|
||||
case TypeBytes.TERRAIN_MESSAGE_TYPE_REQUESTREDUCEDCHUNKDATA:
|
||||
if(TerrainMessage.canParseMessage(byteBuffer,secondByte)){
|
||||
rVal = TerrainMessage.parseRequestReducedChunkDataMessage(byteBuffer,pool,customParserMap);
|
||||
}
|
||||
rVal = TerrainMessage.parseRequestReducedChunkDataMessage(byteBuffer,pool,customParserMap);
|
||||
break;
|
||||
case TypeBytes.TERRAIN_MESSAGE_TYPE_SENDREDUCEDCHUNKDATA:
|
||||
if(TerrainMessage.canParseMessage(byteBuffer,secondByte)){
|
||||
rVal = TerrainMessage.parseSendReducedChunkDataMessage(byteBuffer,pool,customParserMap);
|
||||
}
|
||||
rVal = TerrainMessage.parseSendReducedChunkDataMessage(byteBuffer,pool,customParserMap);
|
||||
break;
|
||||
case TypeBytes.TERRAIN_MESSAGE_TYPE_REQUESTREDUCEDBLOCKDATA:
|
||||
if(TerrainMessage.canParseMessage(byteBuffer,secondByte)){
|
||||
rVal = TerrainMessage.parseRequestReducedBlockDataMessage(byteBuffer,pool,customParserMap);
|
||||
}
|
||||
rVal = TerrainMessage.parseRequestReducedBlockDataMessage(byteBuffer,pool,customParserMap);
|
||||
break;
|
||||
case TypeBytes.TERRAIN_MESSAGE_TYPE_SENDREDUCEDBLOCKDATA:
|
||||
if(TerrainMessage.canParseMessage(byteBuffer,secondByte)){
|
||||
rVal = TerrainMessage.parseSendReducedBlockDataMessage(byteBuffer,pool,customParserMap);
|
||||
}
|
||||
rVal = TerrainMessage.parseSendReducedBlockDataMessage(byteBuffer,pool,customParserMap);
|
||||
break;
|
||||
case TypeBytes.TERRAIN_MESSAGE_TYPE_UPDATEBLOCK:
|
||||
if(TerrainMessage.canParseMessage(byteBuffer,secondByte)){
|
||||
rVal = TerrainMessage.parseUpdateBlockMessage(byteBuffer,pool,customParserMap);
|
||||
}
|
||||
rVal = TerrainMessage.parseUpdateBlockMessage(byteBuffer,pool,customParserMap);
|
||||
break;
|
||||
case TypeBytes.TERRAIN_MESSAGE_TYPE_REQUESTFLUIDDATA:
|
||||
if(TerrainMessage.canParseMessage(byteBuffer,secondByte)){
|
||||
rVal = TerrainMessage.parseRequestFluidDataMessage(byteBuffer,pool,customParserMap);
|
||||
}
|
||||
rVal = TerrainMessage.parseRequestFluidDataMessage(byteBuffer,pool,customParserMap);
|
||||
break;
|
||||
case TypeBytes.TERRAIN_MESSAGE_TYPE_SENDFLUIDDATA:
|
||||
if(TerrainMessage.canParseMessage(byteBuffer,secondByte)){
|
||||
rVal = TerrainMessage.parsesendFluidDataMessage(byteBuffer,pool,customParserMap);
|
||||
}
|
||||
rVal = TerrainMessage.parsesendFluidDataMessage(byteBuffer,pool,customParserMap);
|
||||
break;
|
||||
case TypeBytes.TERRAIN_MESSAGE_TYPE_UPDATEFLUIDDATA:
|
||||
if(TerrainMessage.canParseMessage(byteBuffer,secondByte)){
|
||||
rVal = TerrainMessage.parseupdateFluidDataMessage(byteBuffer,pool,customParserMap);
|
||||
}
|
||||
rVal = TerrainMessage.parseupdateFluidDataMessage(byteBuffer,pool,customParserMap);
|
||||
break;
|
||||
case TypeBytes.TERRAIN_MESSAGE_TYPE_REQUESTEDITBLOCK:
|
||||
if(TerrainMessage.canParseMessage(byteBuffer,secondByte)){
|
||||
rVal = TerrainMessage.parseRequestEditBlockMessage(byteBuffer,pool,customParserMap);
|
||||
}
|
||||
rVal = TerrainMessage.parseRequestEditBlockMessage(byteBuffer,pool,customParserMap);
|
||||
break;
|
||||
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;
|
||||
case TypeBytes.MESSAGE_TYPE_SERVER:
|
||||
secondByte = byteBuffer.peek(1);
|
||||
secondByte = byteBuffer.get();
|
||||
switch(secondByte){
|
||||
case TypeBytes.SERVER_MESSAGE_TYPE_PING:
|
||||
if(ServerMessage.canParseMessage(byteBuffer,secondByte)){
|
||||
rVal = ServerMessage.parsePingMessage(byteBuffer,pool,customParserMap);
|
||||
}
|
||||
rVal = ServerMessage.parsePingMessage(byteBuffer,pool,customParserMap);
|
||||
break;
|
||||
case TypeBytes.SERVER_MESSAGE_TYPE_PONG:
|
||||
if(ServerMessage.canParseMessage(byteBuffer,secondByte)){
|
||||
rVal = ServerMessage.parsePongMessage(byteBuffer,pool,customParserMap);
|
||||
}
|
||||
rVal = ServerMessage.parsePongMessage(byteBuffer,pool,customParserMap);
|
||||
break;
|
||||
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;
|
||||
case TypeBytes.MESSAGE_TYPE_AUTH:
|
||||
secondByte = byteBuffer.peek(1);
|
||||
secondByte = byteBuffer.get();
|
||||
switch(secondByte){
|
||||
case TypeBytes.AUTH_MESSAGE_TYPE_AUTHREQUEST:
|
||||
if(AuthMessage.canParseMessage(byteBuffer,secondByte)){
|
||||
rVal = AuthMessage.parseAuthRequestMessage(byteBuffer,pool,customParserMap);
|
||||
}
|
||||
rVal = AuthMessage.parseAuthRequestMessage(byteBuffer,pool,customParserMap);
|
||||
break;
|
||||
case TypeBytes.AUTH_MESSAGE_TYPE_AUTHDETAILS:
|
||||
if(AuthMessage.canParseMessage(byteBuffer,secondByte)){
|
||||
rVal = AuthMessage.parseAuthDetailsMessage(byteBuffer,pool,customParserMap);
|
||||
}
|
||||
rVal = AuthMessage.parseAuthDetailsMessage(byteBuffer,pool,customParserMap);
|
||||
break;
|
||||
case TypeBytes.AUTH_MESSAGE_TYPE_AUTHSUCCESS:
|
||||
if(AuthMessage.canParseMessage(byteBuffer,secondByte)){
|
||||
rVal = AuthMessage.parseAuthSuccessMessage(byteBuffer,pool,customParserMap);
|
||||
}
|
||||
rVal = AuthMessage.parseAuthSuccessMessage(byteBuffer,pool,customParserMap);
|
||||
break;
|
||||
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;
|
||||
case TypeBytes.MESSAGE_TYPE_CHARACTER:
|
||||
secondByte = byteBuffer.peek(1);
|
||||
secondByte = byteBuffer.get();
|
||||
switch(secondByte){
|
||||
case TypeBytes.CHARACTER_MESSAGE_TYPE_REQUESTCHARACTERLIST:
|
||||
if(CharacterMessage.canParseMessage(byteBuffer,secondByte)){
|
||||
rVal = CharacterMessage.parseRequestCharacterListMessage(byteBuffer,pool,customParserMap);
|
||||
}
|
||||
rVal = CharacterMessage.parseRequestCharacterListMessage(byteBuffer,pool,customParserMap);
|
||||
break;
|
||||
case TypeBytes.CHARACTER_MESSAGE_TYPE_RESPONSECHARACTERLIST:
|
||||
if(CharacterMessage.canParseMessage(byteBuffer,secondByte)){
|
||||
rVal = CharacterMessage.parseResponseCharacterListMessage(byteBuffer,pool,customParserMap);
|
||||
}
|
||||
rVal = CharacterMessage.parseResponseCharacterListMessage(byteBuffer,pool,customParserMap);
|
||||
break;
|
||||
case TypeBytes.CHARACTER_MESSAGE_TYPE_REQUESTCREATECHARACTER:
|
||||
if(CharacterMessage.canParseMessage(byteBuffer,secondByte)){
|
||||
rVal = CharacterMessage.parseRequestCreateCharacterMessage(byteBuffer,pool,customParserMap);
|
||||
}
|
||||
rVal = CharacterMessage.parseRequestCreateCharacterMessage(byteBuffer,pool,customParserMap);
|
||||
break;
|
||||
case TypeBytes.CHARACTER_MESSAGE_TYPE_RESPONSECREATECHARACTERSUCCESS:
|
||||
if(CharacterMessage.canParseMessage(byteBuffer,secondByte)){
|
||||
rVal = CharacterMessage.parseResponseCreateCharacterSuccessMessage(byteBuffer,pool,customParserMap);
|
||||
}
|
||||
rVal = CharacterMessage.parseResponseCreateCharacterSuccessMessage(byteBuffer,pool,customParserMap);
|
||||
break;
|
||||
case TypeBytes.CHARACTER_MESSAGE_TYPE_RESPONSECREATECHARACTERFAILURE:
|
||||
if(CharacterMessage.canParseMessage(byteBuffer,secondByte)){
|
||||
rVal = CharacterMessage.parseResponseCreateCharacterFailureMessage(byteBuffer,pool,customParserMap);
|
||||
}
|
||||
rVal = CharacterMessage.parseResponseCreateCharacterFailureMessage(byteBuffer,pool,customParserMap);
|
||||
break;
|
||||
case TypeBytes.CHARACTER_MESSAGE_TYPE_REQUESTSPAWNCHARACTER:
|
||||
if(CharacterMessage.canParseMessage(byteBuffer,secondByte)){
|
||||
rVal = CharacterMessage.parseRequestSpawnCharacterMessage(byteBuffer,pool,customParserMap);
|
||||
}
|
||||
rVal = CharacterMessage.parseRequestSpawnCharacterMessage(byteBuffer,pool,customParserMap);
|
||||
break;
|
||||
case TypeBytes.CHARACTER_MESSAGE_TYPE_RESPONSESPAWNCHARACTER:
|
||||
if(CharacterMessage.canParseMessage(byteBuffer,secondByte)){
|
||||
rVal = CharacterMessage.parseResponseSpawnCharacterMessage(byteBuffer,pool,customParserMap);
|
||||
}
|
||||
rVal = CharacterMessage.parseResponseSpawnCharacterMessage(byteBuffer,pool,customParserMap);
|
||||
break;
|
||||
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;
|
||||
case TypeBytes.MESSAGE_TYPE_INVENTORY:
|
||||
secondByte = byteBuffer.peek(1);
|
||||
secondByte = byteBuffer.get();
|
||||
switch(secondByte){
|
||||
case TypeBytes.INVENTORY_MESSAGE_TYPE_ADDITEMTOINVENTORY:
|
||||
if(InventoryMessage.canParseMessage(byteBuffer,secondByte)){
|
||||
rVal = InventoryMessage.parseaddItemToInventoryMessage(byteBuffer,pool,customParserMap);
|
||||
}
|
||||
rVal = InventoryMessage.parseaddItemToInventoryMessage(byteBuffer,pool,customParserMap);
|
||||
break;
|
||||
case TypeBytes.INVENTORY_MESSAGE_TYPE_REMOVEITEMFROMINVENTORY:
|
||||
if(InventoryMessage.canParseMessage(byteBuffer,secondByte)){
|
||||
rVal = InventoryMessage.parseremoveItemFromInventoryMessage(byteBuffer,pool,customParserMap);
|
||||
}
|
||||
rVal = InventoryMessage.parseremoveItemFromInventoryMessage(byteBuffer,pool,customParserMap);
|
||||
break;
|
||||
case TypeBytes.INVENTORY_MESSAGE_TYPE_CLIENTREQUESTEQUIPITEM:
|
||||
if(InventoryMessage.canParseMessage(byteBuffer,secondByte)){
|
||||
rVal = InventoryMessage.parseclientRequestEquipItemMessage(byteBuffer,pool,customParserMap);
|
||||
}
|
||||
rVal = InventoryMessage.parseclientRequestEquipItemMessage(byteBuffer,pool,customParserMap);
|
||||
break;
|
||||
case TypeBytes.INVENTORY_MESSAGE_TYPE_SERVERCOMMANDMOVEITEMCONTAINER:
|
||||
if(InventoryMessage.canParseMessage(byteBuffer,secondByte)){
|
||||
rVal = InventoryMessage.parseserverCommandMoveItemContainerMessage(byteBuffer,pool,customParserMap);
|
||||
}
|
||||
rVal = InventoryMessage.parseserverCommandMoveItemContainerMessage(byteBuffer,pool,customParserMap);
|
||||
break;
|
||||
case TypeBytes.INVENTORY_MESSAGE_TYPE_SERVERCOMMANDEQUIPITEM:
|
||||
if(InventoryMessage.canParseMessage(byteBuffer,secondByte)){
|
||||
rVal = InventoryMessage.parseserverCommandEquipItemMessage(byteBuffer,pool,customParserMap);
|
||||
}
|
||||
rVal = InventoryMessage.parseserverCommandEquipItemMessage(byteBuffer,pool,customParserMap);
|
||||
break;
|
||||
case TypeBytes.INVENTORY_MESSAGE_TYPE_SERVERCOMMANDUNEQUIPITEM:
|
||||
if(InventoryMessage.canParseMessage(byteBuffer,secondByte)){
|
||||
rVal = InventoryMessage.parseserverCommandUnequipItemMessage(byteBuffer,pool,customParserMap);
|
||||
}
|
||||
rVal = InventoryMessage.parseserverCommandUnequipItemMessage(byteBuffer,pool,customParserMap);
|
||||
break;
|
||||
case TypeBytes.INVENTORY_MESSAGE_TYPE_CLIENTREQUESTUNEQUIPITEM:
|
||||
if(InventoryMessage.canParseMessage(byteBuffer,secondByte)){
|
||||
rVal = InventoryMessage.parseclientRequestUnequipItemMessage(byteBuffer,pool,customParserMap);
|
||||
}
|
||||
rVal = InventoryMessage.parseclientRequestUnequipItemMessage(byteBuffer,pool,customParserMap);
|
||||
break;
|
||||
case TypeBytes.INVENTORY_MESSAGE_TYPE_CLIENTREQUESTSTOREITEM:
|
||||
if(InventoryMessage.canParseMessage(byteBuffer,secondByte)){
|
||||
rVal = InventoryMessage.parseclientRequestStoreItemMessage(byteBuffer,pool,customParserMap);
|
||||
}
|
||||
rVal = InventoryMessage.parseclientRequestStoreItemMessage(byteBuffer,pool,customParserMap);
|
||||
break;
|
||||
case TypeBytes.INVENTORY_MESSAGE_TYPE_SERVERCOMMANDSTOREITEM:
|
||||
if(InventoryMessage.canParseMessage(byteBuffer,secondByte)){
|
||||
rVal = InventoryMessage.parseserverCommandStoreItemMessage(byteBuffer,pool,customParserMap);
|
||||
}
|
||||
rVal = InventoryMessage.parseserverCommandStoreItemMessage(byteBuffer,pool,customParserMap);
|
||||
break;
|
||||
case TypeBytes.INVENTORY_MESSAGE_TYPE_CLIENTREQUESTWATCHINVENTORY:
|
||||
if(InventoryMessage.canParseMessage(byteBuffer,secondByte)){
|
||||
rVal = InventoryMessage.parseclientRequestWatchInventoryMessage(byteBuffer,pool,customParserMap);
|
||||
}
|
||||
rVal = InventoryMessage.parseclientRequestWatchInventoryMessage(byteBuffer,pool,customParserMap);
|
||||
break;
|
||||
case TypeBytes.INVENTORY_MESSAGE_TYPE_CLIENTREQUESTUNWATCHINVENTORY:
|
||||
if(InventoryMessage.canParseMessage(byteBuffer,secondByte)){
|
||||
rVal = InventoryMessage.parseclientRequestUnwatchInventoryMessage(byteBuffer,pool,customParserMap);
|
||||
}
|
||||
rVal = InventoryMessage.parseclientRequestUnwatchInventoryMessage(byteBuffer,pool,customParserMap);
|
||||
break;
|
||||
case TypeBytes.INVENTORY_MESSAGE_TYPE_CLIENTREQUESTADDTOOLBAR:
|
||||
if(InventoryMessage.canParseMessage(byteBuffer,secondByte)){
|
||||
rVal = InventoryMessage.parseclientRequestAddToolbarMessage(byteBuffer,pool,customParserMap);
|
||||
}
|
||||
rVal = InventoryMessage.parseclientRequestAddToolbarMessage(byteBuffer,pool,customParserMap);
|
||||
break;
|
||||
case TypeBytes.INVENTORY_MESSAGE_TYPE_CLIENTREQUESTADDNATURAL:
|
||||
if(InventoryMessage.canParseMessage(byteBuffer,secondByte)){
|
||||
rVal = InventoryMessage.parseclientRequestAddNaturalMessage(byteBuffer,pool,customParserMap);
|
||||
}
|
||||
rVal = InventoryMessage.parseclientRequestAddNaturalMessage(byteBuffer,pool,customParserMap);
|
||||
break;
|
||||
case TypeBytes.INVENTORY_MESSAGE_TYPE_CLIENTUPDATETOOLBAR:
|
||||
if(InventoryMessage.canParseMessage(byteBuffer,secondByte)){
|
||||
rVal = InventoryMessage.parseclientUpdateToolbarMessage(byteBuffer,pool,customParserMap);
|
||||
}
|
||||
rVal = InventoryMessage.parseclientUpdateToolbarMessage(byteBuffer,pool,customParserMap);
|
||||
break;
|
||||
case TypeBytes.INVENTORY_MESSAGE_TYPE_CLIENTREQUESTPERFORMITEMACTION:
|
||||
if(InventoryMessage.canParseMessage(byteBuffer,secondByte)){
|
||||
rVal = InventoryMessage.parseclientRequestPerformItemActionMessage(byteBuffer,pool,customParserMap);
|
||||
}
|
||||
rVal = InventoryMessage.parseclientRequestPerformItemActionMessage(byteBuffer,pool,customParserMap);
|
||||
break;
|
||||
case TypeBytes.INVENTORY_MESSAGE_TYPE_CLIENTREQUESTCRAFT:
|
||||
if(InventoryMessage.canParseMessage(byteBuffer,secondByte)){
|
||||
rVal = InventoryMessage.parseclientRequestCraftMessage(byteBuffer,pool,customParserMap);
|
||||
}
|
||||
rVal = InventoryMessage.parseclientRequestCraftMessage(byteBuffer,pool,customParserMap);
|
||||
break;
|
||||
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;
|
||||
case TypeBytes.MESSAGE_TYPE_SYNCHRONIZATION:
|
||||
secondByte = byteBuffer.peek(1);
|
||||
secondByte = byteBuffer.get();
|
||||
switch(secondByte){
|
||||
case TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_UPDATECLIENTSTATE:
|
||||
if(SynchronizationMessage.canParseMessage(byteBuffer,secondByte)){
|
||||
rVal = SynchronizationMessage.parseUpdateClientStateMessage(byteBuffer,pool,customParserMap);
|
||||
}
|
||||
rVal = SynchronizationMessage.parseUpdateClientStateMessage(byteBuffer,pool,customParserMap);
|
||||
break;
|
||||
case TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_UPDATECLIENTSTRINGSTATE:
|
||||
if(SynchronizationMessage.canParseMessage(byteBuffer,secondByte)){
|
||||
rVal = SynchronizationMessage.parseUpdateClientStringStateMessage(byteBuffer,pool,customParserMap);
|
||||
}
|
||||
rVal = SynchronizationMessage.parseUpdateClientStringStateMessage(byteBuffer,pool,customParserMap);
|
||||
break;
|
||||
case TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_UPDATECLIENTINTSTATE:
|
||||
if(SynchronizationMessage.canParseMessage(byteBuffer,secondByte)){
|
||||
rVal = SynchronizationMessage.parseUpdateClientIntStateMessage(byteBuffer,pool,customParserMap);
|
||||
}
|
||||
rVal = SynchronizationMessage.parseUpdateClientIntStateMessage(byteBuffer,pool,customParserMap);
|
||||
break;
|
||||
case TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_UPDATECLIENTLONGSTATE:
|
||||
if(SynchronizationMessage.canParseMessage(byteBuffer,secondByte)){
|
||||
rVal = SynchronizationMessage.parseUpdateClientLongStateMessage(byteBuffer,pool,customParserMap);
|
||||
}
|
||||
rVal = SynchronizationMessage.parseUpdateClientLongStateMessage(byteBuffer,pool,customParserMap);
|
||||
break;
|
||||
case TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_UPDATECLIENTFLOATSTATE:
|
||||
if(SynchronizationMessage.canParseMessage(byteBuffer,secondByte)){
|
||||
rVal = SynchronizationMessage.parseUpdateClientFloatStateMessage(byteBuffer,pool,customParserMap);
|
||||
}
|
||||
rVal = SynchronizationMessage.parseUpdateClientFloatStateMessage(byteBuffer,pool,customParserMap);
|
||||
break;
|
||||
case TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_UPDATECLIENTDOUBLESTATE:
|
||||
if(SynchronizationMessage.canParseMessage(byteBuffer,secondByte)){
|
||||
rVal = SynchronizationMessage.parseUpdateClientDoubleStateMessage(byteBuffer,pool,customParserMap);
|
||||
}
|
||||
rVal = SynchronizationMessage.parseUpdateClientDoubleStateMessage(byteBuffer,pool,customParserMap);
|
||||
break;
|
||||
case TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_CLIENTREQUESTBTREEACTION:
|
||||
if(SynchronizationMessage.canParseMessage(byteBuffer,secondByte)){
|
||||
rVal = SynchronizationMessage.parseClientRequestBTreeActionMessage(byteBuffer,pool,customParserMap);
|
||||
}
|
||||
rVal = SynchronizationMessage.parseClientRequestBTreeActionMessage(byteBuffer,pool,customParserMap);
|
||||
break;
|
||||
case TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_SERVERNOTIFYBTREETRANSITION:
|
||||
if(SynchronizationMessage.canParseMessage(byteBuffer,secondByte)){
|
||||
rVal = SynchronizationMessage.parseServerNotifyBTreeTransitionMessage(byteBuffer,pool,customParserMap);
|
||||
}
|
||||
rVal = SynchronizationMessage.parseServerNotifyBTreeTransitionMessage(byteBuffer,pool,customParserMap);
|
||||
break;
|
||||
case TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_ATTACHTREE:
|
||||
if(SynchronizationMessage.canParseMessage(byteBuffer,secondByte)){
|
||||
rVal = SynchronizationMessage.parseAttachTreeMessage(byteBuffer,pool,customParserMap);
|
||||
}
|
||||
rVal = SynchronizationMessage.parseAttachTreeMessage(byteBuffer,pool,customParserMap);
|
||||
break;
|
||||
case TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_DETATCHTREE:
|
||||
if(SynchronizationMessage.canParseMessage(byteBuffer,secondByte)){
|
||||
rVal = SynchronizationMessage.parseDetatchTreeMessage(byteBuffer,pool,customParserMap);
|
||||
}
|
||||
rVal = SynchronizationMessage.parseDetatchTreeMessage(byteBuffer,pool,customParserMap);
|
||||
break;
|
||||
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;
|
||||
case TypeBytes.MESSAGE_TYPE_COMBAT:
|
||||
secondByte = byteBuffer.peek(1);
|
||||
secondByte = byteBuffer.get();
|
||||
switch(secondByte){
|
||||
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;
|
||||
}
|
||||
if(rVal == null){
|
||||
//failed to read the message
|
||||
byteBuffer.position(initialPosition);
|
||||
}
|
||||
}
|
||||
return rVal;
|
||||
}
|
||||
|
||||
@ -2,7 +2,7 @@ package electrosphere.net.parser.net.message;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.io.OutputStream;
|
||||
import io.github.studiorailgun.CircularByteBuffer;
|
||||
import java.nio.ByteBuffer;
|
||||
import electrosphere.net.parser.util.ByteStreamUtils;
|
||||
import java.util.Map;
|
||||
import java.util.function.BiConsumer;
|
||||
@ -102,46 +102,16 @@ public class PlayerMessage extends NetworkMessage {
|
||||
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
|
||||
*/
|
||||
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);
|
||||
rVal.messageType = PlayerMessageType.SET_ID;
|
||||
PlayerMessage.stripPacketHeader(byteBuffer);
|
||||
rVal.setplayerID(ByteStreamUtils.popIntFromByteQueue(byteBuffer));
|
||||
rVal.setplayerID(byteBuffer.getInt());
|
||||
return rVal;
|
||||
}
|
||||
|
||||
@ -157,13 +127,15 @@ public class PlayerMessage extends NetworkMessage {
|
||||
/**
|
||||
* 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);
|
||||
rVal.messageType = PlayerMessageType.SETINITIALDISCRETEPOSITION;
|
||||
PlayerMessage.stripPacketHeader(byteBuffer);
|
||||
rVal.setinitialDiscretePositionX(ByteStreamUtils.popIntFromByteQueue(byteBuffer));
|
||||
rVal.setinitialDiscretePositionY(ByteStreamUtils.popIntFromByteQueue(byteBuffer));
|
||||
rVal.setinitialDiscretePositionZ(ByteStreamUtils.popIntFromByteQueue(byteBuffer));
|
||||
rVal.setinitialDiscretePositionX(byteBuffer.getInt());
|
||||
rVal.setinitialDiscretePositionY(byteBuffer.getInt());
|
||||
rVal.setinitialDiscretePositionZ(byteBuffer.getInt());
|
||||
return rVal;
|
||||
}
|
||||
|
||||
@ -220,20 +192,30 @@ public class PlayerMessage extends NetworkMessage {
|
||||
@Override
|
||||
public void write(OutputStream stream) throws IOException {
|
||||
switch(this.messageType){
|
||||
case SET_ID:
|
||||
case SET_ID: {
|
||||
|
||||
//
|
||||
//message header
|
||||
stream.write(TypeBytes.MESSAGE_TYPE_PLAYER);
|
||||
stream.write(TypeBytes.PLAYER_MESSAGE_TYPE_SET_ID);
|
||||
|
||||
//
|
||||
//Write body of packet
|
||||
ByteStreamUtils.writeInt(stream, playerID);
|
||||
break;
|
||||
case SETINITIALDISCRETEPOSITION:
|
||||
} break;
|
||||
case SETINITIALDISCRETEPOSITION: {
|
||||
|
||||
//
|
||||
//message header
|
||||
stream.write(TypeBytes.MESSAGE_TYPE_PLAYER);
|
||||
stream.write(TypeBytes.PLAYER_MESSAGE_TYPE_SETINITIALDISCRETEPOSITION);
|
||||
|
||||
//
|
||||
//Write body of packet
|
||||
ByteStreamUtils.writeInt(stream, initialDiscretePositionX);
|
||||
ByteStreamUtils.writeInt(stream, initialDiscretePositionY);
|
||||
ByteStreamUtils.writeInt(stream, initialDiscretePositionZ);
|
||||
break;
|
||||
} break;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -2,7 +2,7 @@ package electrosphere.net.parser.net.message;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.io.OutputStream;
|
||||
import io.github.studiorailgun.CircularByteBuffer;
|
||||
import java.nio.ByteBuffer;
|
||||
import java.util.Map;
|
||||
import java.util.function.BiConsumer;
|
||||
|
||||
@ -42,51 +42,15 @@ public class ServerMessage extends NetworkMessage {
|
||||
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
|
||||
*/
|
||||
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);
|
||||
rVal.messageType = ServerMessageType.PING;
|
||||
ServerMessage.stripPacketHeader(byteBuffer);
|
||||
return rVal;
|
||||
}
|
||||
|
||||
@ -101,10 +65,12 @@ public class ServerMessage extends NetworkMessage {
|
||||
/**
|
||||
* 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);
|
||||
rVal.messageType = ServerMessageType.PONG;
|
||||
ServerMessage.stripPacketHeader(byteBuffer);
|
||||
return rVal;
|
||||
}
|
||||
|
||||
@ -119,10 +85,12 @@ public class ServerMessage extends NetworkMessage {
|
||||
/**
|
||||
* 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);
|
||||
rVal.messageType = ServerMessageType.DISCONNECT;
|
||||
ServerMessage.stripPacketHeader(byteBuffer);
|
||||
return rVal;
|
||||
}
|
||||
|
||||
@ -166,21 +134,36 @@ public class ServerMessage extends NetworkMessage {
|
||||
@Override
|
||||
public void write(OutputStream stream) throws IOException {
|
||||
switch(this.messageType){
|
||||
case PING:
|
||||
case PING: {
|
||||
|
||||
//
|
||||
//message header
|
||||
stream.write(TypeBytes.MESSAGE_TYPE_SERVER);
|
||||
stream.write(TypeBytes.SERVER_MESSAGE_TYPE_PING);
|
||||
break;
|
||||
case PONG:
|
||||
|
||||
//
|
||||
//Write body of packet
|
||||
} break;
|
||||
case PONG: {
|
||||
|
||||
//
|
||||
//message header
|
||||
stream.write(TypeBytes.MESSAGE_TYPE_SERVER);
|
||||
stream.write(TypeBytes.SERVER_MESSAGE_TYPE_PONG);
|
||||
break;
|
||||
case DISCONNECT:
|
||||
|
||||
//
|
||||
//Write body of packet
|
||||
} break;
|
||||
case DISCONNECT: {
|
||||
|
||||
//
|
||||
//message header
|
||||
stream.write(TypeBytes.MESSAGE_TYPE_SERVER);
|
||||
stream.write(TypeBytes.SERVER_MESSAGE_TYPE_DISCONNECT);
|
||||
break;
|
||||
|
||||
//
|
||||
//Write body of packet
|
||||
} break;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -2,11 +2,8 @@ package electrosphere.net.parser.net.message;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.io.OutputStream;
|
||||
import io.github.studiorailgun.CircularByteBuffer;
|
||||
import java.nio.ByteBuffer;
|
||||
import electrosphere.net.parser.util.ByteStreamUtils;
|
||||
import java.util.LinkedList;
|
||||
import java.util.List;
|
||||
|
||||
import java.util.Map;
|
||||
import java.util.function.BiConsumer;
|
||||
|
||||
@ -189,95 +186,19 @@ public class SynchronizationMessage extends NetworkMessage {
|
||||
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
|
||||
*/
|
||||
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);
|
||||
rVal.messageType = SynchronizationMessageType.UPDATECLIENTSTATE;
|
||||
SynchronizationMessage.stripPacketHeader(byteBuffer);
|
||||
rVal.setentityId(ByteStreamUtils.popIntFromByteQueue(byteBuffer));
|
||||
rVal.setbTreeId(ByteStreamUtils.popIntFromByteQueue(byteBuffer));
|
||||
rVal.setfieldId(ByteStreamUtils.popIntFromByteQueue(byteBuffer));
|
||||
rVal.setbTreeValue(ByteStreamUtils.popIntFromByteQueue(byteBuffer));
|
||||
rVal.setentityId(byteBuffer.getInt());
|
||||
rVal.setbTreeId(byteBuffer.getInt());
|
||||
rVal.setfieldId(byteBuffer.getInt());
|
||||
rVal.setbTreeValue(byteBuffer.getInt());
|
||||
return rVal;
|
||||
}
|
||||
|
||||
@ -293,48 +214,27 @@ public class SynchronizationMessage extends NetworkMessage {
|
||||
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
|
||||
*/
|
||||
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);
|
||||
rVal.messageType = SynchronizationMessageType.UPDATECLIENTSTRINGSTATE;
|
||||
SynchronizationMessage.stripPacketHeader(byteBuffer);
|
||||
rVal.setentityId(ByteStreamUtils.popIntFromByteQueue(byteBuffer));
|
||||
rVal.setbTreeId(ByteStreamUtils.popIntFromByteQueue(byteBuffer));
|
||||
rVal.setfieldId(ByteStreamUtils.popIntFromByteQueue(byteBuffer));
|
||||
rVal.setstringValue(ByteStreamUtils.popStringFromByteQueue(byteBuffer));
|
||||
rVal.setentityId(byteBuffer.getInt());
|
||||
rVal.setbTreeId(byteBuffer.getInt());
|
||||
rVal.setfieldId(byteBuffer.getInt());
|
||||
if(stringValuelen > 0){
|
||||
rVal.setstringValue(ByteStreamUtils.popStringFromByteBuffer(byteBuffer, stringValuelen));
|
||||
}
|
||||
return rVal;
|
||||
}
|
||||
|
||||
@ -353,14 +253,16 @@ public class SynchronizationMessage extends NetworkMessage {
|
||||
/**
|
||||
* 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);
|
||||
rVal.messageType = SynchronizationMessageType.UPDATECLIENTINTSTATE;
|
||||
SynchronizationMessage.stripPacketHeader(byteBuffer);
|
||||
rVal.setentityId(ByteStreamUtils.popIntFromByteQueue(byteBuffer));
|
||||
rVal.setbTreeId(ByteStreamUtils.popIntFromByteQueue(byteBuffer));
|
||||
rVal.setfieldId(ByteStreamUtils.popIntFromByteQueue(byteBuffer));
|
||||
rVal.setintValue(ByteStreamUtils.popIntFromByteQueue(byteBuffer));
|
||||
rVal.setentityId(byteBuffer.getInt());
|
||||
rVal.setbTreeId(byteBuffer.getInt());
|
||||
rVal.setfieldId(byteBuffer.getInt());
|
||||
rVal.setintValue(byteBuffer.getInt());
|
||||
return rVal;
|
||||
}
|
||||
|
||||
@ -379,14 +281,16 @@ public class SynchronizationMessage extends NetworkMessage {
|
||||
/**
|
||||
* 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);
|
||||
rVal.messageType = SynchronizationMessageType.UPDATECLIENTLONGSTATE;
|
||||
SynchronizationMessage.stripPacketHeader(byteBuffer);
|
||||
rVal.setentityId(ByteStreamUtils.popIntFromByteQueue(byteBuffer));
|
||||
rVal.setbTreeId(ByteStreamUtils.popIntFromByteQueue(byteBuffer));
|
||||
rVal.setfieldId(ByteStreamUtils.popIntFromByteQueue(byteBuffer));
|
||||
rVal.setlongValue(ByteStreamUtils.popLongFromByteQueue(byteBuffer));
|
||||
rVal.setentityId(byteBuffer.getInt());
|
||||
rVal.setbTreeId(byteBuffer.getInt());
|
||||
rVal.setfieldId(byteBuffer.getInt());
|
||||
rVal.setlongValue(byteBuffer.getLong());
|
||||
return rVal;
|
||||
}
|
||||
|
||||
@ -405,14 +309,16 @@ public class SynchronizationMessage extends NetworkMessage {
|
||||
/**
|
||||
* 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);
|
||||
rVal.messageType = SynchronizationMessageType.UPDATECLIENTFLOATSTATE;
|
||||
SynchronizationMessage.stripPacketHeader(byteBuffer);
|
||||
rVal.setentityId(ByteStreamUtils.popIntFromByteQueue(byteBuffer));
|
||||
rVal.setbTreeId(ByteStreamUtils.popIntFromByteQueue(byteBuffer));
|
||||
rVal.setfieldId(ByteStreamUtils.popIntFromByteQueue(byteBuffer));
|
||||
rVal.setfloatValue(ByteStreamUtils.popFloatFromByteQueue(byteBuffer));
|
||||
rVal.setentityId(byteBuffer.getInt());
|
||||
rVal.setbTreeId(byteBuffer.getInt());
|
||||
rVal.setfieldId(byteBuffer.getInt());
|
||||
rVal.setfloatValue(byteBuffer.getFloat());
|
||||
return rVal;
|
||||
}
|
||||
|
||||
@ -431,14 +337,16 @@ public class SynchronizationMessage extends NetworkMessage {
|
||||
/**
|
||||
* 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);
|
||||
rVal.messageType = SynchronizationMessageType.UPDATECLIENTDOUBLESTATE;
|
||||
SynchronizationMessage.stripPacketHeader(byteBuffer);
|
||||
rVal.setentityId(ByteStreamUtils.popIntFromByteQueue(byteBuffer));
|
||||
rVal.setbTreeId(ByteStreamUtils.popIntFromByteQueue(byteBuffer));
|
||||
rVal.setfieldId(ByteStreamUtils.popIntFromByteQueue(byteBuffer));
|
||||
rVal.setdoubleValue(ByteStreamUtils.popDoubleFromByteQueue(byteBuffer));
|
||||
rVal.setentityId(byteBuffer.getInt());
|
||||
rVal.setbTreeId(byteBuffer.getInt());
|
||||
rVal.setfieldId(byteBuffer.getInt());
|
||||
rVal.setdoubleValue(byteBuffer.getDouble());
|
||||
return rVal;
|
||||
}
|
||||
|
||||
@ -457,13 +365,15 @@ public class SynchronizationMessage extends NetworkMessage {
|
||||
/**
|
||||
* 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);
|
||||
rVal.messageType = SynchronizationMessageType.CLIENTREQUESTBTREEACTION;
|
||||
SynchronizationMessage.stripPacketHeader(byteBuffer);
|
||||
rVal.setentityId(ByteStreamUtils.popIntFromByteQueue(byteBuffer));
|
||||
rVal.setbTreeId(ByteStreamUtils.popIntFromByteQueue(byteBuffer));
|
||||
rVal.setbTreeValue(ByteStreamUtils.popIntFromByteQueue(byteBuffer));
|
||||
rVal.setentityId(byteBuffer.getInt());
|
||||
rVal.setbTreeId(byteBuffer.getInt());
|
||||
rVal.setbTreeValue(byteBuffer.getInt());
|
||||
return rVal;
|
||||
}
|
||||
|
||||
@ -481,14 +391,16 @@ public class SynchronizationMessage extends NetworkMessage {
|
||||
/**
|
||||
* 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);
|
||||
rVal.messageType = SynchronizationMessageType.SERVERNOTIFYBTREETRANSITION;
|
||||
SynchronizationMessage.stripPacketHeader(byteBuffer);
|
||||
rVal.setentityId(ByteStreamUtils.popIntFromByteQueue(byteBuffer));
|
||||
rVal.setbTreeId(ByteStreamUtils.popIntFromByteQueue(byteBuffer));
|
||||
rVal.setfieldId(ByteStreamUtils.popIntFromByteQueue(byteBuffer));
|
||||
rVal.setbTreeValue(ByteStreamUtils.popIntFromByteQueue(byteBuffer));
|
||||
rVal.setentityId(byteBuffer.getInt());
|
||||
rVal.setbTreeId(byteBuffer.getInt());
|
||||
rVal.setfieldId(byteBuffer.getInt());
|
||||
rVal.setbTreeValue(byteBuffer.getInt());
|
||||
return rVal;
|
||||
}
|
||||
|
||||
@ -507,12 +419,14 @@ public class SynchronizationMessage extends NetworkMessage {
|
||||
/**
|
||||
* 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);
|
||||
rVal.messageType = SynchronizationMessageType.ATTACHTREE;
|
||||
SynchronizationMessage.stripPacketHeader(byteBuffer);
|
||||
rVal.setentityId(ByteStreamUtils.popIntFromByteQueue(byteBuffer));
|
||||
rVal.setbTreeId(ByteStreamUtils.popIntFromByteQueue(byteBuffer));
|
||||
rVal.setentityId(byteBuffer.getInt());
|
||||
rVal.setbTreeId(byteBuffer.getInt());
|
||||
return rVal;
|
||||
}
|
||||
|
||||
@ -529,12 +443,14 @@ public class SynchronizationMessage extends NetworkMessage {
|
||||
/**
|
||||
* 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);
|
||||
rVal.messageType = SynchronizationMessageType.DETATCHTREE;
|
||||
SynchronizationMessage.stripPacketHeader(byteBuffer);
|
||||
rVal.setentityId(ByteStreamUtils.popIntFromByteQueue(byteBuffer));
|
||||
rVal.setbTreeId(ByteStreamUtils.popIntFromByteQueue(byteBuffer));
|
||||
rVal.setentityId(byteBuffer.getInt());
|
||||
rVal.setbTreeId(byteBuffer.getInt());
|
||||
return rVal;
|
||||
}
|
||||
|
||||
@ -548,36 +464,24 @@ public class SynchronizationMessage extends NetworkMessage {
|
||||
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
|
||||
*/
|
||||
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);
|
||||
rVal.messageType = SynchronizationMessageType.LOADSCENE;
|
||||
SynchronizationMessage.stripPacketHeader(byteBuffer);
|
||||
rVal.setstringValue(ByteStreamUtils.popStringFromByteQueue(byteBuffer));
|
||||
if(stringValuelen > 0){
|
||||
rVal.setstringValue(ByteStreamUtils.popStringFromByteBuffer(byteBuffer, stringValuelen));
|
||||
}
|
||||
return rVal;
|
||||
}
|
||||
|
||||
@ -831,97 +735,160 @@ public class SynchronizationMessage extends NetworkMessage {
|
||||
@Override
|
||||
public void write(OutputStream stream) throws IOException {
|
||||
switch(this.messageType){
|
||||
case UPDATECLIENTSTATE:
|
||||
case UPDATECLIENTSTATE: {
|
||||
|
||||
//
|
||||
//message header
|
||||
stream.write(TypeBytes.MESSAGE_TYPE_SYNCHRONIZATION);
|
||||
stream.write(TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_UPDATECLIENTSTATE);
|
||||
|
||||
//
|
||||
//Write body of packet
|
||||
ByteStreamUtils.writeInt(stream, entityId);
|
||||
ByteStreamUtils.writeInt(stream, bTreeId);
|
||||
ByteStreamUtils.writeInt(stream, fieldId);
|
||||
ByteStreamUtils.writeInt(stream, bTreeValue);
|
||||
break;
|
||||
case UPDATECLIENTSTRINGSTATE:
|
||||
} break;
|
||||
case UPDATECLIENTSTRINGSTATE: {
|
||||
|
||||
//
|
||||
//message header
|
||||
stream.write(TypeBytes.MESSAGE_TYPE_SYNCHRONIZATION);
|
||||
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, bTreeId);
|
||||
ByteStreamUtils.writeInt(stream, fieldId);
|
||||
ByteStreamUtils.writeString(stream, stringValue);
|
||||
break;
|
||||
case UPDATECLIENTINTSTATE:
|
||||
} break;
|
||||
case UPDATECLIENTINTSTATE: {
|
||||
|
||||
//
|
||||
//message header
|
||||
stream.write(TypeBytes.MESSAGE_TYPE_SYNCHRONIZATION);
|
||||
stream.write(TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_UPDATECLIENTINTSTATE);
|
||||
|
||||
//
|
||||
//Write body of packet
|
||||
ByteStreamUtils.writeInt(stream, entityId);
|
||||
ByteStreamUtils.writeInt(stream, bTreeId);
|
||||
ByteStreamUtils.writeInt(stream, fieldId);
|
||||
ByteStreamUtils.writeInt(stream, intValue);
|
||||
break;
|
||||
case UPDATECLIENTLONGSTATE:
|
||||
} break;
|
||||
case UPDATECLIENTLONGSTATE: {
|
||||
|
||||
//
|
||||
//message header
|
||||
stream.write(TypeBytes.MESSAGE_TYPE_SYNCHRONIZATION);
|
||||
stream.write(TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_UPDATECLIENTLONGSTATE);
|
||||
|
||||
//
|
||||
//Write body of packet
|
||||
ByteStreamUtils.writeInt(stream, entityId);
|
||||
ByteStreamUtils.writeInt(stream, bTreeId);
|
||||
ByteStreamUtils.writeInt(stream, fieldId);
|
||||
ByteStreamUtils.writeLong(stream, longValue);
|
||||
break;
|
||||
case UPDATECLIENTFLOATSTATE:
|
||||
} break;
|
||||
case UPDATECLIENTFLOATSTATE: {
|
||||
|
||||
//
|
||||
//message header
|
||||
stream.write(TypeBytes.MESSAGE_TYPE_SYNCHRONIZATION);
|
||||
stream.write(TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_UPDATECLIENTFLOATSTATE);
|
||||
|
||||
//
|
||||
//Write body of packet
|
||||
ByteStreamUtils.writeInt(stream, entityId);
|
||||
ByteStreamUtils.writeInt(stream, bTreeId);
|
||||
ByteStreamUtils.writeInt(stream, fieldId);
|
||||
ByteStreamUtils.writeFloat(stream, floatValue);
|
||||
break;
|
||||
case UPDATECLIENTDOUBLESTATE:
|
||||
} break;
|
||||
case UPDATECLIENTDOUBLESTATE: {
|
||||
|
||||
//
|
||||
//message header
|
||||
stream.write(TypeBytes.MESSAGE_TYPE_SYNCHRONIZATION);
|
||||
stream.write(TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_UPDATECLIENTDOUBLESTATE);
|
||||
|
||||
//
|
||||
//Write body of packet
|
||||
ByteStreamUtils.writeInt(stream, entityId);
|
||||
ByteStreamUtils.writeInt(stream, bTreeId);
|
||||
ByteStreamUtils.writeInt(stream, fieldId);
|
||||
ByteStreamUtils.writeDouble(stream, doubleValue);
|
||||
break;
|
||||
case CLIENTREQUESTBTREEACTION:
|
||||
} break;
|
||||
case CLIENTREQUESTBTREEACTION: {
|
||||
|
||||
//
|
||||
//message header
|
||||
stream.write(TypeBytes.MESSAGE_TYPE_SYNCHRONIZATION);
|
||||
stream.write(TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_CLIENTREQUESTBTREEACTION);
|
||||
|
||||
//
|
||||
//Write body of packet
|
||||
ByteStreamUtils.writeInt(stream, entityId);
|
||||
ByteStreamUtils.writeInt(stream, bTreeId);
|
||||
ByteStreamUtils.writeInt(stream, bTreeValue);
|
||||
break;
|
||||
case SERVERNOTIFYBTREETRANSITION:
|
||||
} break;
|
||||
case SERVERNOTIFYBTREETRANSITION: {
|
||||
|
||||
//
|
||||
//message header
|
||||
stream.write(TypeBytes.MESSAGE_TYPE_SYNCHRONIZATION);
|
||||
stream.write(TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_SERVERNOTIFYBTREETRANSITION);
|
||||
|
||||
//
|
||||
//Write body of packet
|
||||
ByteStreamUtils.writeInt(stream, entityId);
|
||||
ByteStreamUtils.writeInt(stream, bTreeId);
|
||||
ByteStreamUtils.writeInt(stream, fieldId);
|
||||
ByteStreamUtils.writeInt(stream, bTreeValue);
|
||||
break;
|
||||
case ATTACHTREE:
|
||||
} break;
|
||||
case ATTACHTREE: {
|
||||
|
||||
//
|
||||
//message header
|
||||
stream.write(TypeBytes.MESSAGE_TYPE_SYNCHRONIZATION);
|
||||
stream.write(TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_ATTACHTREE);
|
||||
|
||||
//
|
||||
//Write body of packet
|
||||
ByteStreamUtils.writeInt(stream, entityId);
|
||||
ByteStreamUtils.writeInt(stream, bTreeId);
|
||||
break;
|
||||
case DETATCHTREE:
|
||||
} break;
|
||||
case DETATCHTREE: {
|
||||
|
||||
//
|
||||
//message header
|
||||
stream.write(TypeBytes.MESSAGE_TYPE_SYNCHRONIZATION);
|
||||
stream.write(TypeBytes.SYNCHRONIZATION_MESSAGE_TYPE_DETATCHTREE);
|
||||
|
||||
//
|
||||
//Write body of packet
|
||||
ByteStreamUtils.writeInt(stream, entityId);
|
||||
ByteStreamUtils.writeInt(stream, bTreeId);
|
||||
break;
|
||||
case LOADSCENE:
|
||||
} break;
|
||||
case LOADSCENE: {
|
||||
|
||||
//
|
||||
//message header
|
||||
stream.write(TypeBytes.MESSAGE_TYPE_SYNCHRONIZATION);
|
||||
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);
|
||||
break;
|
||||
} break;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,11 +1,11 @@
|
||||
package electrosphere.net.parser.net.raw;
|
||||
|
||||
import electrosphere.net.parser.net.message.MessagePool;
|
||||
import electrosphere.net.parser.net.message.NetworkMessage;
|
||||
import io.github.studiorailgun.CircularByteBuffer;
|
||||
package electrosphere.net.parser.net.raw;
|
||||
|
||||
import electrosphere.net.parser.net.message.MessagePool;
|
||||
import electrosphere.net.parser.net.message.NetworkMessage;
|
||||
import java.io.IOException;
|
||||
import java.io.InputStream;
|
||||
import java.io.OutputStream;
|
||||
import java.nio.ByteBuffer;
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
@ -55,7 +55,7 @@ public class NetworkParser {
|
||||
/**
|
||||
* 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
|
||||
@ -67,6 +67,11 @@ public class NetworkParser {
|
||||
*/
|
||||
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.
|
||||
* 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
|
||||
*/
|
||||
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,19 +100,60 @@ public class NetworkParser {
|
||||
public void readMessagesIn() throws IOException {
|
||||
//read in bytes
|
||||
int bytesRead = 0;
|
||||
while(incomingStream.available() > 0){
|
||||
// nextValue = incomingStream.read();
|
||||
bytesRead = incomingStream.read(readBuffer, 0, READ_BLOCK_SIZE);
|
||||
if(bytesRead > 0){
|
||||
incomingByteBuffer.add(readBuffer, bytesRead);
|
||||
if(incomingStream.available() > 0){
|
||||
//error check
|
||||
if(incomingByteBuffer.position() > 0){
|
||||
String message = "Invalid position!\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);
|
||||
}
|
||||
|
||||
//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;
|
||||
}
|
||||
//parse byte queue for messages
|
||||
//for each message, append to clientIncomingMessageQueue
|
||||
NetworkMessage newMessage;
|
||||
while((newMessage = NetworkMessage.parseBytestreamForMessage(incomingByteBuffer,this.pool,this.customParserMap))!=null){
|
||||
incomingMessageQueue.add(newMessage);
|
||||
if(existingBytes > 0 || bytesRead > 0){
|
||||
while((newMessage = NetworkMessage.parseBytestreamForMessage(incomingByteBuffer,this.pool,this.customParserMap)) != null){
|
||||
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 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);
|
||||
this.customParserMap.put(pair,parserFunc);
|
||||
}
|
||||
|
||||
@ -82,6 +82,13 @@ public class ByteStreamUtils {
|
||||
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){
|
||||
int length = popIntFromByteQueue(queue);
|
||||
byte[] bytes = new byte[length];
|
||||
@ -91,6 +98,12 @@ public class ByteStreamUtils {
|
||||
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){
|
||||
double rVal = -1;
|
||||
bufferLock.acquireUninterruptibly();
|
||||
@ -359,8 +372,6 @@ public class ByteStreamUtils {
|
||||
}
|
||||
|
||||
public static void writeString(OutputStream stream, String s) throws IOException {
|
||||
int length = s.length();
|
||||
writeInt(stream, length);
|
||||
byte[] stringBytes = s.getBytes();
|
||||
stream.write(stringBytes);
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user