You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
400 lines
12 KiB
400 lines
12 KiB
namespace Oculus.Platform.Samples.VrBoardGame
|
|
{
|
|
using UnityEngine;
|
|
using Oculus.Platform;
|
|
using Oculus.Platform.Models;
|
|
using UnityEngine.UI;
|
|
using System.Collections.Generic;
|
|
using System;
|
|
using UnityEngine.Assertions;
|
|
|
|
// This classes uses the Oculus Matchmaking Service to find opponents of a similar
|
|
// skill and play a match with them. A skill pool is used with the matchmaking pool
|
|
// to coordinate the skill matching. Follow the instructions in the Readme to setup
|
|
// the matchmaking pools.
|
|
// The Datastore for the Room is used to communicate between the clients. This only
|
|
// works for relatively simple games with tolerance for latency. For more complex
|
|
// or realtime requirements, you'll want to use the Oculus.Platform.Net API.
|
|
public class MatchmakingManager : MonoBehaviour
|
|
{
|
|
// GameController to notify about match completions or early endings
|
|
[SerializeField] private GameController m_gameController = null;
|
|
|
|
// Text for the button that controls matchmaking
|
|
[SerializeField] private Text m_matchButtonText = null;
|
|
|
|
// Test widget to render matmaking statistics
|
|
[SerializeField] private Text m_infoText = null;
|
|
|
|
// name of the Quckmatch Pool configured on the Oculus Developer Dashboard
|
|
// which is expected to have an associated skill pool
|
|
private const string POOL = "VR_BOARD_GAME_POOL";
|
|
|
|
// the ID of the room for the current match
|
|
private ulong m_matchRoom;
|
|
|
|
// opponent User data
|
|
private User m_remotePlayer;
|
|
|
|
// last time we've received a room update
|
|
private float m_lastUpdateTime;
|
|
|
|
// how long to wait before polling for updates
|
|
private const float POLL_FREQUENCY = 30.0f;
|
|
|
|
private enum MatchRoomState { None, Queued, Configuring, MyTurn, RemoteTurn }
|
|
|
|
private MatchRoomState m_state;
|
|
|
|
void Start()
|
|
{
|
|
Matchmaking.SetMatchFoundNotificationCallback(MatchFoundCallback);
|
|
Rooms.SetUpdateNotificationCallback(MatchmakingRoomUpdateCallback);
|
|
|
|
TransitionToState(MatchRoomState.None);
|
|
}
|
|
|
|
void Update()
|
|
{
|
|
switch (m_state)
|
|
{
|
|
case MatchRoomState.Configuring:
|
|
case MatchRoomState.MyTurn:
|
|
case MatchRoomState.RemoteTurn:
|
|
// if we're expecting an update form the remote player and we haven't
|
|
// heard from them in a while, check the datastore just-in-case
|
|
if (POLL_FREQUENCY < (Time.time - m_lastUpdateTime))
|
|
{
|
|
Debug.Log("Polling Room");
|
|
m_lastUpdateTime = Time.time;
|
|
Rooms.Get(m_matchRoom).OnComplete(MatchmakingRoomUpdateCallback);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
public void MatchButtonPressed()
|
|
{
|
|
switch (m_state)
|
|
{
|
|
case MatchRoomState.None:
|
|
TransitionToState(MatchRoomState.Queued);
|
|
break;
|
|
|
|
default:
|
|
TransitionToState(MatchRoomState.None);
|
|
break;
|
|
}
|
|
}
|
|
|
|
public void EndMatch(int localScore, int remoteScore)
|
|
{
|
|
switch (m_state)
|
|
{
|
|
case MatchRoomState.MyTurn:
|
|
case MatchRoomState.RemoteTurn:
|
|
var myID = PlatformManager.MyID.ToString();
|
|
var remoteID = m_remotePlayer.ID.ToString();
|
|
var rankings = new Dictionary<string, int>();
|
|
if (localScore > remoteScore)
|
|
{
|
|
rankings[myID] = 1;
|
|
rankings[remoteID] = 2;
|
|
}
|
|
else if (localScore < remoteScore)
|
|
{
|
|
rankings[myID] = 2;
|
|
rankings[remoteID] = 1;
|
|
}
|
|
else
|
|
{
|
|
rankings[myID] = 1;
|
|
rankings[remoteID] = 1;
|
|
}
|
|
|
|
// since there is no secure server to simulate the game and report
|
|
// verifiable results, each client needs to independently report their
|
|
// results for the service to compate for inconsistencies
|
|
Matchmaking.ReportResultsInsecure(m_matchRoom, rankings)
|
|
.OnComplete(GenericErrorCheckCallback);
|
|
break;
|
|
}
|
|
|
|
TransitionToState(MatchRoomState.None);
|
|
}
|
|
|
|
void OnApplicationQuit()
|
|
{
|
|
// be a good matchmaking citizen and leave any queue immediately
|
|
Matchmaking.Cancel();
|
|
if (m_matchRoom != 0)
|
|
{
|
|
Rooms.Leave(m_matchRoom);
|
|
}
|
|
}
|
|
|
|
private void TransitionToState(MatchRoomState state)
|
|
{
|
|
var m_oldState = m_state;
|
|
m_state = state;
|
|
|
|
switch (m_state)
|
|
{
|
|
case MatchRoomState.None:
|
|
m_matchButtonText.text = "Find Match";
|
|
// the player can abort from any of the other states to the None state
|
|
// so we need to be careful to clean up all state variables
|
|
m_remotePlayer = null;
|
|
Matchmaking.Cancel();
|
|
if (m_matchRoom != 0)
|
|
{
|
|
Rooms.Leave(m_matchRoom);
|
|
m_matchRoom = 0;
|
|
}
|
|
break;
|
|
|
|
case MatchRoomState.Queued:
|
|
Assert.AreEqual(MatchRoomState.None, m_oldState);
|
|
m_matchButtonText.text = "Leave Queue";
|
|
Matchmaking.Enqueue2(POOL).OnComplete(MatchmakingEnqueueCallback);
|
|
break;
|
|
|
|
case MatchRoomState.Configuring:
|
|
Assert.AreEqual(MatchRoomState.Queued, m_oldState);
|
|
m_matchButtonText.text = "Cancel Match";
|
|
break;
|
|
|
|
case MatchRoomState.MyTurn:
|
|
case MatchRoomState.RemoteTurn:
|
|
Assert.AreNotEqual(MatchRoomState.None, m_oldState);
|
|
Assert.AreNotEqual(MatchRoomState.Queued, m_oldState);
|
|
m_matchButtonText.text = "Cancel Match";
|
|
break;
|
|
}
|
|
}
|
|
|
|
void MatchmakingEnqueueCallback(Message untyped_msg)
|
|
{
|
|
if (untyped_msg.IsError)
|
|
{
|
|
Debug.Log(untyped_msg.GetError().Message);
|
|
TransitionToState(MatchRoomState.None);
|
|
return;
|
|
}
|
|
|
|
Message<MatchmakingEnqueueResult> msg = (Message<MatchmakingEnqueueResult>)untyped_msg;
|
|
MatchmakingEnqueueResult info = msg.Data;
|
|
m_infoText.text = string.Format(
|
|
"Avg Wait Time: {0}s\n" +
|
|
"Max Expected Wait: {1}s\n" +
|
|
"In Last Hour: {2}\n" +
|
|
"Recent Percentage: {3}%",
|
|
info.AverageWait, info.MaxExpectedWait, info.MatchesInLastHourCount,
|
|
info.RecentMatchPercentage);
|
|
}
|
|
|
|
void MatchFoundCallback(Message<Room> msg)
|
|
{
|
|
if (msg.IsError)
|
|
{
|
|
Debug.Log(msg.GetError().Message);
|
|
TransitionToState(MatchRoomState.None);
|
|
return;
|
|
}
|
|
|
|
if (m_state != MatchRoomState.Queued)
|
|
{
|
|
// ignore callback - user already cancelled
|
|
return;
|
|
}
|
|
|
|
// since this example communicates via updates to the datastore, it's vital that
|
|
// we subscribe to room updates
|
|
Matchmaking.JoinRoom(msg.Data.ID, true /* subscribe to update notifications */)
|
|
.OnComplete(MatchmakingJoinRoomCallback);
|
|
m_matchRoom = msg.Data.ID;
|
|
}
|
|
|
|
void MatchmakingJoinRoomCallback(Message<Room> msg)
|
|
{
|
|
if (msg.IsError)
|
|
{
|
|
Debug.Log(msg.GetError().Message);
|
|
TransitionToState(MatchRoomState.None);
|
|
return;
|
|
}
|
|
|
|
if (m_state != MatchRoomState.Queued)
|
|
{
|
|
// ignore callback - user already cancelled
|
|
return;
|
|
}
|
|
|
|
int numUsers = (msg.Data.UsersOptional != null) ? msg.Data.UsersOptional.Count : 0;
|
|
Debug.Log ("Match room joined: " + m_matchRoom + " count: " + numUsers);
|
|
|
|
TransitionToState(MatchRoomState.Configuring);
|
|
|
|
// only process the room data if the other user has already joined
|
|
if (msg.Data.UsersOptional != null && msg.Data.UsersOptional.Count == 2)
|
|
{
|
|
ProcessRoomData(msg.Data);
|
|
}
|
|
}
|
|
|
|
// Room Datastore updates are used to send moves between players. So if the MatchRoomState
|
|
// is RemoteTurn I'm looking for the other player's move in the Datastore. If the
|
|
// MatchRoomState is MyTurn I'm waiting for the room ownership to change so that
|
|
// I have authority to write to the datastore.
|
|
void MatchmakingRoomUpdateCallback(Message<Room> msg)
|
|
{
|
|
if (msg.IsError)
|
|
{
|
|
Debug.Log(msg.GetError().Message);
|
|
TransitionToState(MatchRoomState.None);
|
|
return;
|
|
}
|
|
|
|
string ownerOculusID = msg.Data.OwnerOptional != null ? msg.Data.OwnerOptional.OculusID : "";
|
|
int numUsers = (msg.Data.UsersOptional != null) ? msg.Data.UsersOptional.Count : 0;
|
|
|
|
Debug.LogFormat(
|
|
"Room Update {0}\n" +
|
|
" Owner {1}\n" +
|
|
" User Count {2}\n" +
|
|
" Datastore Count {3}\n",
|
|
msg.Data.ID, ownerOculusID, numUsers, msg.Data.DataStore.Count);
|
|
|
|
// check to make sure the room is valid as there are a few odd timing issues (for
|
|
// example when leaving a room) that can trigger an uninteresting update
|
|
if (msg.Data.ID != m_matchRoom)
|
|
{
|
|
Debug.Log("Unexpected room update from: " + msg.Data.ID);
|
|
return;
|
|
}
|
|
|
|
ProcessRoomData(msg.Data);
|
|
}
|
|
|
|
private void ProcessRoomData(Room room)
|
|
{
|
|
m_lastUpdateTime = Time.time;
|
|
|
|
if (m_state == MatchRoomState.Configuring)
|
|
{
|
|
// get the User info for the other player
|
|
if (room.UsersOptional != null)
|
|
{
|
|
foreach (var user in room.UsersOptional)
|
|
{
|
|
if (PlatformManager.MyID != user.ID)
|
|
{
|
|
Debug.Log("Found remote user: " + user.OculusID);
|
|
m_remotePlayer = user;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (m_remotePlayer == null)
|
|
return;
|
|
|
|
bool i_go_first = DoesLocalUserGoFirst();
|
|
TransitionToState(i_go_first ? MatchRoomState.MyTurn : MatchRoomState.RemoteTurn);
|
|
Matchmaking.StartMatch(m_matchRoom).OnComplete(GenericErrorCheckCallback);
|
|
m_gameController.StartOnlineMatch(m_remotePlayer.OculusID, i_go_first);
|
|
}
|
|
|
|
// if it's the remote player's turn, look for their move in the datastore
|
|
if (m_state == MatchRoomState.RemoteTurn &&
|
|
room.DataStore.ContainsKey(m_remotePlayer.OculusID) &&
|
|
room.DataStore[m_remotePlayer.OculusID] != "")
|
|
{
|
|
// process remote move
|
|
ProcessRemoteMove(room.DataStore[m_remotePlayer.OculusID]);
|
|
TransitionToState(MatchRoomState.MyTurn);
|
|
}
|
|
|
|
// If the room ownership transferred to me, we can mark the remote turn complete.
|
|
// We don't do this when the remote move comes in if we aren't yet the owner because
|
|
// the local user will not be able to write to the datastore if they aren't the
|
|
// owner of the room.
|
|
if (m_state == MatchRoomState.MyTurn && room.OwnerOptional != null && room.OwnerOptional.ID == PlatformManager.MyID)
|
|
{
|
|
m_gameController.MarkRemoteTurnComplete();
|
|
}
|
|
|
|
if (room.UsersOptional == null || (room.UsersOptional != null && room.UsersOptional.Count != 2))
|
|
{
|
|
Debug.Log("Other user quit the room");
|
|
m_gameController.RemoteMatchEnded();
|
|
}
|
|
}
|
|
|
|
private void ProcessRemoteMove(string moveString)
|
|
{
|
|
Debug.Log("Processing remote move string: " + moveString);
|
|
string[] tokens = moveString.Split(':');
|
|
|
|
GamePiece.Piece piece = (GamePiece.Piece)Enum.Parse(typeof(GamePiece.Piece), tokens[0]);
|
|
int x = Int32.Parse(tokens[1]);
|
|
int y = Int32.Parse(tokens[2]);
|
|
|
|
// swap the coordinates since each player assumes they are player 0
|
|
x = GameBoard.LENGTH_X-1 - x;
|
|
y = GameBoard.LENGTH_Y-1 - y;
|
|
|
|
m_gameController.MakeRemoteMove(piece, x, y);
|
|
}
|
|
|
|
public void SendLocalMove(GamePiece.Piece piece, int boardX, int boardY)
|
|
{
|
|
string moveString = string.Format("{0}:{1}:{2}", piece.ToString(), boardX, boardY);
|
|
Debug.Log("Sending move: " + moveString);
|
|
|
|
var dict = new Dictionary<string, string>();
|
|
dict[PlatformManager.MyOculusID] = moveString;
|
|
dict[m_remotePlayer.OculusID] = "";
|
|
|
|
Rooms.UpdateDataStore(m_matchRoom, dict).OnComplete(UpdateDataStoreCallback);
|
|
TransitionToState(MatchRoomState.RemoteTurn);
|
|
}
|
|
|
|
private void UpdateDataStoreCallback(Message<Room> msg)
|
|
{
|
|
if (m_state != MatchRoomState.RemoteTurn)
|
|
{
|
|
// ignore calback - user already quit the match
|
|
return;
|
|
}
|
|
|
|
// after I've updated the datastore with my move, change ownership so the other
|
|
// user can perform their move
|
|
Rooms.UpdateOwner(m_matchRoom, m_remotePlayer.ID);
|
|
}
|
|
|
|
// deterministic but somewhat random selection for who goes first
|
|
private bool DoesLocalUserGoFirst()
|
|
{
|
|
// if the room ID is even, the lower ID goes first
|
|
if (m_matchRoom % 2 == 0)
|
|
{
|
|
return PlatformManager.MyID < m_remotePlayer.ID;
|
|
}
|
|
// otherwise the higher ID goes first
|
|
{
|
|
return PlatformManager.MyID > m_remotePlayer.ID;
|
|
}
|
|
}
|
|
|
|
private void GenericErrorCheckCallback(Message msg)
|
|
{
|
|
if (msg.IsError)
|
|
{
|
|
Debug.Log(msg.GetError().Message);
|
|
TransitionToState(MatchRoomState.None);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|