diff --git a/.idea/ant.xml b/.idea/ant.xml
new file mode 100644
index 0000000..a2a4769
--- /dev/null
+++ b/.idea/ant.xml
@@ -0,0 +1,6 @@
+
+
+
+
+
+
\ No newline at end of file
diff --git a/.idea/laby.iml b/.idea/laby.iml
index 4b248d8..fd89b37 100644
--- a/.idea/laby.iml
+++ b/.idea/laby.iml
@@ -25,5 +25,6 @@
+
\ No newline at end of file
diff --git a/.idea/libraries/artgaphics_0_1_0.xml b/.idea/libraries/artgaphics_0_1_0.xml
deleted file mode 100644
index f00ac9e..0000000
--- a/.idea/libraries/artgaphics_0_1_0.xml
+++ /dev/null
@@ -1,9 +0,0 @@
-
-
-
-
-
-
-
-
-
\ No newline at end of file
diff --git a/.idea/libraries/zstd_jni_1_5_2_2.xml b/.idea/libraries/zstd_jni_1_5_2_2.xml
new file mode 100644
index 0000000..fadbd62
--- /dev/null
+++ b/.idea/libraries/zstd_jni_1_5_2_2.xml
@@ -0,0 +1,9 @@
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/build.xml b/build.xml
index c214aa5..68a5e9d 100644
--- a/build.xml
+++ b/build.xml
@@ -10,8 +10,11 @@
-
+
+
@@ -36,7 +39,7 @@
-
+
diff --git a/fetch_dependencies.sh b/fetch_dependencies.sh
index c72584c..4f8d6fe 100755
--- a/fetch_dependencies.sh
+++ b/fetch_dependencies.sh
@@ -14,6 +14,18 @@ fetch_jackson_databind()
fi
}
+fetch_zstd-jni()
+{
+
+ echo "compiled from https://github.com/luben/zstd-jni commit 54d3d50c16d96bd8a30e2d4c0a9648001a52d6f9"
+ # had to hack through jar generation ...
+ # cp ~/artisanlogiciel/ext_projects/java/zstd-jni/target/zstd-jni-1.5.2-2.jar .
+ libversion_zstdjni=1.5.2-2
+ pushd libs
+ wget https://repo1.maven.org/maven2/com/github/luben/zstd-jni/${libversion_zstdjni}/zstd-jni-${libversion_zstdjni}.jar
+ popd
+}
+
if [[ ! -d ../sharedrawweb ]]
then
echo "[ERROR] expected a sharedrawweb project parent ( for exports )" >&2
@@ -35,3 +47,5 @@ if [[ -n $use_jackson ]]
then
fetch_jackson_databind
fi
+
+fetch_zstd-jni
diff --git a/java/org/artisanlogiciel/games/maze/MainMim.java b/java/org/artisanlogiciel/games/maze/MainMim.java
new file mode 100644
index 0000000..936b7b9
--- /dev/null
+++ b/java/org/artisanlogiciel/games/maze/MainMim.java
@@ -0,0 +1,26 @@
+package org.artisanlogiciel.games.maze;
+
+import org.artisanlogiciel.games.minetest.net.MiM;
+
+import java.net.InetSocketAddress;
+
+public class MainMim {
+
+ void minetestMime(String serverName, int port) {
+ MiM mim = new MiM(30002, new InetSocketAddress(serverName, port));
+ mim.launch();
+ }
+
+ public static void main(String pArgs[])
+ {
+ if ( pArgs.length > 1)
+ {
+ new MainMim().minetestMime(pArgs[0], Integer.parseInt(pArgs[1]));
+ }
+ else
+ {
+ System.err.println("[ERROR] please set minetest server hostname and port as arguments");
+ }
+ }
+}
+
diff --git a/java/org/artisanlogiciel/games/maze/gui/Display.java b/java/org/artisanlogiciel/games/maze/gui/Display.java
index e070636..028ee7f 100644
--- a/java/org/artisanlogiciel/games/maze/gui/Display.java
+++ b/java/org/artisanlogiciel/games/maze/gui/Display.java
@@ -4,6 +4,7 @@ import org.artisanlogiciel.games.maze.*;
import org.artisanlogiciel.games.maze.model.WidthHeightProvider;
import org.artisanlogiciel.games.maze.persist.MazePersistRaw;
import org.artisanlogiciel.games.maze.solve.SolvingModel;
+import org.artisanlogiciel.games.minetest.net.MiM;
import org.artisanlogiciel.graphics.Drawing;
import org.artisanlogiciel.xpm.Xpm;
@@ -14,6 +15,7 @@ import java.awt.image.BufferedImage;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
+import java.net.InetSocketAddress;
import java.util.Locale;
/**
@@ -270,6 +272,7 @@ implements StatusListener
}
};
+
System.out.println("Default Locale " + Locale.getDefault());
if ((pArgs.length > 0) && (pArgs[0].length() > 0)) {
diff --git a/java/org/artisanlogiciel/games/minetest/MapBlock.java b/java/org/artisanlogiciel/games/minetest/MapBlock.java
new file mode 100644
index 0000000..5d5b3b4
--- /dev/null
+++ b/java/org/artisanlogiciel/games/minetest/MapBlock.java
@@ -0,0 +1,97 @@
+package org.artisanlogiciel.games.minetest;
+
+import com.github.luben.zstd.Zstd;
+import org.artisanlogiciel.games.minetest.core.Constant;
+import org.artisanlogiciel.games.minetest.core.PacketException;
+import org.artisanlogiciel.games.minetest.core.Serialize;
+
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+
+/**
+ * A block of nodes of MAP_BLOCKSIZE in any x,y,z direction
+ */
+public class MapBlock {
+
+ final static int nodecount = Constant.MAP_BLOCKSIZE * Constant.MAP_BLOCKSIZE * Constant.MAP_BLOCKSIZE;
+
+ int m_lighting_complete;
+
+ ArrayList nodes;
+
+ ArrayList getNodes()
+ {
+ if ( nodes == null )
+ {
+ nodes = new ArrayList<>(nodecount);
+ }
+ return nodes;
+ }
+
+ // in memory case
+ public void deSerialize(ByteBuffer buffer, int version)
+ throws PacketException
+ {
+
+ int flags = 0;
+ int content_width = 0;
+ int params_width = 0;
+
+ if ( version >= 29) {
+ // ByteBuffer byteBuffer = ByteBuffer.wrap(networkPacket.getBuffer(),offset,networkPacket.getLength() - offset);
+
+ /*
+ // force to have a direct buffer.
+ ByteBuffer byteBuffer = ByteBuffer.allocateDirect(networkPacket.getLength());
+ byteBuffer.put(networkPacket.getBuffer());
+ byteBuffer.position(networkPacket.getOffset());
+
+ //System.arraycopy(networkPacket.getBuffer(), 0, byteBuffer.array(), 0, length);
+ // zstd compression
+ // FIXME, can we know original size ? somehow related to BLOCKSIZE³
+ long originalSizeMax = Zstd.decompressedSize(byteBuffer);
+ System.out.println(String.format("originalSizeMax=%d", originalSizeMax));
+ ByteBuffer decompressed = Zstd.decompress(byteBuffer,(int) originalSizeMax);
+ */
+ byte out[] = new byte[16386];
+ long outLength = Zstd.decompressByteArray(out, 0, out.length, buffer.array(), buffer.arrayOffset(), buffer.limit());
+
+ // Should be a MapBlock
+ MapBlock block = new MapBlock();
+ ByteBuffer decompressed = ByteBuffer.wrap(out, 0, (int) outLength);
+ buffer = decompressed;
+ }
+
+ flags = Serialize.readU8(buffer);
+
+ if ( version >= 27 ) {
+ m_lighting_complete = Serialize.readU16(buffer);
+ }
+
+ content_width = Serialize.readU8(buffer);
+ params_width = Serialize.readU8(buffer);
+
+ System.out.println(String.format(" flags %x lightning_complete %d content_witd %d params_width %d ",flags, m_lighting_complete, content_width, params_width));
+
+ if (( version < 29 ) && ( version >= 11 ))
+ {
+ // ZLib decompression
+ try {
+ byte decompressed[] = Serialize.decompress(buffer);
+ buffer = ByteBuffer.wrap(decompressed);
+ }
+ catch ( Exception e)
+ {
+ // TODO
+ System.err.println(e);
+ e.printStackTrace(System.err);
+ return;
+ }
+ }
+
+ nodes = getNodes();
+ MapNode.deSerializeBulk(buffer,version, nodes,nodecount,content_width,params_width);
+
+ //m_node_metadata.deSerialize(is, m_gamedef->idef());
+ }
+}
diff --git a/java/org/artisanlogiciel/games/minetest/MapNode.java b/java/org/artisanlogiciel/games/minetest/MapNode.java
new file mode 100644
index 0000000..1dbaf1d
--- /dev/null
+++ b/java/org/artisanlogiciel/games/minetest/MapNode.java
@@ -0,0 +1,99 @@
+package org.artisanlogiciel.games.minetest;
+
+import org.artisanlogiciel.games.minetest.core.PacketException;
+import org.artisanlogiciel.games.minetest.core.Serialize;
+
+import java.nio.ByteBuffer;
+import java.util.List;
+
+public class MapNode {
+ /*
+ Main content
+ */
+ short param0;
+
+ /*
+ Misc parameter. Initialized to 0.
+ - For light_propagates() blocks, this is light intensity,
+ stored logarithmically from 0 to LIGHT_MAX.
+ Sunlight is LIGHT_SUN, which is LIGHT_MAX+1.
+ - Contains 2 values, day- and night lighting. Each takes 4 bits.
+ - Uhh... well, most blocks have light or nothing in here.
+ */
+ byte param1;
+
+ /*
+ The second parameter. Initialized to 0.
+ E.g. direction for torches and flowing water.
+ */
+ byte param2;
+
+ public void deSerialize(ByteBuffer buffer)
+ throws PacketException
+ {
+ // version >= 24
+ param0 = (short) Serialize.readU16(buffer);
+ buffer.position(buffer.position() + 2);
+ param1 = (byte) Serialize.readU8(buffer);
+ buffer.position(buffer.position() + 1);
+ param2 = (byte) Serialize.readU8(buffer);
+ // network specific ...
+ // readU8(is);
+
+ }
+
+ // Deserialize bulk node data
+ public static void deSerializeBulk(ByteBuffer buffer, int version,
+ List nodes, int nodecount,
+ int content_width, int params_width)
+ throws PacketException
+ {
+ byte[] intern = buffer.array();
+ int initialOffset = buffer.position();
+
+ // Deserialize content
+ if(content_width == 1)
+ {
+ for(int i=0; i 0x7F){
+ node.param0 <<= 4;
+ node.param0 |= (node.param2&0xF0)>>4;
+ node.param2 &= 0x0F;
+ }
+ }
+ }
+ else if(content_width == 2)
+ {
+ for(int i=0; i {runFromToServer(in,fromServer);});
+ running = true;
+ toServer.start();
+ }
+ catch(Exception e)
+ {
+ System.out.println("problem");
+ e.printStackTrace(System.err);
+ running = false;
+ }
+ }
+
+ public void stop()
+ {
+ running = false;
+ }
+
+ public void runFromToServer(DatagramSocket in, SocketAddress fromServer) {
+ try {
+
+ while (running) {
+ // quick way, a new buffer at each reception
+ // to handle split packets that are buffered
+ byte[] buf = new byte[4096];
+ SocketAddress toRemote = null;
+ DatagramPacket packet = new DatagramPacket(buf, buf.length);
+ in.receive(packet);
+ SocketAddress from = packet.getSocketAddress();
+ if ( from.equals(fromServer)) {
+ // no client yet
+ if ( fromClient == null )
+ {
+ continue;
+ }
+ fromServer(buf,packet.getLength());
+ toRemote = fromClient;
+ }
+ else
+ {
+ // record client
+ // later on to be smart : could try to record peer id ?
+ // will add a constraint : only one auth at a time
+ if ( fromClient == null ) {
+ fromClient = from;
+ }
+ fromClient(buf,packet.getLength());
+ toRemote = fromServer;
+ }
+ packet = new DatagramPacket(buf, packet.getLength(), toRemote);
+ in.send(packet);
+ }
+ }
+ catch( IOException ioException)
+ {
+ //
+ System.out.println("oops");
+ }
+ // socket.close();
+ }
+
+ void fromServer(byte[] buffer, int length)
+ {
+ try {
+ // reply from server
+ if (handler != null) {
+ handler.fromServer(buffer, length);
+ }
+ }
+ catch (PacketException packetException)
+ {
+ //
+ }
+ }
+
+ void fromClient(byte[] buffer, int length)
+ {
+ try {
+ // reply from client
+ if (handler != null) {
+ handler.fromClient(buffer, length);
+ }
+ }
+ catch (PacketException packetException)
+ {
+ //
+ }
+
+ }
+
+
+}
diff --git a/java/org/artisanlogiciel/games/minetest/net/NetworkPacket.java b/java/org/artisanlogiciel/games/minetest/net/NetworkPacket.java
new file mode 100644
index 0000000..d1c92f8
--- /dev/null
+++ b/java/org/artisanlogiciel/games/minetest/net/NetworkPacket.java
@@ -0,0 +1,70 @@
+package org.artisanlogiciel.games.minetest.net;
+
+import org.artisanlogiciel.games.minetest.core.PacketException;
+import org.artisanlogiciel.games.minetest.core.Serialize;
+import org.artisanlogiciel.games.minetest.core.v3s16;
+
+import java.nio.ByteBuffer;
+
+public class NetworkPacket {
+
+ int m_protocol_id;
+ int m_peer_id;
+ int m_channel;
+ public PacketType packetType;
+
+ // somehow a BufferedPacket ...
+ byte[] m_buffer; // m_data
+ // used part in buffer
+ int m_length; // m_datasize ?
+ // current header index in packet
+ int m_offset; // m_read_offset
+
+ short m_command = 0;
+
+ public NetworkPacket(int protocol_id, int peer_id, int channel, PacketType type, byte[] buffer, int length) {
+ this.m_protocol_id = protocol_id;
+ this.m_peer_id = peer_id;
+ this.m_channel = channel;
+ this.packetType = type;
+ m_buffer = buffer;
+ m_length = length;
+ m_offset = 0;
+ }
+
+ public int getChannel()
+ {
+ return m_channel;
+ }
+
+ public byte[] getBuffer()
+ {
+ return m_buffer;
+ }
+
+ public int getOffset() {
+ return m_offset;
+ }
+
+ public int getLength() {
+ return m_length;
+ }
+
+ void addOffset(int offset)
+ {
+ m_offset += offset;
+ }
+
+ // Serialization
+ public v3s16 v3s16()
+ throws PacketException
+ {
+ return Serialize.readV3S16(m_buffer, m_offset, m_length);
+ }
+
+ public ByteBuffer getByteBuffer()
+ {
+ ByteBuffer buffer = ByteBuffer.wrap(m_buffer,m_offset,m_length-m_offset);
+ return buffer;
+ }
+}
diff --git a/java/org/artisanlogiciel/games/minetest/net/PacketHandler.java b/java/org/artisanlogiciel/games/minetest/net/PacketHandler.java
new file mode 100644
index 0000000..ddf815d
--- /dev/null
+++ b/java/org/artisanlogiciel/games/minetest/net/PacketHandler.java
@@ -0,0 +1,287 @@
+package org.artisanlogiciel.games.minetest.net;
+import com.github.luben.zstd.Zstd;
+import org.artisanlogiciel.games.minetest.MapBlock;
+import org.artisanlogiciel.games.minetest.MapNode;
+import org.artisanlogiciel.games.minetest.core.PacketException;
+import org.artisanlogiciel.games.minetest.core.Serialize;
+import org.artisanlogiciel.games.minetest.core.v2s16;
+import org.artisanlogiciel.games.minetest.core.v3s16;
+
+import java.nio.ByteBuffer;
+
+/**
+ * see src/network/networkprotocol.h of minetest sources
+ *
+ *
+ * === NOTES ===
+ *
+ * A packet is sent through a channel to a peer with a basic header:
+ * Header (7 bytes):
+ * [0] u32 protocol_id
+ * [4] session_t sender_peer_id
+ * [6] u8 channel
+ * sender_peer_id:
+ * Unique to each peer.
+ * value 0 (PEER_ID_INEXISTENT) is reserved for making new connections
+ * value 1 (PEER_ID_SERVER) is reserved for server
+ * these constants are defined in constants.h
+ * channel:
+ * Channel numbers have no intrinsic meaning. Currently only 0, 1, 2 exist.
+ *
+ *
+ * */
+
+public class PacketHandler {
+
+ ReliablePacketBuffer reliableBuffer = null;
+
+ IncomingSplitBuffer[] incomingChanneleSplitBuffer = new IncomingSplitBuffer[4];
+
+ // server serialization in hello version
+ int ser_version;
+
+ // minetest protocol should be 0x4f457403
+ static int readProtocolId(byte[] buffer, int length)
+ throws PacketException
+ {
+ return Serialize.readU32(buffer, 0, length);
+ }
+
+ static int readPeerId(byte[] buffer, int length)
+ throws PacketException
+ {
+ return Serialize.readU16(buffer,4,length);
+ }
+
+ static int readChannel(byte[] buffer, int length)
+ throws PacketException
+ {
+ return Serialize.readU8(buffer, 6, length);
+ }
+
+ NetworkPacket handleAny(byte[] buffer, int length)
+ throws PacketException
+ {
+ int protocol_id = readProtocolId(buffer, length);
+ int peer_id = readPeerId(buffer, length);
+ int channel = readChannel(buffer, length);
+ int type = Serialize.readU8(buffer,7,length);
+ PacketType packetType = PacketType.getPacketType(type);
+
+ NetworkPacket networkPacket = new NetworkPacket(protocol_id,peer_id,channel,packetType, buffer, length);
+
+ // offset of packet within buffer.
+ networkPacket.addOffset(BufferedPacket.BASE_HEADER_SIZE);
+
+ System.out.println("length " + length + " protocol_id " + String.format("%x", protocol_id) + " peer_id " + peer_id + " channel " + channel + " type " + packetType);
+
+ return networkPacket;
+ }
+
+ void handlePacketType_Control(NetworkPacket networkPacket)
+ throws PacketException {
+ }
+
+ void handlePacketType_Reliable(NetworkPacket networkPacket)
+ throws PacketException
+ {
+ // TODO handle misordered...
+ /*
+ if ( reliableBuffer == null )
+ {
+ reliableBuffer = new ReliablePacketBuffer();
+ }
+
+ BufferedPacket packet = new BufferedPacket(buffer);
+ int nextExpected = 0;
+ reliableBuffer.insert(packet, nextExpected);
+ */
+
+ // handle nested packet
+ networkPacket.addOffset(3);
+ int offset = networkPacket.getOffset();
+ byte buffer[] = networkPacket.getBuffer();
+ int length = networkPacket.getLength();
+
+ PacketType packetType = PacketType.getPacketType(Serialize.readU8(buffer,offset,length));
+
+ System.out.println( "reliable " + packetType.toString());
+
+ switch (packetType)
+ {
+ case PACKET_TYPE_CONTROL:
+ //
+ handlePacketType_Control(networkPacket);
+ break;
+ case PACKET_TYPE_ORIGINAL:
+ handlePacketType_Original(networkPacket);
+ break;
+ case PACKET_TYPE_SPLIT:
+ handlePacketType_Split(networkPacket);
+ break;
+ case PACKET_TYPE_RELIABLE:
+ // this is an error, no nested reliable accepted.
+ throw new PacketException("nested reliable");
+ default: // error
+ throw new PacketException("unknown type");
+ }
+
+ }
+
+ void handleCommand_Hello(NetworkPacket networkPacket)
+ throws PacketException {
+
+ // u8 deployed serialisation version
+ ByteBuffer buffer = networkPacket.getByteBuffer();
+ int ser_ver = Serialize.readU8(buffer);
+ ser_version = ser_ver;
+ // u16 deployed network compression mode
+ int net_compress = Serialize.readU16(buffer);
+ // u16 deployed protocol version
+ int deployed = Serialize.readU16(buffer);
+ System.out.println(String.format("HELLO ser_ver=%d net_compress %d deployed %d", ser_ver,net_compress,deployed));
+ // u32 supported auth methods
+ // std::string username that should be used for legacy hash (for proper casing)
+
+ }
+
+ // clientpackethandler.cpp Client::handleCommand_BlockData(NetworkPacket* pkt)
+ // TOCLIENT_BLOCKDATA
+ void handleCommand_BlockData(NetworkPacket networkPacket)
+ throws PacketException
+ {
+ v3s16 p = networkPacket.v3s16();
+
+ // will be used to get vector...
+ // v2s16 p2d = new v2s16(p.X,p.Z);
+
+ System.out.println(String.format(" (X,Y,Z) %d %d %d", p.X, p.Y,p.Z));
+ //
+ networkPacket.addOffset(6);
+
+ // FIXME get it from handshake
+ int version = 28;
+
+ // Should be a MapBlock
+ MapBlock block = new MapBlock();
+ block.deSerialize(networkPacket.getByteBuffer(),version);
+
+ // now we have a block ! what to do with it ?
+ }
+
+ void handlePacketCommand(NetworkPacket networkPacket)
+ throws PacketException {
+
+ // consume type and ??? well ... 2
+ int command = Serialize.readU16(networkPacket.getBuffer(),networkPacket.getOffset(),networkPacket.getLength());
+
+ System.out.println(String.format("command %x length %d", command, networkPacket.getLength()));
+
+ networkPacket.addOffset(2);
+ // Original ... toClient - toServer
+ switch (command)
+ {
+ case 0x02:
+ {
+ System.out.println("TOCLIENT_HELLO");
+ handleCommand_Hello(networkPacket);
+ }
+ break;
+ case 0x20:
+ {
+ System.out.println("TOCLIENT_BLOCKDATA");
+ handleCommand_BlockData(networkPacket);
+ }
+ break;
+ case 0x4f:
+ {
+ //TOCLIENT_SET_SKY = 0x4f,
+ System.out.println("TOCLIENT_SET_SKY");
+ }
+ break;
+ }
+
+ }
+
+ void handlePacketType_Original(NetworkPacket networkPacket)
+ throws PacketException {
+
+ // eat original type 1.
+ networkPacket.addOffset(1);
+ handlePacketCommand(networkPacket);
+ }
+
+ void handlePacketType_Split(NetworkPacket networkPacket)
+ throws PacketException {
+
+ int channel = networkPacket.getChannel();
+ if ( channel < incomingChanneleSplitBuffer.length) {
+ IncomingSplitBuffer splitBuffer = incomingChanneleSplitBuffer[channel];
+ if ( splitBuffer == null )
+ {
+ splitBuffer = new IncomingSplitBuffer();
+ incomingChanneleSplitBuffer[channel] = splitBuffer;
+ }
+ if ( splitBuffer != null ) {
+ BufferedPacket bufferedPacket = splitBuffer.insert(networkPacket);
+ if ( bufferedPacket != null ) {
+ // well should handle it.
+ System.out.println("Reassembled packet size " + bufferedPacket.m_data.length);
+ // reset it.
+ incomingChanneleSplitBuffer[channel] = new IncomingSplitBuffer();
+ handleBufferedPacket(bufferedPacket);
+ }
+ }
+ }
+ else {
+ throw new PacketException("invalid channel " + channel);
+ }
+
+
+ }
+
+ void handleBufferedPacket(BufferedPacket bufferedPacket)
+ throws PacketException
+ {
+ // FIXME, why a BufferedPacket anyway since we finaly need a NetworkPacket ?
+ NetworkPacket networkPacket = new NetworkPacket(0,0,0, PacketType.PACKET_TYPE_ORIGINAL,bufferedPacket.m_data, bufferedPacket.size());
+ networkPacket.addOffset(BufferedPacket.BASE_HEADER_SIZE);
+ handlePacketCommand(networkPacket);
+ }
+
+ void fromServer(byte[] buffer, int length)
+ throws PacketException
+ {
+ System.out.print(" <- ");
+ NetworkPacket networkPacket = handleAny(buffer,length);
+
+ switch (networkPacket.packetType)
+ {
+ case PACKET_TYPE_CONTROL:
+ //
+ handlePacketType_Control(networkPacket);
+ break;
+ case PACKET_TYPE_RELIABLE:
+ //
+ handlePacketType_Reliable(networkPacket);
+ break;
+ case PACKET_TYPE_ORIGINAL:
+ handlePacketType_Original(networkPacket);
+ break;
+ case PACKET_TYPE_SPLIT:
+ handlePacketType_Split(networkPacket);
+ break;
+ default: // error
+ throw new PacketException("unknown type");
+ }
+
+ }
+
+ void fromClient(byte[] buffer, int length)
+ throws PacketException
+ {
+ System.out.print(" -> ");
+ handleAny(buffer,length);
+ }
+
+}
diff --git a/java/org/artisanlogiciel/games/minetest/net/PacketType.java b/java/org/artisanlogiciel/games/minetest/net/PacketType.java
new file mode 100644
index 0000000..6286991
--- /dev/null
+++ b/java/org/artisanlogiciel/games/minetest/net/PacketType.java
@@ -0,0 +1,27 @@
+package org.artisanlogiciel.games.minetest.net;
+
+public enum PacketType {
+ PACKET_TYPE_CONTROL,
+ PACKET_TYPE_ORIGINAL,
+ PACKET_TYPE_SPLIT,
+ PACKET_TYPE_RELIABLE,
+ PACKET_TYPE_ERROR;
+
+ static PacketType getPacketType(int value)
+ {
+ switch (value)
+ {
+ case 0:
+ return PACKET_TYPE_CONTROL;
+ case 1:
+ return PACKET_TYPE_ORIGINAL;
+ case 2:
+ return PACKET_TYPE_SPLIT;
+ case 3:
+ return PACKET_TYPE_RELIABLE;
+ default:
+ return PACKET_TYPE_ERROR;
+ }
+ }
+
+}
diff --git a/java/org/artisanlogiciel/games/minetest/net/ReliablePacketBuffer.java b/java/org/artisanlogiciel/games/minetest/net/ReliablePacketBuffer.java
new file mode 100644
index 0000000..fe939da
--- /dev/null
+++ b/java/org/artisanlogiciel/games/minetest/net/ReliablePacketBuffer.java
@@ -0,0 +1,20 @@
+package org.artisanlogiciel.games.minetest.net;
+
+import org.artisanlogiciel.games.minetest.core.PacketException;
+
+import java.util.LinkedList;
+import java.util.List;
+
+public class ReliablePacketBuffer {
+
+ List m_list = new LinkedList<>();
+
+ void insert(BufferedPacket packet, int nextExpected)
+ throws PacketException
+ {
+ //
+ int seqNum = packet.getSeqNum();
+ m_list.add(packet);
+ }
+
+}
diff --git a/project_params b/project_params
index 8041926..9f9f00e 100644
--- a/project_params
+++ b/project_params
@@ -3,5 +3,5 @@ project_default=dist
project_basedir=$(pwd)
project_mainpackage=org.artisanlogiciel.games
project_mainclass=$project_mainpackage.maze.gui.Display
-project_version=1.1
+project_version=1.2
default_args='lab/lab30x30.raw'