Send Message to Game Server

Send messages directly to the game server using the standardmessagetogameserver method. This is ideal for server-side game logic, validation, database operations, and any processing that shouldn't be handled by client players.

Method Signature

MoitribeSDK(gameId, 'standardmessagetogameserver', params, callback)

Parameters

Parameter	Type	Required	Description
messageData	ArrayBuffer	Yes	Message content as binary data
isReliable	boolean	No	Whether message must be delivered reliably (default: true)

Examples

Submit Game Score to Server

Send game score to server for validation and leaderboard updates:

JavaScript

function submitScoreToServer(score, gameData) {
  const scoreSubmission = {
    type: 'scoreSubmission',
    score: score,
    gameMode: 'classic',
    completionTime: gameData.duration,
    accuracy: gameData.accuracy,
    powerUpsUsed: gameData.powerUpsUsed,
    timestamp: Date.now(),
    sessionToken: getSessionToken() // For anti-cheat validation
  };

  const encoder = new TextEncoder();
  const messageData = encoder.encode(JSON.stringify(scoreSubmission)).buffer;

  MoitribeSDK('my-game-id', 'standardmessagetogameserver', {
    messageData: messageData,
    isReliable: true  // Score submissions must be reliable
  }, (result) => {
    if (result.success) {
      console.log('Score submitted to server successfully');
      showScoreConfirmation(score);
    } else {
      console.error('Failed to submit score:', result.msg);
      showScoreSubmissionError('Unable to submit score. Please try again.');
    }
  });
}

// Usage
const gameData = {
  duration: 180000, // 3 minutes
  accuracy: 0.85,
  powerUpsUsed: ['speed', 'shield']
};
submitScoreToServer(15420, gameData);

TypeScript

import MoitribeSDK from '@veniso/moitribe-js';

interface ScoreSubmission {
  type: 'scoreSubmission';
  score: number;
  gameMode: string;
  completionTime: number;
  accuracy: number;
  powerUpsUsed: string[];
  timestamp: number;
  sessionToken: string;
}

function submitScoreToServer(score: number, gameData: {
  duration: number;
  accuracy: number;
  powerUpsUsed: string[];
}): void {
  const scoreSubmission: ScoreSubmission = {
    type: 'scoreSubmission',
    score: score,
    gameMode: 'classic',
    completionTime: gameData.duration,
    accuracy: gameData.accuracy,
    powerUpsUsed: gameData.powerUpsUsed,
    timestamp: Date.now(),
    sessionToken: getSessionToken() // For anti-cheat validation
  };

  const encoder = new TextEncoder();
  const messageData = encoder.encode(JSON.stringify(scoreSubmission)).buffer;

  MoitribeSDK('my-game-id', 'standardmessagetogameserver', {
    messageData: messageData,
    isReliable: true  // Score submissions must be reliable
  }, (result) => {
    if (result.success) {
      console.log('Score submitted to server successfully');
      showScoreConfirmation(score);
    } else {
      console.error('Failed to submit score:', result.msg);
      showScoreSubmissionError('Unable to submit score. Please try again.');
    }
  });
}

// Usage
const gameData = {
  duration: 180000, // 3 minutes
  accuracy: 0.85,
  powerUpsUsed: ['speed', 'shield']
};
submitScoreToServer(15420, gameData);

Request Server Validation

Ask server to validate game actions for anti-cheat:

JavaScript

function validateGameAction(action, data) {
  const validationRequest = {
    type: 'validationRequest',
    action: action,
    data: data,
    playerPosition: getCurrentPlayerPosition(),
    gameTimestamp: getGameTimestamp(),
    checksum: calculateChecksum(data),
    timestamp: Date.now()
  };

  const encoder = new TextEncoder();
  const messageData = encoder.encode(JSON.stringify(validationRequest)).buffer;

  MoitribeSDK('my-game-id', 'standardmessagetogameserver', {
    messageData: messageData,
    isReliable: true  // Validation must be reliable
  }, (result) => {
    if (result.success) {
      console.log('Action validated by server');
      proceedWithAction(action, data);
    } else {
      console.error('Action validation failed:', result.msg);
      rejectAction(action, 'Server validation failed');
    }
  });
}

// Example validations
validateGameAction('playerMove', { from: {x: 10, y: 20}, to: {x: 15, y: 25} });
validateGameAction('usePowerUp', { powerUp: 'teleport', target: {x: 100, y: 200} });
validateGameAction('attack', { target: 'player456', damage: 50, weapon: 'sword' });

TypeScript

import MoitribeSDK from '@veniso/moitribe-js';

interface ValidationRequest {
  type: 'validationRequest';
  action: string;
  data: any;
  playerPosition: { x: number; y: number };
  gameTimestamp: number;
  checksum: string;
  timestamp: number;
}

function validateGameAction(action: string, data: any): void {
  const validationRequest: ValidationRequest = {
    type: 'validationRequest',
    action: action,
    data: data,
    playerPosition: getCurrentPlayerPosition(),
    gameTimestamp: getGameTimestamp(),
    checksum: calculateChecksum(data),
    timestamp: Date.now()
  };

  const encoder = new TextEncoder();
  const messageData = encoder.encode(JSON.stringify(validationRequest)).buffer;

  MoitribeSDK('my-game-id', 'standardmessagetogameserver', {
    messageData: messageData,
    isReliable: true  // Validation must be reliable
  }, (result) => {
    if (result.success) {
      console.log('Action validated by server');
      proceedWithAction(action, data);
    } else {
      console.error('Action validation failed:', result.msg);
      rejectAction(action, 'Server validation failed');
    }
  });
}

// Example validations
validateGameAction('playerMove', { from: {x: 10, y: 20}, to: {x: 15, y: 25} });
validateGameAction('usePowerUp', { powerUp: 'teleport', target: {x: 100, y: 200} });
validateGameAction('attack', { target: 'player456', damage: 50, weapon: 'sword' });

Save Game Progress

Send game progress to server for persistent storage:

JavaScript

function saveGameProgress(progressData) {
  const saveRequest = {
    type: 'saveProgress',
    progress: progressData,
    level: progressData.currentLevel,
    experience: progressData.totalXP,
    achievements: progressData.unlockedAchievements,
    inventory: progressData.playerInventory,
    settings: progressData.gameSettings,
    timestamp: Date.now()
  };

  const encoder = new TextEncoder();
  const messageData = encoder.encode(JSON.stringify(saveRequest)).buffer;

  MoitribeSDK('my-game-id', 'standardmessagetogameserver', {
    messageData: messageData,
    isReliable: true  // Save data must be reliable
  }, (result) => {
    if (result.success) {
      console.log('Game progress saved successfully');
      showSaveConfirmation();
      updateLastSavedTime();
    } else {
      console.error('Failed to save progress:', result.msg);
      showSaveError('Unable to save game progress');
    }
  });
}

// Usage
const progress = {
  currentLevel: 15,
  totalXP: 15420,
  unlockedAchievements: ['firstWin', 'speedRunner', 'collector'],
  playerInventory: ['sword', 'shield', 'healthPotion'],
  gameSettings: { soundVolume: 0.8, graphicsQuality: 'high' }
};
saveGameProgress(progress);

TypeScript

import MoitribeSDK from '@veniso/moitribe-js';

interface SaveRequest {
  type: 'saveProgress';
  progress: any;
  level: number;
  experience: number;
  achievements: string[];
  inventory: string[];
  settings: any;
  timestamp: number;
}

function saveGameProgress(progressData: {
  currentLevel: number;
  totalXP: number;
  unlockedAchievements: string[];
  playerInventory: string[];
  gameSettings: any;
}): void {
  const saveRequest: SaveRequest = {
    type: 'saveProgress',
    progress: progressData,
    level: progressData.currentLevel,
    experience: progressData.totalXP,
    achievements: progressData.unlockedAchievements,
    inventory: progressData.playerInventory,
    settings: progressData.gameSettings,
    timestamp: Date.now()
  };

  const encoder = new TextEncoder();
  const messageData = encoder.encode(JSON.stringify(saveRequest)).buffer;

  MoitribeSDK('my-game-id', 'standardmessagetogameserver', {
    messageData: messageData,
    isReliable: true  // Save data must be reliable
  }, (result) => {
    if (result.success) {
      console.log('Game progress saved successfully');
      showSaveConfirmation();
      updateLastSavedTime();
    } else {
      console.error('Failed to save progress:', result.msg);
      showSaveError('Unable to save game progress');
    }
  });
}

// Usage
const progress = {
  currentLevel: 15,
  totalXP: 15420,
  unlockedAchievements: ['firstWin', 'speedRunner', 'collector'],
  playerInventory: ['sword', 'shield', 'healthPotion'],
  gameSettings: { soundVolume: 0.8, graphicsQuality: 'high' }
};
saveGameProgress(progress);

Request Server-Side Data

Request data from server that clients shouldn't have:

JavaScript

function requestServerData(dataType, parameters) {
  const dataRequest = {
    type: 'dataRequest',
    dataType: dataType,
    parameters: parameters,
    requestId: generateRequestId(),
    timestamp: Date.now()
  };

  const encoder = new TextEncoder();
  const messageData = encoder.encode(JSON.stringify(dataRequest)).buffer;

  MoitribeSDK('my-game-id', 'standardmessagetogameserver', {
    messageData: messageData,
    isReliable: true  // Data requests must be reliable
  }, (result) => {
    if (result.success) {
      console.log(`Server data received: ${dataType}`);
      handleServerResponse(result.requestId, result.data);
    } else {
      console.error('Failed to get server data:', result.msg);
      handleDataRequestError(dataType, result.msg);
    }
  });
}

// Example data requests
requestServerData('leaderboard', { timeRange: 'weekly', limit: 10 });
requestServerData('playerStats', { playerId: 'player123' });
requestServerData('tournamentInfo', { tournamentId: 'summer2024' });
requestServerData('dailyChallenge', { difficulty: 'hard' });

TypeScript

import MoitribeSDK from '@veniso/moitribe-js';

interface DataRequest {
  type: 'dataRequest';
  dataType: string;
  parameters: any;
  requestId: string;
  timestamp: number;
}

function requestServerData(dataType: string, parameters: any): void {
  const dataRequest: DataRequest = {
    type: 'dataRequest',
    dataType: dataType,
    parameters: parameters,
    requestId: generateRequestId(),
    timestamp: Date.now()
  };

  const encoder = new TextEncoder();
  const messageData = encoder.encode(JSON.stringify(dataRequest)).buffer;

  MoitribeSDK('my-game-id', 'standardmessagetogameserver', {
    messageData: messageData,
    isReliable: true  // Data requests must be reliable
  }, (result) => {
    if (result.success) {
      console.log(`Server data received: ${dataType}`);
      handleServerResponse(result.requestId, result.data);
    } else {
      console.error('Failed to get server data:', result.msg);
      handleDataRequestError(dataType, result.msg);
    }
  });
}

// Example data requests
requestServerData('leaderboard', { timeRange: 'weekly', limit: 10 });
requestServerData('playerStats', { playerId: 'player123' });
requestServerData('tournamentInfo', { tournamentId: 'summer2024' });
requestServerData('dailyChallenge', { difficulty: 'hard' });

Report Player Behavior

Send player behavior reports to server for moderation:

JavaScript

function reportPlayer(targetPlayerId, reason, evidence) {
  const reportData = {
    type: 'playerReport',
    reportedPlayer: targetPlayerId,
    reason: reason,
    evidence: evidence,
    gameSession: getCurrentGameSession(),
    timestamp: Date.now(),
    reporterId: getCurrentPlayerId()
  };

  const encoder = new TextEncoder();
  const messageData = encoder.encode(JSON.stringify(reportData)).buffer;

  MoitribeSDK('my-game-id', 'standardmessagetogameserver', {
    messageData: messageData,
    isReliable: true  // Reports must be reliable
  }, (result) => {
    if (result.success) {
      console.log('Player report submitted successfully');
      showReportConfirmation(targetPlayerId, reason);
    } else {
      console.error('Failed to submit report:', result.msg);
      showReportError('Unable to submit report. Please try again.');
    }
  });
}

// Usage
reportPlayer('player456', 'cheating', {
  description: 'Player moved impossibly fast',
  gameTime: '15:30',
  screenshot: 'base64image...'
});

TypeScript

import MoitribeSDK from '@veniso/moitribe-js';

interface PlayerReport {
  type: 'playerReport';
  reportedPlayer: string;
  reason: string;
  evidence: any;
  gameSession: string;
  timestamp: number;
  reporterId: string;
}

function reportPlayer(targetPlayerId: string, reason: string, evidence: any): void {
  const reportData: PlayerReport = {
    type: 'playerReport',
    reportedPlayer: targetPlayerId,
    reason: reason,
    evidence: evidence,
    gameSession: getCurrentGameSession(),
    timestamp: Date.now(),
    reporterId: getCurrentPlayerId()
  };

  const encoder = new TextEncoder();
  const messageData = encoder.encode(JSON.stringify(reportData)).buffer;

  MoitribeSDK('my-game-id', 'standardmessagetogameserver', {
    messageData: messageData,
    isReliable: true  // Reports must be reliable
  }, (result) => {
    if (result.success) {
      console.log('Player report submitted successfully');
      showReportConfirmation(targetPlayerId, reason);
    } else {
      console.error('Failed to submit report:', result.msg);
      showReportError('Unable to submit report. Please try again.');
    }
  });
}

// Usage
reportPlayer('player456', 'cheating', {
  description: 'Player moved impossibly fast',
  gameTime: '15:30',
  screenshot: 'base64image...'
});

Response Format

The callback receives a response object:

{
  success: boolean;
  data?: any;         // Response data from server
  requestId?: string; // For data requests
  msg?: string;        // Error message if failed
}

Message Data Format

ArrayBuffer Conversion

All messages must be sent as ArrayBuffer:

const encoder = new TextEncoder();
const messageData = encoder.encode(JSON.stringify(messageObject)).buffer;

Message Structure

Include a type field for server-side routing:

const message = {
  type: 'messageType',  // Required for server routing
  // ... other data
};

Server Communication Patterns

Request-Response Pattern

// Send request
const request = { type: 'dataRequest', dataType: 'leaderboard' };

// Handle response in callback
(result) => {
  if (result.success) {
    // Process server response data
    updateLeaderboard(result.data);
  }
}

Fire-and-Forget Pattern

// Send data without expecting immediate response
const notification = { type: 'analytics', event: 'gameCompleted' };

// Just check for delivery success
(result) => {
  if (result.success) {
    console.log('Analytics data sent');
  }
}

Error Handling

Common errors and solutions:

Error	Cause	Solution
Message is required	Empty message data	Ensure messageData is not null/undefined
Server unavailable	Server is down or overloaded	Implement retry logic with exponential backoff
Invalid message format	Malformed message data	Validate message structure before sending
Rate limit exceeded	Too many requests	Implement request throttling

warning

Server messages should be used for critical game logic, validation, and data persistence. Avoid sending frequent real-time data to the server as it can cause performance issues.

Best Practices

Message Security

• Include authentication tokens for sensitive operations
• Use checksums for data integrity verification
• Validate all data on the server side
• Never trust client-side data for critical game logic

Performance Optimization

• Batch multiple operations into single messages
• Use unreliable messages for non-critical analytics data
• Implement client-side caching for frequently requested data
• Compress large data payloads

Error Handling

• Always check callback results
• Implement retry logic for important operations
• Provide user feedback for server communication failures
• Gracefully handle server unavailability

Data Validation

• Validate message structure before sending
• Include request IDs for tracking responses
• Handle partial failures gracefully
• Log communication errors for debugging

Next Steps

• Receive Messages
• Handle Room Callbacks
• Leave a Room
• Understand Room Lifecycle