Connection to the server

In order to connect to the server, you need to:

1. Download and install Lasertag Operator (LTO) app from Play Market.

2. If the app is already installed on your device, update it.

3. Connect to a local network (LASERTAG, LASERTAG.NET, etc.) on your device. It will be displayed as a connection without internet.

   

4. Open the LTO application and from the “Lobby” menu go to the “Tools” menu.

5. From the “Tools” menu, go to the “API” setting - it will be displayed at the top of the list.

   

6. In the “API” menu, activate Automatic Start and Logging by sliding the switches, then click on the “Start server” button.

   

7. Return to the “Lobby” menu and make sure the server is connected (icon is green). If the icon is red, restart the server in the API menu.

   

8. If necessary, apply settings and connect the kits into the game.

LTO Api

Socket settings

LTO Api uses WebSocket to exchange data between the client and the server.

Attention

Do not use Windows hot-spot to connect between the client and server, as it may block broadcast messages.
The functionality is intended for work in a local network: Client < -- > Router < -- > Server.

Server URL

ws://< server ip address >:8080/lto

Instead of < server ip address > insert the IP address of the server (the device on which the Lasertag operator application is running).

Server auto discovery

To receive the IP address of a server, you can use server autodetection by sending a broadcast message.
Parameters for server autodetection:
Request tag - 0xc94222115fc942d3 (apply reverse to Request);
Response tag - 0xade7e97f3f51477b (apply reverse to Response);
Port – 4000.

After receiving a response from the server, subtract the first 8 bytes and compare them to the Response tag. After that you can get the IP address of the server and open the socket for operation.

Example of auto discovery server kotlin code:

val REQUEST_TAG =
ByteBuffer.allocate(8).putLong(Long.reverseBytes(0xC94222115FC942D3u.toLong())).array()
val RESPONSE_TAG =
ByteBuffer.allocate(8).putLong(Long.reverseBytes(0xADE7E97F3F51477Bu.toLong())).array()
val PORT = 4000
val BROADCAST_ADDR ="255.255.255.255"

// socket sending to the server

val socket = DatagramSocket()
socket.broadcast = true

val sendPacket = DatagramPacket(REQUEST_TAG, sendData.size, 
InetAddress.getByName(BROADCAST_ADDR), PORT) 
socket.send(sendPacket)

// reply from the server and get ip address

val recvData = ByteArray(128)
val recvPacket = DatagramPacket(recvData, recvData.size)
socket.receive(recvPacket)

val responceTag = responseData.sliceArray(0 until 8)

if (responceTag.contentEquals(RESPONSE_TAG))
val serverIp = recvPacket.address.hostAddress

Example of auto discovery server js code:

const dgram = require('dgram');
      const socket = dgram.createSocket('udp4');
      
      const BROADCAST_ADDR = '255.255.255.255';
      const PORT = 4000;
      
      const REQUEST_TAG = new Uint8Array([0xC9, 0x42, 0x22, 0x11, 0x5F, 0xC9, 0x42, 0xD3]).reverse();
      const RESPONSE_TAG = new Uint8Array([0xAD, 0xE7, 0xE9, 0x7F, 0x3F, 0x51, 0x47, 0x7B]).reverse();
      
      async function sendBroadcast() {
        return new Promise((resolve, reject) => {
          socket.bind(() => {
            socket.setBroadcast(true);
      
            socket.send(REQUEST_TAG, 0, REQUEST_TAG.length, PORT, BROADCAST_ADDR, (err) => {
              if (err) {
                reject('Error sending broadcast message: ' + err);
              } else {
                console.log('Broadcast message sent');
              }
            });
 // Listen for responses

socket.on('message', (msg, rinfo) => {
              const response = msg.subarray(0, RESPONSE_TAG.length);
              if (response.equals(RESPONSE_TAG)) {
                const ws = new WebSocket(`ws://${response}:8080/lto`);
      

 // Add work with socket

        }
            });
          });
        });
      }

Protocol message structure

Protocol message headers

  content-version : 1.0.0 
  message-format : message_type:{payload}
  message-type : string 
  payload-type : json
                

First type of message with payload

  Structure:
  message_type:{payload}
  
  Example:
  StartGameType:{
  "game Time": 1730308650362
  }
  
  Explanation:
  message_type - StartGameType
  payload - {
  "gameTime": 1730308650362
  }
                

Second type of message without payload

  Structure:
  message_type
  
  Example:
  PauseGameType
  
  Explanation:
  message_type - PauseGameType
                

The message consists of two parts: message_type and payload.
If the messages do not contain payload, only the message_type needs to be sent.
A list of all possible message_type is presented in the table below.