turn-based games without state synchronization

[meturgut]

Hello,

I plan to develop a 2-player competitive turn-based game using Colyseus, and I want to send all messages on the server side using room.broadcast() and receive them on the client side with room.onMessage().

1-Do I need to derive my message classes from the Schema class?
2-Is it necessary to set the state using the setState function when the room is created?

What would be the best approach to follow in general?

[endel]

Hi @meturgut, welcome 👋 Glad you're considering Colyseus for your next project!

1. There's no need to. The Schema classes are meant to be used for shared state only. All the messages use msgpack for encoding.
2. It's not required to use the room's state if you don't want to.

There are advantages to using the state, though. For example, when a client joins the room mid-game, it then receives the current data in the state. On version 0.15 the state is always shared between all clients, but 0.16-preview (not fully released yet) has a new thing called StateView, where you can made portions of the state visible to a particular client.

Kind regards

[meturgut]

Thank you for the answer and your nice welcome! @endel

Here is a Room example I wrote for testing purposes, and it works as expected. In this kind of usage, is there anything wrong, or would you suggest any improvements?

Best regards,

import { Room, Client, logger } from "@colyseus/core";
import { Opcode, FIRE_REQ_MESSAGE, FIRE_RES_MESSAGE, GENERATE_BOARD_MESSAGE, OPPONENT_FOUND_MESSAGE, PLAYER_LEFT_MESSAGE } from "@shared/opcodes";

const BOARD_WIDTH = 9;
const BOARD_HEIGHT = 7;


export class Player {
  id: string;
  board: number[] = [];
}

export class GameState {
  player1: Player;
  player2: Player;

  currentPlayerId: string;

}

export class PvPRoom extends Room {
  maxClients = 2;

  gameState: GameState;

  onCreate(options: any) {

    this.autoDispose = true;
    // this.setState(new GameState());
    logger.debug(`Room:${this.roomId} has created now!`);

    this.gameState = new GameState();


    this.onMessage(Opcode.FIRE_REQ, (client, message: FIRE_REQ_MESSAGE) => {
      this.fire(client.sessionId, message.x, message.y);
    });

  }

  onJoin(client: Client, options: any, auth: any) {
    logger.debug(`Client joined: ${client.sessionId}`);
    logger.debug(`Clients length: ${this.clients.length}`);
  }

  onLeave(client: Client, consented: boolean) {
    console.log(`Client left: ${client.sessionId} - consented:${consented}`);

    const playerLeftMes = new PLAYER_LEFT_MESSAGE();
    playerLeftMes.id = client.sessionId;
    this.broadcast(Opcode.PLAYER_LEFT, playerLeftMes);
    this.disconnect();
  }

  onDispose() {
    console.log(`Room is ${this.roomName}-${this.roomId} disposing`);

  }

  onUncaughtException(err: Error, methodName: string) {
    console.error("An error ocurred in", methodName, ":", err);
    err.cause // original unhandled error
    err.message // original error message
  }
  }