Online real-time turn-based multiplayer game genre involves two or more online players and the game play progressing in turns. The players are constantly engaged throughout the game session. Often each player is only given a limited amount of time (in seconds) to make their turns and such a ticker also adds to the excitement.Juegos multijugador por turnos en tiempo real online involucra dos o mas jugadores online y el juego proceso de juego por turnos. Los jugadores participan de manera constante durante la sesión de juego. Regularmente a cada jugador se le otorga una cantidad definida de tiempo (en segundos) para su turno, sumándole emoción al juego.

Es una alternativa a juegos por turnos asíncronos en los cuales los usuarios no necesitan estar conectados en línea juntos mientras el juego avanza en turnos. Los jugadores hacen sus movimientos en un tiempo conveniente para ellos y así los juegos pueden durar incluso por días. Estos juegos pueden ser creados usando App42 cloud APIs.

En la publicación describiremos como construir juegos online por turnos en tiempo real usando AppWarp Clouds turn based gaming APIs. Esto elimina el esfuerzo por parte del cliente requerido para:

• Distribución de la gestión del tiempo
• Distribución de la gestión de turno
• Distribución de la gestión de estado

Hemos extendido el juego de muestra de Microsoft Catapult Waren la plataforma de Windows para explicar cómo usar las APIs. Código de fuente completo también está disponible.

Proceso para la creación de una sala por turno en AppWarp

La manera en la que crea y se une a estas salas es la misma que a salas dinámicas la cual explicamos en publicaciones anteriores. La única diferencia es que hemos creado una sala por turnos, también suministramos “Turn Time” como un parámetro.

WarpClient.GetInstance().createTurnRoom("TurnBasedRoom", GlobalContext.localUsername, 2, GlobalContext.tableProperties,GlobalContext.turnTime);

Una vez ambos usuarios están dentro de la sala de juego, necesitamos empezar el juego.

public void onUserJoinedRoom(RoomData eventObj, String username)
{
    if (!GlobalContext.localUsername.Equals(username))
    {  
        GlobalContext.opponentName = username;
        GlobalContext.joinedUsers = new[] {GlobalContext.localUsername, GlobalContext.opponentName};
    }
    if (GlobalContext.joinedUsers.Length == 2)
    {
        WarpClient.GetInstance().startGame();
    }
}

Una vez el juego ha empezado, el jugador que tenga el turno, puede enviar su movimiento. La información es suministrada en los eventos de notificación que llegan desde el servidor de quien sea el turno. Enviar el movimiento es sencillo, use la API SendMove cuando el usuario dispare la catapulta cuando levante del dedo.

public void HandleInput(GestureSample gestureSample) {
        GlobalContext.fireNumber = Convert.ToInt32(GlobalContext.tableProperties["fireNumber"]);
        GlobalContext.fireNumber++;
        Dictionary<string, object> fireProperties = new Dictionary<string, object>();
        fireProperties.Add("fireNumber", GlobalContext.fireNumber);
        WarpClient.GetInstance().UpdateRoomProperties(GlobalContext.GameRoomId, fireProperties, null);
        WarpClient.GetInstance().sendMove(MoveMessage.buildSHOTMessageString(Catapult.ShotVelocity.ToString(), Catapult.ShotAngle.ToString()));
        GlobalContext.prevUDPPacketNumber = 0;
 }

Si un movimiento es enviado de manera exitosa, el evento de notificación onMoveCompleted se activará en ambos clientes. Esto contendrá moveData enviado en el movimiento y también el nombre del usuario quien tenga el turno.

public void onMoveCompleted(MoveEvent moveEvent) {
        if (moveEvent.getRoomId().Equals(GlobalContext.GameRoomId)) {
            if (moveEvent.getMoveData() != null) {
                MoveMessage.buildMessage(System.Text.Encoding.UTF8.GetBytes(moveEvent.getMoveData()));
            }
            if (moveEvent.getNextTurn().ToString().Equals(GlobalContext.localUsername)) {
                GlobalContext.IsMyTurn = true;
                if (RemoteUserPaused != null) {
                    Deployment.Current.Dispatcher.BeginInvoke(new UICallback(ChangeTurnCallback));
                }
            } else {
                GlobalContext.IsMyTurn = false;
                if (RemoteUserPaused != null) {
                    Deployment.Current.Dispatcher.BeginInvoke(new UICallback(ChangeTurnCallback));
                }
            }
        }
}

Si el usuario no envía un movimiento durante la ronda de tiempo (establecer mientras crea la sala) entonces este método será invocado pero moveEvent.getMoveData() volverá nulo. Sin embargo el turno se moverá al siguiente usuario.

Aunque el turno del usuario y el tiempo del jugador serán controlado por AppWarp Cloud Server para prevenir trampa y temporizadores que no estén sincronizados, podemos mostrar el tiempo restante del turno del usuario en la pantalla del juego usando nuestro temporizador para mantener al usuario comprometido e informado.

Código de fuente completo de un juego puede ser descargado o visto desde Git repo. Si usted tiene alguna pregunta o necesita asistencia adicional, Por favor contáctenos a support@shephertz.comen caso de alguna duda o sugerencia.

It’s an alternate to asynchronous turn based games in which both the users don’t need to be online together while the game play progresses in turns. The players make their moves at a time convenient to them and games can thus often even last for days. Such games can be easily built using App42 cloud APIs.

In this post we will describe how to build online real-time turn based game play using AppWarp cloud’s turn based gaming APIs. This eliminates the client-side effort required for the following:

• distributed timer management
• distributed turn management
• distributed state management

We have extended Microsoft’s sample game Catapult War on Windows phone platform to explain how to use the APIs. Complete source code is also available.

Process to create a turn based room in AppWarp

The way you create and join these rooms is the same as that for dynamic rooms which we explained in previous posts. The only difference is that when we create the turn based room, we also provide “Turn Time” as a parameter.

WarpClient.GetInstance().createTurnRoom("TurnBasedRoom", GlobalContext.localUsername, 2, GlobalContext.tableProperties,GlobalContext.turnTime);

Once both users are inside the game room, we need to start the game.

public void onUserJoinedRoom(RoomData eventObj, String username)
{
    if (!GlobalContext.localUsername.Equals(username))
    {  
        GlobalContext.opponentName = username;
        GlobalContext.joinedUsers = new[] {GlobalContext.localUsername, GlobalContext.opponentName};
    }
    if (GlobalContext.joinedUsers.Length == 2)
    {
        WarpClient.GetInstance().startGame();
    }
}

Once the game is started; the player, whose turn it is, can send his move. The information is provided in the notification events that come from the server about whose turn it is. Sending the move is easy – use the sendMove API when the user fires the catapult by releasing his finger.

public void HandleInput(GestureSample gestureSample) {
        GlobalContext.fireNumber = Convert.ToInt32(GlobalContext.tableProperties["fireNumber"]);
        GlobalContext.fireNumber++;
        Dictionary<string, object> fireProperties = new Dictionary<string, object>();
        fireProperties.Add("fireNumber", GlobalContext.fireNumber);
        WarpClient.GetInstance().UpdateRoomProperties(GlobalContext.GameRoomId, fireProperties, null);
        WarpClient.GetInstance().sendMove(MoveMessage.buildSHOTMessageString(Catapult.ShotVelocity.ToString(), Catapult.ShotAngle.ToString()));
        GlobalContext.prevUDPPacketNumber = 0;
 }

If a move is successfully submitted, the onMoveCompleted notification event will be fired on both the clients. This will contain the moveData sent in the move and also the name of the user whose turn it is now.

public void onMoveCompleted(MoveEvent moveEvent) {
        if (moveEvent.getRoomId().Equals(GlobalContext.GameRoomId)) {
            if (moveEvent.getMoveData() != null) {
                MoveMessage.buildMessage(System.Text.Encoding.UTF8.GetBytes(moveEvent.getMoveData()));
            }
            if (moveEvent.getNextTurn().ToString().Equals(GlobalContext.localUsername)) {
                GlobalContext.IsMyTurn = true;
                if (RemoteUserPaused != null) {
                    Deployment.Current.Dispatcher.BeginInvoke(new UICallback(ChangeTurnCallback));
                }
            } else {
                GlobalContext.IsMyTurn = false;
                if (RemoteUserPaused != null) {
                    Deployment.Current.Dispatcher.BeginInvoke(new UICallback(ChangeTurnCallback));
                }
            }
        }
}

If the user does not send move within the round time (set while creating the room) then also this method will be invoked but moveEvent.getMoveData() will return null. The turn will however move to the next user.

Although the user’s turn and game timer will be controlled by AppWarp cloud server to prevent cheating and out of sync timers, we can display the remaining turn time to user on game screen using our own timer to keep the user informed and engaged.

Complete source code of the game can be downloaded or viewed from our Git repo. If you have any questions or need any further assistance, please feel free to write us at support@shephertz.com.