415 lines
12 KiB
C#
415 lines
12 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using Firebase.Database;
|
|
using Firebase.Extensions;
|
|
using Newtonsoft.Json;
|
|
using Newtonsoft.Json.Linq;
|
|
using TMPro;
|
|
using UnityEngine;
|
|
using static UnityEditor.Experimental.AssetDatabaseExperimental.AssetDatabaseCounters;
|
|
|
|
/// <summary>
|
|
/// This is the game state manager on the phone side
|
|
/// </summary>
|
|
public class GameManager : MonoBehaviour
|
|
{
|
|
private List<Player> players = new();
|
|
public Player currentPlayer = null;
|
|
|
|
[Header("Other component")]
|
|
public float explanationTime = 4f;
|
|
private float currentExplanationTime = 0;
|
|
|
|
[Header("Home Connection Component")]
|
|
public TMP_InputField roomCodeField;
|
|
public TextMeshProUGUI roomError;
|
|
public TMP_InputField playerNameField;
|
|
public TextMeshProUGUI nameError;
|
|
public UnityEngine.UI.Button submitNewPlayer;
|
|
|
|
[Header("WaitingRoom Component")]
|
|
public TextMeshProUGUI listPlayersUI;
|
|
public GameObject submitStartGame;
|
|
|
|
[Header("Explanation Component")]
|
|
public TextMeshProUGUI counter;
|
|
|
|
[Header("Pages")]
|
|
public GameObject HomeConnection;
|
|
public GameObject WaitingRoom;
|
|
public GameObject BeforeStart;
|
|
public GameObject TakePicture;
|
|
public GameObject VotePicture;
|
|
public GameObject WaitingOtherPlayers;
|
|
public GameObject EndGame;
|
|
|
|
private DatabaseReference realtimeDB;
|
|
public Room myRoom;
|
|
private DatabaseReference myOnlineRoom;
|
|
private DateTime endOfExplanationDate = DateTime.MinValue;
|
|
|
|
private void Awake()
|
|
{
|
|
FirebaseInitializer.Instance.onFirebaseReady += Initialize;
|
|
}
|
|
|
|
private void Start()
|
|
{
|
|
currentExplanationTime = explanationTime;
|
|
HomeConnection.SetActive(true);
|
|
WaitingRoom.SetActive(false);
|
|
BeforeStart.SetActive(false);
|
|
TakePicture.SetActive(false);
|
|
VotePicture.SetActive(false);
|
|
WaitingOtherPlayers.SetActive(false);
|
|
EndGame.SetActive(false);
|
|
|
|
submitNewPlayer.interactable = false;
|
|
}
|
|
|
|
private void OnApplicationQuit()
|
|
{
|
|
myOnlineRoom.Child("players").Child(currentPlayer.id).RemoveValueAsync().ContinueWithOnMainThread(task =>
|
|
{
|
|
Debug.Log($"delete player {currentPlayer.name}");
|
|
if (myOnlineRoom != null)
|
|
{
|
|
myOnlineRoom.ValueChanged -= OnRoomUpdate;
|
|
}
|
|
});
|
|
}
|
|
|
|
private void Update()
|
|
{
|
|
if (myRoom.currentState == (int)GameState.Explanation && endOfExplanationDate != DateTime.MinValue )
|
|
{
|
|
TimeSpan duration = endOfExplanationDate - DateTime.Now;
|
|
counter.text = ((int)duration.TotalSeconds).ToString("D1");
|
|
|
|
if (duration.TotalMilliseconds <= 0)
|
|
{
|
|
Debug.Log("It's time to make proposition !");
|
|
endOfExplanationDate = DateTime.MinValue;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
private void Initialize()
|
|
{
|
|
FirebaseInitializer.Instance.onFirebaseReady -= Initialize;
|
|
realtimeDB = FirebaseDatabase.DefaultInstance.RootReference;
|
|
Debug.Log("Realtime DB initialized");
|
|
|
|
submitNewPlayer.interactable = true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Send your name and game room to the server
|
|
/// </summary>
|
|
public void PlayerValidateNameAndServerRoom(string _name, string _code)
|
|
{
|
|
nameError.gameObject.SetActive(false);
|
|
roomError.gameObject.SetActive(false);
|
|
|
|
if (string.IsNullOrEmpty(_name))
|
|
{
|
|
Debug.LogError("Player name is empty", this);
|
|
|
|
nameError.text = "You have to put a valid name";
|
|
nameError.gameObject.SetActive(true);
|
|
|
|
return;
|
|
}
|
|
|
|
if (string.IsNullOrEmpty(_code))
|
|
{
|
|
Debug.LogError("Room code is empty", this);
|
|
roomError.text = "You have to put a room code";
|
|
roomError.gameObject.SetActive(true);
|
|
|
|
return;
|
|
}
|
|
|
|
currentPlayer = new Player(_name);
|
|
|
|
//check if the room exists, if not display an error message
|
|
CheckIfRoomExists(_code, room =>
|
|
{
|
|
if (room == null)
|
|
{
|
|
Debug.LogError("The room doesn't exists");
|
|
roomError.text = "Error: the room doesn't exists";
|
|
roomError.gameObject.SetActive(true);
|
|
}
|
|
else
|
|
{
|
|
myOnlineRoom = realtimeDB.Child("rooms").Child(_code);
|
|
//subscribe to it
|
|
myOnlineRoom.ValueChanged += OnRoomUpdate;
|
|
//if room exists, join it
|
|
JoinRoom(() =>
|
|
{
|
|
myRoom.currentState = (int)GameState.WaitingForOtherPlayersToJoin;
|
|
players.Add(currentPlayer);
|
|
|
|
WaitingRoom.SetActive(true);
|
|
HomeConnection.SetActive(false);
|
|
|
|
List<Player> list = new List<Player>
|
|
{
|
|
currentPlayer
|
|
};
|
|
|
|
UpdateDisplayedListUser(list);
|
|
});
|
|
}
|
|
});
|
|
}
|
|
|
|
private void CheckIfRoomExists(string _roomCode, Action<Room> callback_Room)
|
|
{
|
|
realtimeDB.Child("rooms").Child(_roomCode).GetValueAsync().ContinueWithOnMainThread(task =>
|
|
{
|
|
if (task.IsFaulted)
|
|
{
|
|
Debug.LogException(task.Exception);
|
|
}
|
|
else if (task.IsCompleted)
|
|
{
|
|
DataSnapshot snapshot = task.Result;
|
|
if (snapshot == null)
|
|
{
|
|
callback_Room?.Invoke(null);
|
|
}
|
|
else
|
|
{
|
|
callback_Room?.Invoke(JsonUtility.FromJson<Room>(snapshot.GetRawJsonValue()));
|
|
}
|
|
}
|
|
});
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Add this player to the room
|
|
/// </summary>
|
|
private void JoinRoom(Action callback_OnRoomJoined)
|
|
{
|
|
string JSON = JsonUtility.ToJson(currentPlayer);
|
|
Debug.Log(JSON);
|
|
try
|
|
{
|
|
myOnlineRoom.Child("players").Child(currentPlayer.id).SetRawJsonValueAsync(JSON).ContinueWithOnMainThread(task =>
|
|
{
|
|
if (task.IsFaulted)
|
|
{
|
|
Debug.LogException(task.Exception);
|
|
}
|
|
else
|
|
{
|
|
Debug.Log($"{currentPlayer.name} has been added to the room", this);
|
|
callback_OnRoomJoined?.Invoke();
|
|
}
|
|
});
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Debug.LogException(ex);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Call this only by the first player
|
|
/// </summary>
|
|
public void StartGame()
|
|
{
|
|
// send Start Game
|
|
myRoom.setPlayersAreReady(1);
|
|
string JSON = JsonUtility.ToJson(myRoom);
|
|
Debug.Log(JSON);
|
|
try
|
|
{
|
|
sendCurrentState(GameState.Explanation, () =>
|
|
{
|
|
Debug.Log($"start the game", this);
|
|
myRoom.currentState = (int)GameState.Explanation;
|
|
WaitingRoom.SetActive(false);
|
|
BeforeStart.SetActive(true);
|
|
|
|
});
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Debug.LogException(ex);
|
|
}
|
|
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Dislay on the screen the current prompt ask to you and another player
|
|
/// Also show all the camera stuff
|
|
/// </summary>
|
|
/// <param name="_prompt">The prompt to display</param>
|
|
public void MakeAProposition(Prompt _prompt)
|
|
{
|
|
//currentState = GameState.MakeProposition;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Create a proposition from the picture taken and send it to server.
|
|
/// Then go to next proposition (if any) or the page "WaitingForOtherPlayers"
|
|
/// </summary>
|
|
public void SubmitProposition()
|
|
{
|
|
Proposition temp = new Proposition();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Display the voting page
|
|
/// </summary>
|
|
public void StartToVote()
|
|
{
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Choose one result and send it to the server
|
|
/// Then go to the next vote (if any) or to the page "WaitingForOtherPlayers"
|
|
/// </summary>
|
|
public void Vote()
|
|
{
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Display the UI of the end screen
|
|
/// </summary>
|
|
public void DisplayEndScreen()
|
|
{
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Automatically called when something change in your room
|
|
/// </summary>
|
|
private void OnRoomUpdate(object sender, ValueChangedEventArgs e)
|
|
{
|
|
Debug.Log("begin OnRoomUpdate");
|
|
try
|
|
{
|
|
if (e?.Snapshot?.GetRawJsonValue() != null)
|
|
{
|
|
string JSON = e.Snapshot.GetRawJsonValue();
|
|
Debug.Log($"your room has been updated :\n{JSON}");
|
|
myRoom = JsonConvert.DeserializeObject<Room>(e.Snapshot.GetRawJsonValue());
|
|
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Debug.LogException(ex);
|
|
}
|
|
if (myRoom == null)
|
|
{
|
|
Debug.Log("myroom is null");
|
|
return;
|
|
}
|
|
switch (myRoom.currentState)
|
|
{
|
|
case (int)GameState.WaitingForOtherPlayersToJoin:
|
|
{
|
|
Debug.Log("update player List");
|
|
Debug.Log(myRoom.GetPlayerList());
|
|
CheckIfIAmTheFirst(myRoom.GetPlayerList());
|
|
UpdateDisplayedListUser(myRoom.GetPlayerList());
|
|
break;
|
|
}
|
|
case (int)GameState.Explanation:
|
|
{
|
|
WaitingRoom.SetActive(false);
|
|
BeforeStart.SetActive(true);
|
|
endOfExplanationDate = DateTime.Now.AddSeconds(3);
|
|
|
|
break;
|
|
}
|
|
case (int)GameState.MakeProposition:
|
|
{
|
|
if (BeforeStart.activeInHierarchy)
|
|
{
|
|
BeforeStart.SetActive(false);
|
|
TakePicture.SetActive(true);
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
private void UpdateDisplayedListUser(List<Player> players)
|
|
{
|
|
listPlayersUI.text = string.Empty;
|
|
for (int i = 0; i < players.Count; i++)
|
|
{
|
|
listPlayersUI.text += "\n" + players[i].name;
|
|
}
|
|
}
|
|
|
|
private void CheckIfIAmTheFirst(List<Player> players)
|
|
{
|
|
bool isFirst = false;
|
|
if (players.Count > 1)
|
|
{
|
|
|
|
List<Player> sortedList = players.OrderBy(x => x.creationDate).ToList();
|
|
|
|
if (sortedList[0].id == currentPlayer.id)
|
|
{
|
|
isFirst = true;
|
|
}
|
|
}
|
|
|
|
if (isFirst)
|
|
{
|
|
submitStartGame.SetActive(true);
|
|
}
|
|
}
|
|
public void sendCurrentState(GameState state, Action callback_oncCurrentStateSent)
|
|
{
|
|
myOnlineRoom.Child("currentState").SetValueAsync((int)state).ContinueWithOnMainThread(task =>
|
|
{
|
|
if (task.IsFaulted)
|
|
{
|
|
Debug.LogException(task.Exception);
|
|
}
|
|
else
|
|
{
|
|
callback_oncCurrentStateSent?.Invoke();
|
|
}
|
|
}); ;
|
|
|
|
}
|
|
|
|
public void OnClickSubmitSignIn()
|
|
{
|
|
string playerName = playerNameField.text;
|
|
string roomCode = roomCodeField.text;
|
|
PlayerValidateNameAndServerRoom(playerName, roomCode);
|
|
}
|
|
}
|
|
|
|
public enum GameState
|
|
{
|
|
EnteringName = 0,
|
|
WaitingForOtherPlayersToJoin = 1,
|
|
Explanation = 2,
|
|
MakeProposition = 3,
|
|
PropositionsSent = 4,
|
|
MakeVote = 5,
|
|
VoteSent = 6,
|
|
Score = 7
|
|
}
|