1591 lines
45 KiB
C#
1591 lines
45 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Net.NetworkInformation;
|
|
using Firesplash.UnityAssets.SocketIO;
|
|
using HeathenEngineering.SteamApi.Foundation;
|
|
using I2.Loc;
|
|
using Newtonsoft.Json;
|
|
using Newtonsoft.Json.Linq;
|
|
using Steamworks;
|
|
using TMPro;
|
|
using UnityEngine;
|
|
using UnityEngine.Serialization;
|
|
|
|
public class ServerManager : MonoBehaviour
|
|
{
|
|
[Serializable]
|
|
public class PlayerData
|
|
{
|
|
public string PLAYER_ID;
|
|
|
|
public string COUNTRY;
|
|
|
|
public string PLAYER_NAME;
|
|
|
|
public string PLAYER_PROFILE_NAME;
|
|
|
|
public string GAME_VERSION;
|
|
|
|
public int PROFILE_INDEX;
|
|
|
|
public int PLAYER_LEVEL;
|
|
|
|
public float PLAYER_CASH;
|
|
|
|
public float TOTAL_FISH_WEIGHT;
|
|
|
|
public int TOTAL_FISH;
|
|
}
|
|
|
|
private class RankingFishData
|
|
{
|
|
public string PLAYER_ID;
|
|
|
|
public string PLAYER_NAME;
|
|
|
|
public int PROFILE_INDEX;
|
|
|
|
public int POINTS;
|
|
|
|
public int FISH_ID;
|
|
|
|
public float FISH_WEIGHT;
|
|
|
|
public string GAME_MODE;
|
|
|
|
public int MAP_ID;
|
|
}
|
|
|
|
private class GetRankingsData
|
|
{
|
|
public int from;
|
|
|
|
public int to;
|
|
|
|
public string GAME_MODE;
|
|
}
|
|
|
|
[Serializable]
|
|
public class RankingPlayersData
|
|
{
|
|
public string PLAYER_ID;
|
|
|
|
public string PLAYER_NAME;
|
|
|
|
public int PROFILE_INDEX;
|
|
|
|
public float TOTAL_FISH_WEIGHT;
|
|
|
|
public int BEST_FISH_ID;
|
|
|
|
public float BEST_FISH_WEIGHT;
|
|
|
|
public int TOTAL_FISH;
|
|
|
|
public int POINTS;
|
|
}
|
|
|
|
[Serializable]
|
|
private class RankingOwnData
|
|
{
|
|
public string PLAYER_ID;
|
|
|
|
public int PROFILE_INDEX;
|
|
|
|
public string GAME_MODE;
|
|
}
|
|
|
|
[Serializable]
|
|
public class GetRankingOwnData
|
|
{
|
|
public string PLAYER_ID;
|
|
|
|
public string PLAYER_NAME;
|
|
|
|
public int PROFILE_INDEX;
|
|
|
|
public float TOTAL_FISH_WEIGHT;
|
|
|
|
public int BEST_FISH_ID;
|
|
|
|
public float BEST_FISH_WEIGHT;
|
|
|
|
public int TOTAL_FISH;
|
|
|
|
public int POINTS;
|
|
|
|
public int POSITION;
|
|
}
|
|
|
|
[Serializable]
|
|
public class PlayerLocationData
|
|
{
|
|
public string PLAYER_ID;
|
|
|
|
public string COUNTRY;
|
|
|
|
public string PLAYER_NAME;
|
|
|
|
public string PLAYER_PROFILE_NAME;
|
|
|
|
public string GAME_VERSION;
|
|
|
|
public int PROFILE_INDEX;
|
|
|
|
public int PLAYER_LEVEL;
|
|
|
|
public float PLAYER_CASH;
|
|
|
|
public float TOTAL_FISH_WEIGHT;
|
|
|
|
public int TOTAL_FISH;
|
|
|
|
public int LOCATION_ID;
|
|
}
|
|
|
|
private class GetRankingsLocationData
|
|
{
|
|
public int from;
|
|
|
|
public int to;
|
|
|
|
public string GAME_MODE;
|
|
|
|
public int locationID;
|
|
}
|
|
|
|
[Serializable]
|
|
public class RankingPlayersLocationData
|
|
{
|
|
public string PLAYER_ID;
|
|
|
|
public string PLAYER_NAME;
|
|
|
|
public int PROFILE_INDEX;
|
|
|
|
public float TOTAL_FISH_WEIGHT;
|
|
|
|
public int BEST_FISH_ID;
|
|
|
|
public float BEST_FISH_WEIGHT;
|
|
|
|
public int TOTAL_FISH;
|
|
|
|
public int POINTS;
|
|
|
|
public int MAP_ID;
|
|
}
|
|
|
|
[Serializable]
|
|
private class RankingOwnLocationData
|
|
{
|
|
public string PLAYER_ID;
|
|
|
|
public int PROFILE_INDEX;
|
|
|
|
public string GAME_MODE;
|
|
|
|
public int locationID;
|
|
}
|
|
|
|
[Serializable]
|
|
public class GetRankingOwnLocationData
|
|
{
|
|
public string PLAYER_ID;
|
|
|
|
public string PLAYER_NAME;
|
|
|
|
public int PROFILE_INDEX;
|
|
|
|
public float TOTAL_FISH_WEIGHT;
|
|
|
|
public int BEST_FISH_ID;
|
|
|
|
public float BEST_FISH_WEIGHT;
|
|
|
|
public int TOTAL_FISH;
|
|
|
|
public int POINTS;
|
|
|
|
public int POSITION;
|
|
|
|
public int MAP_ID;
|
|
}
|
|
|
|
[Serializable]
|
|
private class RewardOwnData
|
|
{
|
|
public string PLAYER_ID;
|
|
|
|
public string PLAYER_NAME;
|
|
|
|
public int PROFILE_INDEX;
|
|
}
|
|
|
|
[Serializable]
|
|
public class GetRewardOwnData
|
|
{
|
|
public string REWARD_TYPE;
|
|
|
|
public string REWARD;
|
|
}
|
|
|
|
[Serializable]
|
|
public class PlayerChatData
|
|
{
|
|
public string PLAYER_ID;
|
|
|
|
public string PLAYER_NAME;
|
|
|
|
public string COUNTRY;
|
|
|
|
public string LOCATION_ID;
|
|
}
|
|
|
|
[Serializable]
|
|
public class GetPlayerChatRoomData
|
|
{
|
|
public string ID;
|
|
|
|
public string LOCATION_ID;
|
|
|
|
public string PLAYERS;
|
|
|
|
public int MAX_PLAYERS;
|
|
}
|
|
|
|
[Serializable]
|
|
public class ReconnectPlayerData
|
|
{
|
|
public string PLAYER_ID;
|
|
|
|
public string PLAYER_NAME;
|
|
|
|
public string COUNTRY;
|
|
|
|
public string ROOM_ID;
|
|
|
|
public string LOCATION_ID;
|
|
}
|
|
|
|
[Serializable]
|
|
public class Message
|
|
{
|
|
public string MESSAGE_TYPE;
|
|
|
|
public string PLAYER_ID;
|
|
|
|
public string PLAYER_NAME;
|
|
|
|
public string COUNTRY;
|
|
|
|
public string LOCATION_ID;
|
|
|
|
public string MESSAGE;
|
|
}
|
|
|
|
[Serializable]
|
|
public class FishMessage
|
|
{
|
|
public string PLAYER_ID;
|
|
|
|
public string PLAYER_NAME;
|
|
|
|
public int FISH_ID;
|
|
|
|
public float FISH_WEIGHT;
|
|
}
|
|
|
|
[Serializable]
|
|
private class TournamentData
|
|
{
|
|
public int ID;
|
|
|
|
public string NAME;
|
|
|
|
public string TYPE;
|
|
|
|
public string VISABLE_TYPE;
|
|
|
|
public string TASK;
|
|
|
|
public string METHOD;
|
|
|
|
public int MAP_ID;
|
|
|
|
public int DURATION;
|
|
|
|
public int PARTICIPANTS_MAX;
|
|
|
|
public int ENTRY_FEE;
|
|
|
|
public int LEVEL_MIN;
|
|
|
|
public int LEVEL_MAX;
|
|
|
|
public string CREATOR_PLAYER_ID;
|
|
|
|
public int CREATOR_PROFILE_INDEX;
|
|
|
|
public string CREATOR_PLAYER_NAME;
|
|
|
|
public long TIME_START;
|
|
|
|
public int TIME_TO_END_S;
|
|
|
|
public int TIME_CREATE_S;
|
|
}
|
|
|
|
[Serializable]
|
|
private class TournamentParticipantsData
|
|
{
|
|
public int ID;
|
|
|
|
public int TOURNAMENT_ID;
|
|
|
|
public string PLAYER_ID;
|
|
|
|
public string PLAYER_NAME;
|
|
|
|
public int PROFILE_INDEX;
|
|
|
|
public int PLAYER_LEVEL;
|
|
|
|
public int TOURNAMENTS_WON;
|
|
|
|
public int RANKING_POINTS;
|
|
|
|
public int BEST_FISH_ID;
|
|
|
|
public float VALUE;
|
|
|
|
public int JOINED_TIMELEFT;
|
|
|
|
public string STATUS;
|
|
}
|
|
|
|
[Serializable]
|
|
private class TournamentJoinData
|
|
{
|
|
public int TOURNAMENT_ID;
|
|
|
|
public int PARTICIPANTS_MAX;
|
|
|
|
public string PLAYER_ID;
|
|
|
|
public string PLAYER_NAME;
|
|
|
|
public int PROFILE_INDEX;
|
|
|
|
public int PLAYER_LEVEL;
|
|
|
|
public int TOURNAMENTS_WON;
|
|
|
|
public int RANKING_POINTS;
|
|
}
|
|
|
|
[Serializable]
|
|
private class TournamentJoinedIdsData
|
|
{
|
|
public int TOURNAMENT_ID;
|
|
}
|
|
|
|
[Serializable]
|
|
private class TournamentInvitesData
|
|
{
|
|
public int TOURNAMENT_ID;
|
|
|
|
public string TOURNAMENT_NAME;
|
|
|
|
public string PLAYER_ID;
|
|
|
|
public string SEND_PLAYER_NAME;
|
|
}
|
|
|
|
[Serializable]
|
|
private class TournamentCreatorData
|
|
{
|
|
public int ID;
|
|
|
|
public string NAME;
|
|
|
|
public string TYPE;
|
|
|
|
public string TYPE_PLAYER_TOURNAMENT;
|
|
|
|
public string TASK;
|
|
|
|
public string METHOD;
|
|
|
|
public int MAP_ID;
|
|
|
|
public int DURATION;
|
|
|
|
public int PARTICIPANTS_MAX;
|
|
|
|
public int ENTRY_FEE;
|
|
|
|
public int LEVEL_MIN;
|
|
|
|
public int LEVEL_MAX;
|
|
|
|
public string PLAYER_ID;
|
|
|
|
public string PLAYER_NAME;
|
|
|
|
public int PROFILE_INDEX;
|
|
|
|
public string INVITES;
|
|
}
|
|
|
|
[Serializable]
|
|
private class TournamentFishData
|
|
{
|
|
public int TOURNAMENT_ID;
|
|
|
|
public string PLAYER_ID;
|
|
|
|
public int PROFILE_INDEX;
|
|
|
|
public string TASK;
|
|
|
|
public int FISH_ID;
|
|
|
|
public float FISH_WEIGHT;
|
|
|
|
public int MAP_ID;
|
|
}
|
|
|
|
private enum APITestStage
|
|
{
|
|
None = 0,
|
|
RewardsAndOwnRanking = 1,
|
|
ServerTime = 2,
|
|
OtherPlayersRanking = 3,
|
|
UpdatePlayerData = 4,
|
|
Tournaments_0 = 5
|
|
}
|
|
|
|
public string serverVersion;
|
|
|
|
public SocketIOCommunicator socket;
|
|
|
|
private static ServerManager instance;
|
|
|
|
[FormerlySerializedAs("UserData")]
|
|
public SteamUserData userData;
|
|
|
|
public long serverTime;
|
|
|
|
public bool isServerTimeUpdated;
|
|
|
|
private long serverTimeOnStart;
|
|
|
|
private ChatManager chatManager;
|
|
|
|
public bool getParticipantReady;
|
|
|
|
public static bool isBanned;
|
|
|
|
private RankingFishData rankingFishData = new RankingFishData();
|
|
|
|
private GetRankingsData getRankingsData = new GetRankingsData();
|
|
|
|
public List<RankingPlayersData> rankingPlayersData;
|
|
|
|
public GetRankingOwnData rankingOwnData = new GetRankingOwnData();
|
|
|
|
private GetRankingsLocationData getRankingsLocationData = new GetRankingsLocationData();
|
|
|
|
public List<RankingPlayersLocationData> rankingPlayersLocationData;
|
|
|
|
public GetRankingOwnLocationData rankingOwnLocationData = new GetRankingOwnLocationData();
|
|
|
|
public List<GetRewardOwnData> rewardsOwnData;
|
|
|
|
private PlayerChatData playerChatData = new PlayerChatData();
|
|
|
|
public GetPlayerChatRoomData getPlayerChatRoomData = new GetPlayerChatRoomData();
|
|
|
|
private float getTimeTimer = 1f;
|
|
|
|
private bool isFirstUpdate;
|
|
|
|
private APITestStage apiTestStage;
|
|
|
|
public bool apiTestRunning;
|
|
|
|
private bool testServerWasTimeout;
|
|
|
|
private string testServerEventNameLast;
|
|
|
|
private string testServerResponseLast;
|
|
|
|
private int socketEventID;
|
|
|
|
public static ServerManager Instance => instance;
|
|
|
|
private void Awake()
|
|
{
|
|
UnityEngine.Object.DontDestroyOnLoad(this);
|
|
if (instance == null)
|
|
{
|
|
instance = this;
|
|
}
|
|
else if (instance != this)
|
|
{
|
|
UnityEngine.Object.Destroy(base.gameObject);
|
|
}
|
|
}
|
|
|
|
public void Start()
|
|
{
|
|
socket.Instance.On("ON_GET_REWARDS_OWN", delegate(string payload)
|
|
{
|
|
if (!apiTestRunning)
|
|
{
|
|
OnGetOwnRewards(payload);
|
|
}
|
|
else
|
|
{
|
|
TestServerResponse("ON_GET_REWARDS_OWN", payload);
|
|
}
|
|
});
|
|
socket.Instance.On("ON_GET_RANKING_OWN", delegate(string payload)
|
|
{
|
|
if (!apiTestRunning)
|
|
{
|
|
OnGetOwnRanking(payload);
|
|
}
|
|
else
|
|
{
|
|
TestServerResponse("ON_GET_RANKING_OWN", payload);
|
|
}
|
|
});
|
|
socket.Instance.On("ON_GET_RANKING_PLAYERS", delegate(string payload)
|
|
{
|
|
if (!apiTestRunning)
|
|
{
|
|
OnGetPlayersRanking(payload);
|
|
}
|
|
else
|
|
{
|
|
TestServerResponse("ON_GET_RANKING_PLAYERS", payload);
|
|
}
|
|
});
|
|
socket.Instance.On("ON_GET_RANKING_LOCATION_OWN", delegate(string payload)
|
|
{
|
|
if (!apiTestRunning)
|
|
{
|
|
OnGetOwnRankingLocation(payload);
|
|
}
|
|
else
|
|
{
|
|
TestServerResponse("ON_GET_RANKING_LOCATION_OWN", payload);
|
|
}
|
|
});
|
|
socket.Instance.On("ON_GET_RANKING_LOCATION_PLAYERS", delegate(string payload)
|
|
{
|
|
if (!apiTestRunning)
|
|
{
|
|
OnGetPlayersRankingLocation(payload);
|
|
}
|
|
else
|
|
{
|
|
TestServerResponse("ON_GET_RANKING_LOCATION_PLAYERS", payload);
|
|
}
|
|
});
|
|
socket.Instance.On("ON_GET_SERVER_TIME", delegate(string payload)
|
|
{
|
|
if (!apiTestRunning)
|
|
{
|
|
OnGetServerTime(payload);
|
|
}
|
|
else
|
|
{
|
|
TestServerResponse("ON_GET_SERVER_TIME", payload);
|
|
}
|
|
});
|
|
socket.Instance.On("CONNECT", delegate
|
|
{
|
|
Debug.Log("Po³¹czono z serwerem UFS2_server");
|
|
PlayerReconnect();
|
|
});
|
|
socket.Instance.On("ON_GET_TOURNAMENTS", delegate(string payload)
|
|
{
|
|
if (!apiTestRunning)
|
|
{
|
|
OnGetTournaments(payload);
|
|
}
|
|
else
|
|
{
|
|
TestServerResponse("ON_GET_TOURNAMENTS", payload);
|
|
}
|
|
});
|
|
socket.Instance.On("ON_GET_TOURNAMENT_PARTICIPANTS", delegate(string payload)
|
|
{
|
|
OnGetTournamentParticipants(payload);
|
|
});
|
|
socket.Instance.On("ON_JOIN_TOURNAMENT_FAILED", delegate(string payload)
|
|
{
|
|
OnJoinTournamentFailed(payload);
|
|
});
|
|
socket.Instance.On("ON_JOIN_TOURNAMENT_SUCCESS", delegate(string payload)
|
|
{
|
|
OnJoinTournamentSuccess(payload);
|
|
});
|
|
socket.Instance.On("ON_GET_TOURNAMENT_JOINED_IDS", delegate(string payload)
|
|
{
|
|
if (!apiTestRunning)
|
|
{
|
|
OnGetTournamentJoinedIds(payload);
|
|
}
|
|
else
|
|
{
|
|
TestServerResponse("ON_GET_TOURNAMENT_JOINED_IDS", payload);
|
|
}
|
|
});
|
|
socket.Instance.On("ON_CREATE_TOURNAMENT", delegate(string payload)
|
|
{
|
|
OnCreateTournament(payload);
|
|
});
|
|
socket.Instance.On("ON_GET_TOURNAMENT_INVITES", delegate(string payload)
|
|
{
|
|
if (!apiTestRunning)
|
|
{
|
|
OnGetTournamentInvites(payload);
|
|
}
|
|
else
|
|
{
|
|
TestServerResponse("ON_GET_TOURNAMENT_INVITES", payload);
|
|
}
|
|
});
|
|
socket.Instance.On("ON_GET_DELETE_TOURNAMENT", delegate
|
|
{
|
|
OnGetTournamentDeleteByPlayer();
|
|
});
|
|
socket.Instance.On("ON_GET_BANNED", delegate(string payload)
|
|
{
|
|
OnGetBannedPlayer(payload);
|
|
});
|
|
socket.Instance.Connect();
|
|
InvokeRepeating("UpdatePlayerData", 60f, 60f);
|
|
}
|
|
|
|
private void Update()
|
|
{
|
|
getTimeTimer = Mathf.MoveTowards(getTimeTimer, 0f, Time.unscaledDeltaTime);
|
|
if (getTimeTimer == 0f)
|
|
{
|
|
RepeatTime();
|
|
getTimeTimer = 1f;
|
|
}
|
|
FirstPlayerUpdate();
|
|
}
|
|
|
|
private void RepeatTime()
|
|
{
|
|
if (socket.Instance.IsConnected())
|
|
{
|
|
socket.Instance.Emit("GET_TIME_FROM_SERVER");
|
|
serverTime = serverTimeOnStart;
|
|
}
|
|
else
|
|
{
|
|
long num = DateTimeOffset.Now.ToUnixTimeSeconds();
|
|
serverTime = num;
|
|
}
|
|
}
|
|
|
|
public void OnGetServerTime(string data)
|
|
{
|
|
long num = long.Parse(JObject.Parse(data)["time"].ToString());
|
|
serverTimeOnStart = num;
|
|
isServerTimeUpdated = true;
|
|
}
|
|
|
|
public long GetServerTime()
|
|
{
|
|
return serverTime;
|
|
}
|
|
|
|
private void FirstPlayerUpdate()
|
|
{
|
|
if (SteamManager.Initialized && socket.Instance.IsConnected() && !isFirstUpdate)
|
|
{
|
|
UpdatePlayerData();
|
|
}
|
|
}
|
|
|
|
public void UpdatePlayerData()
|
|
{
|
|
if (SteamManager.Initialized && socket.Instance.IsConnected() && GameManager.Instance._playerData.currentPlayerProfileIndex != -1)
|
|
{
|
|
PlayerData playerData = new PlayerData();
|
|
playerData.PROFILE_INDEX = GameManager.Instance._playerData.currentPlayerProfileIndex;
|
|
playerData.PLAYER_ID = SteamUser.GetSteamID().m_SteamID.ToString();
|
|
playerData.PLAYER_NAME = userData.DisplayName;
|
|
playerData.PLAYER_PROFILE_NAME = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerName;
|
|
playerData.GAME_VERSION = Application.version;
|
|
playerData.PLAYER_LEVEL = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLevel;
|
|
playerData.COUNTRY = Application.systemLanguage.ToString();
|
|
playerData.PLAYER_CASH = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerCash;
|
|
playerData.TOTAL_FISH = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().TotalFish;
|
|
playerData.TOTAL_FISH_WEIGHT = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().TotalFishWeight;
|
|
EmitWithID("UPDATE_PLAYER_DATA", JsonUtility.ToJson(playerData), dataIsPlainText: false);
|
|
isFirstUpdate = true;
|
|
}
|
|
}
|
|
|
|
private void OnGetBannedPlayer(string data)
|
|
{
|
|
if (JObject.Parse(data)["isBanned"].ToString() == "yes")
|
|
{
|
|
isBanned = true;
|
|
}
|
|
else
|
|
{
|
|
isBanned = false;
|
|
}
|
|
Debug.Log("isBanned: " + isBanned);
|
|
}
|
|
|
|
public void AddFishToRankings(GameManager.FishSpecies fishSpecies, float fishWeight, int points, int mapId)
|
|
{
|
|
int currentPlayerProfileIndex = GameManager.Instance._playerData.currentPlayerProfileIndex;
|
|
rankingFishData.PLAYER_ID = SteamUser.GetSteamID().m_SteamID.ToString();
|
|
rankingFishData.PLAYER_NAME = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerName;
|
|
rankingFishData.PROFILE_INDEX = currentPlayerProfileIndex;
|
|
rankingFishData.GAME_MODE = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().GameMode.ToString();
|
|
rankingFishData.FISH_ID = (int)fishSpecies;
|
|
rankingFishData.FISH_WEIGHT = fishWeight;
|
|
rankingFishData.POINTS = points;
|
|
rankingFishData.MAP_ID = mapId;
|
|
EmitWithID("ADD_FISH_TO_RANKINGS", JsonUtility.ToJson(rankingFishData), dataIsPlainText: false);
|
|
}
|
|
|
|
public void GetRankingPlayers(int from, int to)
|
|
{
|
|
_ = GameManager.Instance._playerData.currentPlayerProfileIndex;
|
|
getRankingsData.from = from;
|
|
getRankingsData.to = to;
|
|
getRankingsData.GAME_MODE = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().GameMode.ToString();
|
|
EmitWithID("GET_RANKINGS_PLAYERS", JsonUtility.ToJson(getRankingsData), dataIsPlainText: false);
|
|
}
|
|
|
|
public void GetOwnRankingPosition()
|
|
{
|
|
int currentPlayerProfileIndex = GameManager.Instance._playerData.currentPlayerProfileIndex;
|
|
RankingOwnData rankingOwnData = new RankingOwnData();
|
|
rankingOwnData.PLAYER_ID = SteamUser.GetSteamID().m_SteamID.ToString();
|
|
rankingOwnData.PROFILE_INDEX = currentPlayerProfileIndex;
|
|
rankingOwnData.GAME_MODE = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().GameMode.ToString();
|
|
EmitWithID("GET_RANKINGS_OWN", JsonUtility.ToJson(rankingOwnData), dataIsPlainText: false);
|
|
}
|
|
|
|
private void OnGetPlayersRanking(string data)
|
|
{
|
|
RankingPlayersData[] collection = JsonHelper.FromJson<RankingPlayersData>(JsonHelper.fixJson(data));
|
|
rankingPlayersData.Clear();
|
|
rankingPlayersData.AddRange(collection);
|
|
UnityEngine.Object.FindObjectOfType<RankingManager>().ShowRankingData(rankingPlayersData);
|
|
}
|
|
|
|
private void OnGetOwnRanking(string data)
|
|
{
|
|
rankingOwnData = JsonUtility.FromJson<GetRankingOwnData>(data);
|
|
UnityEngine.Object.FindObjectOfType<RankingManager>().ShowOwnRankingData(rankingOwnData);
|
|
}
|
|
|
|
public void GetRankingPlayersLocation(int from, int to, int locationID)
|
|
{
|
|
_ = GameManager.Instance._playerData.currentPlayerProfileIndex;
|
|
getRankingsLocationData.from = from;
|
|
getRankingsLocationData.to = to;
|
|
getRankingsLocationData.locationID = locationID;
|
|
getRankingsLocationData.GAME_MODE = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().GameMode.ToString();
|
|
EmitWithID("GET_RANKINGS_LOCATION_PLAYERS", JsonUtility.ToJson(getRankingsLocationData), dataIsPlainText: false);
|
|
}
|
|
|
|
public void GetOwnRankingPositionLocation(int locationID)
|
|
{
|
|
int currentPlayerProfileIndex = GameManager.Instance._playerData.currentPlayerProfileIndex;
|
|
RankingOwnLocationData rankingOwnLocationData = new RankingOwnLocationData();
|
|
rankingOwnLocationData.PLAYER_ID = SteamUser.GetSteamID().m_SteamID.ToString();
|
|
rankingOwnLocationData.PROFILE_INDEX = currentPlayerProfileIndex;
|
|
rankingOwnLocationData.GAME_MODE = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().GameMode.ToString();
|
|
rankingOwnLocationData.locationID = locationID;
|
|
EmitWithID("GET_RANKINGS_LOCATION_OWN", JsonUtility.ToJson(rankingOwnLocationData), dataIsPlainText: false);
|
|
}
|
|
|
|
private void OnGetPlayersRankingLocation(string data)
|
|
{
|
|
RankingPlayersLocationData[] collection = JsonHelper.FromJson<RankingPlayersLocationData>(JsonHelper.fixJson(data));
|
|
rankingPlayersLocationData.Clear();
|
|
rankingPlayersLocationData.AddRange(collection);
|
|
UnityEngine.Object.FindObjectOfType<RankingManager>().ShowRankingLocationData(rankingPlayersLocationData);
|
|
}
|
|
|
|
private void OnGetOwnRankingLocation(string data)
|
|
{
|
|
rankingOwnLocationData = JsonUtility.FromJson<GetRankingOwnLocationData>(data);
|
|
UnityEngine.Object.FindObjectOfType<RankingManager>().ShowOwnRankingLocationData(rankingOwnLocationData);
|
|
}
|
|
|
|
private void TestAddPlayerChat()
|
|
{
|
|
_ = GameManager.Instance._playerData.currentPlayerProfileIndex;
|
|
playerChatData.PLAYER_ID = UnityEngine.Random.Range(100000, 9999999).ToString();
|
|
playerChatData.PLAYER_NAME = "Gracz_" + playerChatData.PLAYER_ID;
|
|
playerChatData.COUNTRY = LocalizationManager.CurrentLanguageCode;
|
|
playerChatData.LOCATION_ID = "0";
|
|
}
|
|
|
|
private void PlayerReconnect()
|
|
{
|
|
if (getPlayerChatRoomData.ID != "" && playerChatData.LOCATION_ID != "-1")
|
|
{
|
|
ReJoinToChat();
|
|
}
|
|
}
|
|
|
|
public void JoinToChat(string locationId, ChatManager currentChat)
|
|
{
|
|
chatManager = currentChat;
|
|
_ = GameManager.Instance._playerData.currentPlayerProfileIndex;
|
|
playerChatData.PLAYER_ID = SteamUser.GetSteamID().m_SteamID.ToString();
|
|
playerChatData.PLAYER_NAME = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerName;
|
|
playerChatData.COUNTRY = LocalizationManager.CurrentLanguageCode;
|
|
playerChatData.LOCATION_ID = locationId;
|
|
}
|
|
|
|
private void ReJoinToChat()
|
|
{
|
|
_ = GameManager.Instance._playerData.currentPlayerProfileIndex;
|
|
new ReconnectPlayerData
|
|
{
|
|
PLAYER_ID = SteamUser.GetSteamID().m_SteamID.ToString(),
|
|
PLAYER_NAME = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerName,
|
|
ROOM_ID = getPlayerChatRoomData.ID,
|
|
LOCATION_ID = getPlayerChatRoomData.LOCATION_ID
|
|
};
|
|
}
|
|
|
|
public void SendChatMessage(string message, string country)
|
|
{
|
|
_ = GameManager.Instance._playerData.currentPlayerProfileIndex;
|
|
new Message
|
|
{
|
|
PLAYER_ID = SteamUser.GetSteamID().m_SteamID.ToString(),
|
|
PLAYER_NAME = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerName,
|
|
COUNTRY = country,
|
|
MESSAGE = message
|
|
};
|
|
}
|
|
|
|
public void OnGetMessage(string data)
|
|
{
|
|
Message message = new Message();
|
|
message = JsonUtility.FromJson<Message>(data);
|
|
Debug.Log("data: " + data + " playerChatMessage:" + message.PLAYER_NAME);
|
|
}
|
|
|
|
private void OnGetChatJoinToRoom(string data)
|
|
{
|
|
getPlayerChatRoomData = JsonUtility.FromJson<GetPlayerChatRoomData>(data);
|
|
}
|
|
|
|
private void OnGetPlayerJoinToRoom(string data)
|
|
{
|
|
Message message = new Message();
|
|
message = JsonUtility.FromJson<Message>(data);
|
|
Debug.Log("data: " + data + " playerChatMessage:" + message.PLAYER_NAME);
|
|
}
|
|
|
|
private void OnLeavePlayerFromRoom(string data)
|
|
{
|
|
Message message = new Message();
|
|
message = JsonUtility.FromJson<Message>(data);
|
|
Debug.Log("Gracz wyszed³ z pokoju data: " + data + " playerChatMessage:" + message.PLAYER_NAME);
|
|
}
|
|
|
|
private void OnGetFishMessage(string data)
|
|
{
|
|
FishMessage fishMessage = new FishMessage();
|
|
fishMessage = JsonUtility.FromJson<FishMessage>(data);
|
|
Debug.Log("Gracz zlapal rybe: " + fishMessage.FISH_ID + " weight: " + fishMessage.FISH_WEIGHT);
|
|
}
|
|
|
|
public void ChatDisconnect()
|
|
{
|
|
getPlayerChatRoomData.ID = "";
|
|
getPlayerChatRoomData.LOCATION_ID = "-1";
|
|
getPlayerChatRoomData.PLAYERS = "";
|
|
}
|
|
|
|
private void OnGetOwnRewards(string data)
|
|
{
|
|
GetRewardOwnData[] collection = JsonHelper.FromJson<GetRewardOwnData>(JsonHelper.fixJson(data));
|
|
rewardsOwnData.Clear();
|
|
rewardsOwnData.AddRange(collection);
|
|
}
|
|
|
|
public void GetOwnRewards()
|
|
{
|
|
RewardOwnData rewardOwnData = new RewardOwnData();
|
|
int currentPlayerProfileIndex = GameManager.Instance._playerData.currentPlayerProfileIndex;
|
|
rewardOwnData.PLAYER_ID = SteamUser.GetSteamID().m_SteamID.ToString();
|
|
rewardOwnData.PLAYER_NAME = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerName;
|
|
rewardOwnData.PROFILE_INDEX = currentPlayerProfileIndex;
|
|
EmitWithID("GET_REWARDS_OWN", JsonUtility.ToJson(rewardOwnData), dataIsPlainText: false);
|
|
}
|
|
|
|
public void GetAllTournaments()
|
|
{
|
|
socket.Instance.Emit("GET_TOURNAMENTS");
|
|
}
|
|
|
|
public void GetTournament(int tournamentId)
|
|
{
|
|
Debug.Log("Get tournament emit");
|
|
EmitWithID("GET_TOURNAMENT", tournamentId.ToString(), dataIsPlainText: false);
|
|
}
|
|
|
|
private void OnGetTournaments(string data)
|
|
{
|
|
TournamentData[] array = JsonHelper.FromJson<TournamentData>(JsonHelper.fixJson(data));
|
|
for (int i = 0; i < array.Length; i++)
|
|
{
|
|
bool flag = false;
|
|
for (int j = 0; j < TournamentManager.Instance.tournaments.Count; j++)
|
|
{
|
|
if (TournamentManager.Instance.tournaments[j].id == array[i].ID)
|
|
{
|
|
TournamentManager.Instance.tournaments[j].timeToEnd = array[i].TIME_TO_END_S;
|
|
TournamentManager.Instance.tournaments[j].timeLeft = (int)((array[i].TIME_START + array[i].DURATION * 60 - serverTime) / 60);
|
|
TournamentManager.Instance.tournaments[j].timeStart = array[i].TIME_START;
|
|
TournamentManager.Instance.tournaments[j].timeCreate = array[i].TIME_CREATE_S;
|
|
flag = true;
|
|
}
|
|
}
|
|
if (!flag)
|
|
{
|
|
TournamentManager.CTournament cTournament = new TournamentManager.CTournament();
|
|
cTournament.id = array[i].ID;
|
|
cTournament.tournamentName = array[i].NAME;
|
|
cTournament.tournamentType = (TournamentManager.TournamentContentType)Enum.Parse(typeof(TournamentManager.TournamentContentType), array[i].TYPE);
|
|
cTournament.type = (TournamentManager.TournamentType)Enum.Parse(typeof(TournamentManager.TournamentType), array[i].VISABLE_TYPE);
|
|
cTournament.tournamentTask = (TournamentManager.CTournament.TournamentTask)Enum.Parse(typeof(TournamentManager.CTournament.TournamentTask), array[i].TASK);
|
|
cTournament.tournamentMethod = (TournamentManager.CTournament.TournamentMethod)Enum.Parse(typeof(TournamentManager.CTournament.TournamentMethod), array[i].METHOD);
|
|
cTournament.mapId = array[i].MAP_ID;
|
|
cTournament.duration = array[i].DURATION;
|
|
cTournament.participantMaximum = array[i].PARTICIPANTS_MAX;
|
|
cTournament.entryFee = array[i].ENTRY_FEE;
|
|
cTournament.levelRange = new Vector2(array[i].LEVEL_MIN, array[i].LEVEL_MAX);
|
|
cTournament.timeStart = array[i].TIME_START;
|
|
cTournament.creatorPlayerId = array[i].CREATOR_PLAYER_ID;
|
|
cTournament.creatorPlayerName = array[i].CREATOR_PLAYER_NAME;
|
|
cTournament.creatorProfileIndex = array[i].CREATOR_PROFILE_INDEX;
|
|
cTournament.timeLeft = (int)((array[i].TIME_START + array[i].DURATION * 60 - serverTime) / 60);
|
|
cTournament.timeToEnd = array[i].TIME_TO_END_S;
|
|
cTournament.timeCreate = array[i].TIME_CREATE_S;
|
|
TournamentManager.Instance.tournaments.Add(cTournament);
|
|
}
|
|
}
|
|
for (int k = 0; k < TournamentManager.Instance.tournaments.Count; k++)
|
|
{
|
|
bool flag2 = true;
|
|
for (int l = 0; l < array.Length; l++)
|
|
{
|
|
if (TournamentManager.Instance.tournaments[k].id == array[l].ID)
|
|
{
|
|
flag2 = false;
|
|
}
|
|
}
|
|
if (flag2)
|
|
{
|
|
TournamentManager.Instance.tournaments.Remove(TournamentManager.Instance.tournaments[k]);
|
|
}
|
|
}
|
|
Debug.Log("Odebrano liste turniejów z serwera: " + array.Length);
|
|
}
|
|
|
|
public void GetTournamentParticipants(int tournamentId)
|
|
{
|
|
EmitWithID("GET_TOURNAMENT_PARTICIPANTS", tournamentId.ToString(), dataIsPlainText: false);
|
|
}
|
|
|
|
private void OnGetTournamentParticipants(string data)
|
|
{
|
|
getParticipantReady = true;
|
|
TournamentParticipantsData[] array = JsonHelper.FromJson<TournamentParticipantsData>(JsonHelper.fixJson(data));
|
|
Debug.Log("Odebrano liste uczestników turniejów z serwera: " + array.Length);
|
|
for (int i = 0; i < array.Length; i++)
|
|
{
|
|
for (int j = 0; j < TournamentManager.Instance.tournaments.Count; j++)
|
|
{
|
|
if (TournamentManager.Instance.tournaments[j].id != array[i].TOURNAMENT_ID)
|
|
{
|
|
continue;
|
|
}
|
|
bool flag = false;
|
|
for (int k = 0; k < TournamentManager.Instance.tournaments[j].tournamentParticipants.Count; k++)
|
|
{
|
|
if (TournamentManager.Instance.tournaments[j].tournamentParticipants[k].playerId == array[i].PLAYER_ID && TournamentManager.Instance.tournaments[j].tournamentParticipants[k].profile_index == array[i].PROFILE_INDEX)
|
|
{
|
|
TournamentManager.Instance.tournaments[j].tournamentParticipants[k].player_level = array[i].PLAYER_LEVEL;
|
|
TournamentManager.Instance.tournaments[j].tournamentParticipants[k].tournaments_won = array[i].TOURNAMENTS_WON;
|
|
TournamentManager.Instance.tournaments[j].tournamentParticipants[k].rankings_points = array[i].RANKING_POINTS;
|
|
TournamentManager.Instance.tournaments[j].tournamentParticipants[k].value = array[i].VALUE;
|
|
TournamentManager.Instance.tournaments[j].tournamentParticipants[k].bestFishId = array[i].BEST_FISH_ID;
|
|
TournamentManager.Instance.tournaments[j].tournamentParticipants[k].status = array[i].STATUS;
|
|
TournamentManager.Instance.tournaments[j].tournamentParticipants[k].joined_timeleft = array[i].JOINED_TIMELEFT;
|
|
flag = true;
|
|
}
|
|
}
|
|
if (!flag)
|
|
{
|
|
TournamentManager.CTournament.TournamentParticipant tournamentParticipant = new TournamentManager.CTournament.TournamentParticipant();
|
|
tournamentParticipant.playerId = array[i].PLAYER_ID;
|
|
tournamentParticipant.playerName = array[i].PLAYER_NAME;
|
|
tournamentParticipant.profile_index = array[i].PROFILE_INDEX;
|
|
tournamentParticipant.player_level = array[i].PLAYER_LEVEL;
|
|
tournamentParticipant.tournaments_won = array[i].TOURNAMENTS_WON;
|
|
tournamentParticipant.rankings_points = array[i].RANKING_POINTS;
|
|
tournamentParticipant.bestFishId = array[i].BEST_FISH_ID;
|
|
tournamentParticipant.value = array[i].VALUE;
|
|
tournamentParticipant.status = array[i].STATUS;
|
|
tournamentParticipant.joined_timeleft = array[i].JOINED_TIMELEFT;
|
|
TournamentManager.Instance.tournaments[j].tournamentParticipants.Add(tournamentParticipant);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void JoinToTournament(TournamentManager.CTournament tournament)
|
|
{
|
|
int currentPlayerProfileIndex = GameManager.Instance._playerData.currentPlayerProfileIndex;
|
|
TournamentJoinData tournamentJoinData = new TournamentJoinData();
|
|
tournamentJoinData.PLAYER_ID = SteamUser.GetSteamID().m_SteamID.ToString();
|
|
tournamentJoinData.PLAYER_NAME = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerName;
|
|
tournamentJoinData.PROFILE_INDEX = currentPlayerProfileIndex;
|
|
tournamentJoinData.TOURNAMENT_ID = tournament.id;
|
|
tournamentJoinData.PARTICIPANTS_MAX = tournament.participantMaximum;
|
|
tournamentJoinData.PLAYER_LEVEL = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLevel;
|
|
tournamentJoinData.TOURNAMENTS_WON = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerTournamentsWon;
|
|
tournamentJoinData.RANKING_POINTS = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRankingPoints;
|
|
EmitWithID("JOIN_TOURNAMENT", JsonUtility.ToJson(tournamentJoinData), dataIsPlainText: false);
|
|
}
|
|
|
|
private void OnJoinTournamentFailed(string data)
|
|
{
|
|
Debug.Log("B³¹d do³aczenia, limit uczestników");
|
|
}
|
|
|
|
private void OnJoinTournamentSuccess(string data)
|
|
{
|
|
Debug.Log("Do³aczenie do turnieju: " + data);
|
|
if (int.TryParse(data, out var result))
|
|
{
|
|
TournamentManager.Instance.myTournamentsIds.Add(result);
|
|
}
|
|
}
|
|
|
|
public void GetTournamentJoinedIds()
|
|
{
|
|
int currentPlayerProfileIndex = GameManager.Instance._playerData.currentPlayerProfileIndex;
|
|
TournamentJoinData tournamentJoinData = new TournamentJoinData();
|
|
tournamentJoinData.PLAYER_ID = SteamUser.GetSteamID().m_SteamID.ToString();
|
|
tournamentJoinData.PROFILE_INDEX = currentPlayerProfileIndex;
|
|
EmitWithID("GET_JOINED_TOURNAMENT_IDS", JsonUtility.ToJson(tournamentJoinData), dataIsPlainText: false);
|
|
}
|
|
|
|
private void OnGetTournamentJoinedIds(string data)
|
|
{
|
|
Debug.Log("OnGetTournamentJoinedIds: " + data);
|
|
TournamentJoinedIdsData[] array = JsonHelper.FromJson<TournamentJoinedIdsData>(JsonHelper.fixJson(data));
|
|
TournamentManager.Instance.myTournamentsIds.Clear();
|
|
for (int i = 0; i < array.Length; i++)
|
|
{
|
|
TournamentManager.Instance.myTournamentsIds.Add(array[i].TOURNAMENT_ID);
|
|
}
|
|
}
|
|
|
|
public void CreateTournament(TournamentManager.CTournament tournament, List<TournamentManager.CInviteSend> invitePlayers)
|
|
{
|
|
int currentPlayerProfileIndex = GameManager.Instance._playerData.currentPlayerProfileIndex;
|
|
TournamentCreatorData tournamentCreatorData = new TournamentCreatorData();
|
|
tournamentCreatorData.NAME = tournament.tournamentName;
|
|
tournamentCreatorData.TYPE = tournament.tournamentType.ToString();
|
|
tournamentCreatorData.TYPE_PLAYER_TOURNAMENT = tournament.type.ToString();
|
|
tournamentCreatorData.TASK = tournament.tournamentTask.ToString();
|
|
tournamentCreatorData.METHOD = tournament.tournamentMethod.ToString();
|
|
tournamentCreatorData.MAP_ID = tournament.mapId;
|
|
tournamentCreatorData.DURATION = tournament.duration;
|
|
tournamentCreatorData.ENTRY_FEE = tournament.entryFee;
|
|
tournamentCreatorData.PARTICIPANTS_MAX = tournament.participantMaximum;
|
|
tournamentCreatorData.LEVEL_MIN = (int)tournament.levelRange.x;
|
|
tournamentCreatorData.LEVEL_MAX = (int)tournament.levelRange.y;
|
|
tournamentCreatorData.PLAYER_ID = SteamUser.GetSteamID().m_SteamID.ToString();
|
|
tournamentCreatorData.PLAYER_NAME = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerName;
|
|
tournamentCreatorData.PROFILE_INDEX = currentPlayerProfileIndex;
|
|
tournamentCreatorData.INVITES = JsonHelper.ToJson(invitePlayers.ToArray());
|
|
EmitWithID("CREATE_TOURNAMENT", JsonUtility.ToJson(tournamentCreatorData), dataIsPlainText: false);
|
|
}
|
|
|
|
private void OnCreateTournament(string data)
|
|
{
|
|
if (int.TryParse(data, out var result) && result != -1)
|
|
{
|
|
TournamentManager.Instance.currentCreatorTournament.id = result;
|
|
TournamentPlayerCreator tournamentPlayerCreator = UnityEngine.Object.FindObjectOfType<TournamentPlayerCreator>();
|
|
if (tournamentPlayerCreator != null)
|
|
{
|
|
Debug.Log("Create tournament id:" + result);
|
|
tournamentPlayerCreator.CreateSuccess();
|
|
}
|
|
}
|
|
}
|
|
|
|
public void ReadyTournament(TournamentManager.CTournament tournament)
|
|
{
|
|
int currentPlayerProfileIndex = GameManager.Instance._playerData.currentPlayerProfileIndex;
|
|
TournamentJoinData tournamentJoinData = new TournamentJoinData();
|
|
tournamentJoinData.PLAYER_ID = SteamUser.GetSteamID().m_SteamID.ToString();
|
|
tournamentJoinData.PROFILE_INDEX = currentPlayerProfileIndex;
|
|
tournamentJoinData.TOURNAMENT_ID = tournament.id;
|
|
EmitWithID("READY_TOURNAMENT", JsonUtility.ToJson(tournamentJoinData), dataIsPlainText: false);
|
|
}
|
|
|
|
public void AutoReadyTournament(TournamentManager.CTournament.TournamentParticipant participant, int tournament_id)
|
|
{
|
|
TournamentJoinData tournamentJoinData = new TournamentJoinData();
|
|
tournamentJoinData.PLAYER_ID = participant.playerId;
|
|
tournamentJoinData.PROFILE_INDEX = participant.profile_index;
|
|
tournamentJoinData.TOURNAMENT_ID = tournament_id;
|
|
EmitWithID("READY_TOURNAMENT", JsonUtility.ToJson(tournamentJoinData), dataIsPlainText: false);
|
|
}
|
|
|
|
public void GetTournamentInvites()
|
|
{
|
|
TournamentJoinData tournamentJoinData = new TournamentJoinData();
|
|
tournamentJoinData.PLAYER_ID = SteamUser.GetSteamID().m_SteamID.ToString();
|
|
EmitWithID("GET_INVITES_TOURNAMENT", JsonUtility.ToJson(tournamentJoinData), dataIsPlainText: false);
|
|
}
|
|
|
|
private void OnGetTournamentInvites(string data)
|
|
{
|
|
TournamentInvitesData[] array = JsonHelper.FromJson<TournamentInvitesData>(JsonHelper.fixJson(data));
|
|
for (int i = 0; i < array.Length; i++)
|
|
{
|
|
bool flag = false;
|
|
for (int j = 0; j < TournamentManager.Instance.myTournamentInvites.Count; j++)
|
|
{
|
|
if (TournamentManager.Instance.myTournamentInvites[j].tournamentId == array[i].TOURNAMENT_ID)
|
|
{
|
|
flag = true;
|
|
}
|
|
}
|
|
if (!flag)
|
|
{
|
|
TournamentManager.CInvite cInvite = new TournamentManager.CInvite();
|
|
cInvite.tournamentId = array[i].TOURNAMENT_ID;
|
|
cInvite.tournamentName = array[i].TOURNAMENT_NAME;
|
|
cInvite.playerSenderName = array[i].SEND_PLAYER_NAME;
|
|
TournamentManager.Instance.myTournamentInvites.Add(cInvite);
|
|
}
|
|
}
|
|
for (int k = 0; k < TournamentManager.Instance.myTournamentInvites.Count; k++)
|
|
{
|
|
bool flag2 = false;
|
|
for (int l = 0; l < array.Length; l++)
|
|
{
|
|
if (TournamentManager.Instance.myTournamentInvites[k].tournamentId == array[l].TOURNAMENT_ID)
|
|
{
|
|
flag2 = true;
|
|
}
|
|
}
|
|
if (!flag2)
|
|
{
|
|
TournamentManager.Instance.myTournamentInvites.Remove(TournamentManager.Instance.myTournamentInvites[k]);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void StartPlayerTournament(int tournamentId)
|
|
{
|
|
TournamentJoinedIdsData tournamentJoinedIdsData = new TournamentJoinedIdsData();
|
|
tournamentJoinedIdsData.TOURNAMENT_ID = tournamentId;
|
|
EmitWithID("START_TOURNAMENT", JsonUtility.ToJson(tournamentJoinedIdsData), dataIsPlainText: false);
|
|
}
|
|
|
|
public void TournamentSendFish(int fishId, float weight, TournamentManager.CTournament tournament, int mapId = 0)
|
|
{
|
|
TournamentFishData tournamentFishData = new TournamentFishData();
|
|
tournamentFishData.TOURNAMENT_ID = tournament.id;
|
|
tournamentFishData.PLAYER_ID = SteamUser.GetSteamID().m_SteamID.ToString();
|
|
tournamentFishData.PROFILE_INDEX = GameManager.Instance._playerData.currentPlayerProfileIndex;
|
|
tournamentFishData.TASK = tournament.tournamentTask.ToString();
|
|
tournamentFishData.FISH_ID = fishId;
|
|
tournamentFishData.FISH_WEIGHT = weight;
|
|
tournamentFishData.MAP_ID = mapId;
|
|
EmitWithID("ADD_FISH_TOURNAMENT", JsonUtility.ToJson(tournamentFishData), dataIsPlainText: false);
|
|
}
|
|
|
|
public void TournamentSendFishTESt(int fishId, float weight, int tournamentID)
|
|
{
|
|
TournamentFishData tournamentFishData = new TournamentFishData();
|
|
tournamentFishData.TOURNAMENT_ID = tournamentID;
|
|
tournamentFishData.PLAYER_ID = SteamUser.GetSteamID().m_SteamID.ToString();
|
|
tournamentFishData.PROFILE_INDEX = GameManager.Instance._playerData.currentPlayerProfileIndex;
|
|
tournamentFishData.FISH_ID = fishId;
|
|
tournamentFishData.FISH_WEIGHT = weight;
|
|
EmitWithID("ADD_FISH_TOURNAMENT", JsonUtility.ToJson(tournamentFishData), dataIsPlainText: false);
|
|
}
|
|
|
|
public void DeletePlayerTournament(int tournamentId)
|
|
{
|
|
TournamentJoinedIdsData tournamentJoinedIdsData = new TournamentJoinedIdsData();
|
|
tournamentJoinedIdsData.TOURNAMENT_ID = tournamentId;
|
|
EmitWithID("DELETE_TOURNAMENT", JsonUtility.ToJson(tournamentJoinedIdsData), dataIsPlainText: false);
|
|
}
|
|
|
|
private void OnGetTournamentDeleteByPlayer()
|
|
{
|
|
TournamentScene tournamentScene = UnityEngine.Object.FindObjectOfType<TournamentScene>();
|
|
if ((bool)tournamentScene)
|
|
{
|
|
TournamentManager.Instance.tournaments.Clear();
|
|
if (tournamentScene.currentTournamentContentType == TournamentManager.TournamentContentType.CreatorTournament)
|
|
{
|
|
tournamentScene.ChangeType("CreatorTournament");
|
|
}
|
|
if (tournamentScene.currentTournamentContentType == TournamentManager.TournamentContentType.MyTournaments)
|
|
{
|
|
tournamentScene.ChangeType("MyTournaments");
|
|
}
|
|
if (tournamentScene.currentTournamentContentType == TournamentManager.TournamentContentType.Players)
|
|
{
|
|
tournamentScene.ChangeType("Players");
|
|
}
|
|
}
|
|
}
|
|
|
|
private void TestServerResponse(string eventName, string payload)
|
|
{
|
|
testServerEventNameLast = eventName;
|
|
testServerResponseLast = payload;
|
|
}
|
|
|
|
private void ResetResponse()
|
|
{
|
|
testServerWasTimeout = false;
|
|
testServerEventNameLast = null;
|
|
testServerResponseLast = null;
|
|
}
|
|
|
|
private IEnumerator WaitForResponseOrTimeout(bool filterOut_Time = true, bool filterOut_Rewards = true, bool filterOut_Invites = true)
|
|
{
|
|
testServerWasTimeout = false;
|
|
float timeout = 5f;
|
|
float startTime = Time.time;
|
|
while (Time.time - startTime < timeout)
|
|
{
|
|
if (testServerEventNameLast != null)
|
|
{
|
|
bool flag = false;
|
|
if (filterOut_Time && testServerEventNameLast == "ON_GET_SERVER_TIME")
|
|
{
|
|
flag = true;
|
|
}
|
|
if (filterOut_Rewards && testServerEventNameLast == "ON_GET_REWARDS_OWN")
|
|
{
|
|
flag = true;
|
|
}
|
|
if (filterOut_Invites && testServerEventNameLast == "ON_GET_TOURNAMENT_INVITES")
|
|
{
|
|
flag = true;
|
|
}
|
|
if (!flag)
|
|
{
|
|
yield break;
|
|
}
|
|
}
|
|
yield return null;
|
|
}
|
|
testServerWasTimeout = true;
|
|
}
|
|
|
|
public void StartAPITest(TextMeshProUGUI uiText)
|
|
{
|
|
if (!apiTestRunning)
|
|
{
|
|
apiTestStage = (APITestStage)((int)(apiTestStage + 1) % Enum.GetValues(typeof(APITestStage)).Length);
|
|
if (apiTestStage == APITestStage.None)
|
|
{
|
|
UnityEngine.Object.Destroy(uiText.transform.parent.gameObject);
|
|
}
|
|
else
|
|
{
|
|
StartCoroutine(TestCoroutine());
|
|
}
|
|
}
|
|
IEnumerator TestCoroutine()
|
|
{
|
|
apiTestRunning = true;
|
|
uiText.text = "";
|
|
uiText.text += $"Socket status: {socket.Instance.Status}\n";
|
|
TextMeshProUGUI textMeshProUGUI = uiText;
|
|
textMeshProUGUI.text = textMeshProUGUI.text + "Socket socket ID: " + socket.Instance.SocketID + "\n";
|
|
TextMeshProUGUI textMeshProUGUI2 = uiText;
|
|
textMeshProUGUI2.text = textMeshProUGUI2.text + "Socket address: " + socket.socketIOAddress + "\n";
|
|
uiText.text += "\n//////////////////////////////////////////////////////////////////////////////\n\n";
|
|
using (System.Net.NetworkInformation.Ping ping = new System.Net.NetworkInformation.Ping())
|
|
{
|
|
string text = socket.socketIOAddress.Split(':')[0];
|
|
try
|
|
{
|
|
PingReply pingReply = ping.Send(text);
|
|
if (pingReply.Status == IPStatus.Success)
|
|
{
|
|
uiText.text += $"Ping to {pingReply.Address} successful: Time={pingReply.RoundtripTime}ms\n";
|
|
}
|
|
else
|
|
{
|
|
uiText.text += $"Ping to {pingReply.Address} failed: {pingReply.Status}\n";
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
TextMeshProUGUI textMeshProUGUI3 = uiText;
|
|
textMeshProUGUI3.text = textMeshProUGUI3.text + "Failed to ping " + text + ": " + ex.Message + "\n";
|
|
}
|
|
}
|
|
uiText.text += $"\n///////////////////////////////////// API TEST STAGE: {apiTestStage} /////////////////////////////////////////\n\n";
|
|
if (apiTestStage == APITestStage.RewardsAndOwnRanking)
|
|
{
|
|
uiText.text += "\nEmitting event: GET_REWARDS_OWN\n";
|
|
ResetResponse();
|
|
GetOwnRewards();
|
|
yield return WaitForResponseOrTimeout(filterOut_Time: true, filterOut_Rewards: false);
|
|
if (!testServerWasTimeout)
|
|
{
|
|
TextMeshProUGUI textMeshProUGUI3 = uiText;
|
|
textMeshProUGUI3.text = textMeshProUGUI3.text + "Received response for " + testServerEventNameLast + ": " + testServerResponseLast + "\n";
|
|
}
|
|
else
|
|
{
|
|
uiText.text += "Response timeout\n";
|
|
}
|
|
uiText.text += "\nEmitting event: GET_RANKINGS_OWN\n";
|
|
ResetResponse();
|
|
GetOwnRankingPosition();
|
|
yield return WaitForResponseOrTimeout();
|
|
if (!testServerWasTimeout)
|
|
{
|
|
TextMeshProUGUI textMeshProUGUI3 = uiText;
|
|
textMeshProUGUI3.text = textMeshProUGUI3.text + "Received response for " + testServerEventNameLast + ": " + testServerResponseLast + "\n";
|
|
}
|
|
else
|
|
{
|
|
uiText.text += "Response timeout\n";
|
|
}
|
|
uiText.text += "\nEmitting event: GET_RANKINGS_LOCATION_OWN\n";
|
|
ResetResponse();
|
|
GetOwnRankingPositionLocation(2);
|
|
yield return WaitForResponseOrTimeout();
|
|
if (!testServerWasTimeout)
|
|
{
|
|
TextMeshProUGUI textMeshProUGUI3 = uiText;
|
|
textMeshProUGUI3.text = textMeshProUGUI3.text + "Received response for " + testServerEventNameLast + ": " + testServerResponseLast + "\n";
|
|
}
|
|
else
|
|
{
|
|
uiText.text += "Response timeout\n";
|
|
}
|
|
uiText.text += "\nEmitting event: ADD_FISH_TO_RANKINGS\n";
|
|
List<int> list = new List<int> { 2 };
|
|
int num = list[UnityEngine.Random.Range(0, list.Count)];
|
|
GameManager.FishSpecies fishSpecies = GameManager.FishSpecies.Perch;
|
|
float num2 = 1f;
|
|
int num3 = 1;
|
|
switch (num)
|
|
{
|
|
case 0:
|
|
fishSpecies = GameManager.FishSpecies.Bluegill;
|
|
num2 = 0.7966322f;
|
|
num3 = 4;
|
|
break;
|
|
case 1:
|
|
fishSpecies = GameManager.FishSpecies.Asp;
|
|
num2 = 1.2f;
|
|
num3 = 5;
|
|
break;
|
|
case 2:
|
|
fishSpecies = GameManager.FishSpecies.CharArctic;
|
|
num2 = 1.2f;
|
|
num3 = 5;
|
|
break;
|
|
case 3:
|
|
fishSpecies = GameManager.FishSpecies.Tench;
|
|
num2 = 1.2f;
|
|
num3 = 5;
|
|
break;
|
|
case 4:
|
|
fishSpecies = GameManager.FishSpecies.Tench;
|
|
num2 = 1.2f;
|
|
num3 = 5;
|
|
break;
|
|
}
|
|
uiText.text += $"Fish: {fishSpecies} Weight: {num2} Points: {num3} Map ID: {num}\n";
|
|
ResetResponse();
|
|
AddFishToRankings(fishSpecies, num2, num3, num);
|
|
yield return WaitForResponseOrTimeout();
|
|
if (!testServerWasTimeout)
|
|
{
|
|
TextMeshProUGUI textMeshProUGUI3 = uiText;
|
|
textMeshProUGUI3.text = textMeshProUGUI3.text + "Received response for " + testServerEventNameLast + ": " + testServerResponseLast + "\n";
|
|
}
|
|
else
|
|
{
|
|
uiText.text += "Response timeout\n";
|
|
}
|
|
}
|
|
if (apiTestStage == APITestStage.ServerTime)
|
|
{
|
|
uiText.text += "\nEmitting event: GET_TIME_FROM_SERVER\n";
|
|
ResetResponse();
|
|
RepeatTime();
|
|
yield return WaitForResponseOrTimeout(filterOut_Time: false);
|
|
if (!testServerWasTimeout)
|
|
{
|
|
TextMeshProUGUI textMeshProUGUI3 = uiText;
|
|
textMeshProUGUI3.text = textMeshProUGUI3.text + "Received response for " + testServerEventNameLast + ": " + testServerResponseLast + "\n";
|
|
}
|
|
else
|
|
{
|
|
uiText.text += "Response timeout\n";
|
|
}
|
|
}
|
|
if (apiTestStage == APITestStage.OtherPlayersRanking)
|
|
{
|
|
uiText.text += "\nEmitting event: GET_RANKINGS_PLAYERS\n";
|
|
ResetResponse();
|
|
GetRankingPlayers(15, 0);
|
|
yield return WaitForResponseOrTimeout();
|
|
if (!testServerWasTimeout)
|
|
{
|
|
TextMeshProUGUI textMeshProUGUI3 = uiText;
|
|
textMeshProUGUI3.text = textMeshProUGUI3.text + "Received response for " + testServerEventNameLast + ": " + testServerResponseLast + "\n";
|
|
}
|
|
else
|
|
{
|
|
uiText.text += "Response timeout\n";
|
|
}
|
|
uiText.text += "\nEmitting event: GET_RANKINGS_LOCATION_PLAYERS\n";
|
|
ResetResponse();
|
|
GetRankingPlayersLocation(15, 0, 2);
|
|
yield return WaitForResponseOrTimeout();
|
|
if (!testServerWasTimeout)
|
|
{
|
|
TextMeshProUGUI textMeshProUGUI3 = uiText;
|
|
textMeshProUGUI3.text = textMeshProUGUI3.text + "Received response for " + testServerEventNameLast + ": " + testServerResponseLast + "\n";
|
|
}
|
|
else
|
|
{
|
|
uiText.text += "Response timeout\n";
|
|
}
|
|
}
|
|
if (apiTestStage == APITestStage.UpdatePlayerData)
|
|
{
|
|
uiText.text += "\nEmitting event: UPDATE_PLAYER_DATA\n";
|
|
ResetResponse();
|
|
UpdatePlayerData();
|
|
yield return WaitForResponseOrTimeout();
|
|
if (!testServerWasTimeout)
|
|
{
|
|
TextMeshProUGUI textMeshProUGUI3 = uiText;
|
|
textMeshProUGUI3.text = textMeshProUGUI3.text + "Received response for " + testServerEventNameLast + ": " + testServerResponseLast + "\n";
|
|
}
|
|
else
|
|
{
|
|
uiText.text += "Response timeout\n";
|
|
}
|
|
}
|
|
if (apiTestStage == APITestStage.Tournaments_0)
|
|
{
|
|
uiText.text += "\nEmitting event: GET_TOURNAMENTS\n";
|
|
ResetResponse();
|
|
GetAllTournaments();
|
|
yield return WaitForResponseOrTimeout();
|
|
if (!testServerWasTimeout)
|
|
{
|
|
TextMeshProUGUI textMeshProUGUI3 = uiText;
|
|
textMeshProUGUI3.text = textMeshProUGUI3.text + "Received response for " + testServerEventNameLast + ": " + testServerResponseLast + "\n";
|
|
}
|
|
else
|
|
{
|
|
uiText.text += "Response timeout\n";
|
|
}
|
|
uiText.text += "\nEmitting event: GET_JOINED_TOURNAMENT_IDS\n";
|
|
ResetResponse();
|
|
GetTournamentJoinedIds();
|
|
yield return WaitForResponseOrTimeout();
|
|
if (!testServerWasTimeout)
|
|
{
|
|
TextMeshProUGUI textMeshProUGUI3 = uiText;
|
|
textMeshProUGUI3.text = textMeshProUGUI3.text + "Received response for " + testServerEventNameLast + ": " + testServerResponseLast + "\n";
|
|
}
|
|
else
|
|
{
|
|
uiText.text += "Response timeout\n";
|
|
}
|
|
uiText.text += "\nEmitting event: GET_INVITES_TOURNAMENT\n";
|
|
ResetResponse();
|
|
GetTournamentInvites();
|
|
yield return WaitForResponseOrTimeout(filterOut_Time: true, filterOut_Rewards: true, filterOut_Invites: false);
|
|
if (!testServerWasTimeout)
|
|
{
|
|
TextMeshProUGUI textMeshProUGUI3 = uiText;
|
|
textMeshProUGUI3.text = textMeshProUGUI3.text + "Received response for " + testServerEventNameLast + ": " + testServerResponseLast + "\n";
|
|
}
|
|
else
|
|
{
|
|
uiText.text += "Response timeout\n";
|
|
}
|
|
}
|
|
string path = $"ServerAPITest_Stage_{apiTestStage}.txt";
|
|
using (StreamWriter streamWriter = new StreamWriter(Path.Combine(Application.persistentDataPath, path), append: false))
|
|
{
|
|
streamWriter.Write(uiText.text);
|
|
}
|
|
yield return new WaitForSeconds(1f);
|
|
uiText.text += "\n///////////////////////////////////// API TEST DONE /////////////////////////////////////////\n\n";
|
|
apiTestRunning = false;
|
|
}
|
|
}
|
|
|
|
private void EmitWithID(string eventName, string jsonData, bool dataIsPlainText)
|
|
{
|
|
string text = jsonData;
|
|
try
|
|
{
|
|
JObject jObject = JObject.Parse(jsonData);
|
|
jObject["SOC_EV_ID"] = socketEventID;
|
|
text = jObject.ToString(Formatting.None);
|
|
}
|
|
catch
|
|
{
|
|
text = jsonData;
|
|
}
|
|
socket.Instance.Emit(eventName, text, dataIsPlainText);
|
|
socketEventID++;
|
|
if (socketEventID >= 10000)
|
|
{
|
|
socketEventID = 0;
|
|
}
|
|
}
|
|
}
|