IEnumerator WaitForRequest(WWW www)
{
yield return(www);
PlayerPackage newPlayer = new PlayerPackage();
// check for errors
if (www.error == null)
{
Debug.Log("WWW Ok!: " + www.text);
newPlayer = JsonUtility.FromJson <PlayerPackage>(www.text);
Debug.Log("Player Username " + newPlayer.playerUsername);
Debug.Log("Player Score " + newPlayer.score);
Debug.Log("Player Badges " + newPlayer.badges);
Debug.Log("Player Key Cards " + newPlayer.keyCards);
Debug.Log("Player Num Qs Correct " + newPlayer.numOfCorrectQuestions);
PlayerPrefs.SetString("identity", newPlayer.playerUsername);
PlayerPrefs.SetInt("Score", newPlayer.score);
PlayerPrefs.SetString("badges", newPlayer.badges);
PlayerPrefs.SetString("keyCards", newPlayer.keyCards);
PlayerPrefs.SetInt("NumQuestionsCorrect", newPlayer.numOfCorrectQuestions);
SceneManager.LoadScene("Elevator");
}
else
{
Debug.Log("WWW Error: " + www.error);
}
}
// Use this for initialization
void Start()
{
string url = "http://172.23.28.228/hackheist/updateGameInformation.php";
PlayerPackage player = new PlayerPackage();
player.playerUsername = PlayerPrefs.GetString("identity");
char[] allKeys = PlayerPrefs.GetString("keyCards").ToCharArray();
char[] allBadges = PlayerPrefs.GetString("badges").ToCharArray();
int BadgeValue = (100 * (allBadges[0] + allBadges[1] + allBadges[2] + allBadges[3] + allBadges[4] + allBadges[5] + allBadges[6]));
int KeyCardValue = (10 * (allKeys[0] + allKeys[1] + allKeys[2] + allKeys[3] + allKeys[4] + allKeys[5] + allKeys[6]));
int ScoreValue = PlayerPrefs.GetInt("NumQuestionsCorrect") + BadgeValue + KeyCardValue;
PlayerPrefs.SetInt("Score", ScoreValue);
ScoreText.text = ScoreValue.ToString();
player.score = PlayerPrefs.GetInt("Score");
player.numOfCorrectQuestions = PlayerPrefs.GetInt("NumQuestionsCorrect");
player.keyCards = PlayerPrefs.GetString("keyCards");
player.badges = PlayerPrefs.GetString("badges");
string json = JsonUtility.ToJson(player);
print(json);
UnityEngine.Networking.UnityWebRequest www = UnityEngine.Networking.UnityWebRequest.Put(url, json);
www.SetRequestHeader("Content-Type", "application/json");
www.SendWebRequest();
}
// Use this for initialization
void Start()
{
string url = "http://172.23.28.228/hackheist/getSingleUserGameInfo.php";
PlayerPackage player = new PlayerPackage();
player.playerUsername = PlayerPrefs.GetString("identity");
player.score = 0;
player.numOfCorrectQuestions = 0;
player.keyCards = "";
player.badges = "";
string json = JsonUtility.ToJson(player);
print(json);
Hashtable postHeader = new Hashtable();
postHeader.Add("Content-Type", "application/json");
// convert json string to byte
var formData = System.Text.Encoding.UTF8.GetBytes(json);
var www = new WWW(url, formData, postHeader);
// Gavin there is a warning that says -- `UnityEngine.WWW.WWW(string, byte[], System.Collections.Hashtable)'
// is obsolete: `This overload is deprecated. Use UnityEngine.WWW.WWW(string, byte[],
// System.Collections.Generic.Dictionary<string, string>) instead.'
StartCoroutine(WaitForRequest(www));
}
public static void InstallPackage(PackageStatusContext context)
{
IPackage package = null;
switch (InstallationContext.PackageType)
{
case PackageType.DeveloperFull:
package = new DeveloperFullPackage();
break;
case PackageType.DeveloperLite:
package = new DeveloperLitePackage();
break;
case PackageType.Player:
package = new PlayerPackage();
break;
}
if (package == null)
{
throw new Exception("Unknown Package Type");
}
package.Install(context);
}
public UserData(DHero hero, PlayerPackage package, int gold, int coin)
{
Hero = hero;
Package = package;
Gold = gold;
Coin = coin;
IsChanged = false;
IsEquipChanged = false;
LastAccessTime = DateTime.Now;
}
private void GetPlayerData(G2C_Login result)
{
//Result = result;
Coin = result.Coin;
Gold = result.Gold;
hero = result.Hero;
package = result.Package;
operat = SceneManager.LoadSceneAsync("Main");
//data
//UUIManager.Singleton.ShowMask(false);
}
public void RevertPackage()
{
if (goldTemp < 0 || coinTemp <= 0 || packagetemp == null)
{
return;
}
Package = packagetemp;
Gold = goldTemp;
Coin = coinTemp;
ClearRecord();
}
private PlayerPackage GetCompletedPackage()
{
var result = new PlayerPackage();
lock (syncRoot)
{
foreach (var i in Package.Items)
{
result.Items.Add(i);
result.MaxSize = Package.MaxSize;
}
}
return(result);
}
public static PlayerPackage GetPackageFromTbPlayer(DataBaseContext.TBGAmePlayer player, DataBaseContext.TBPLayerEquip equip)
{
var package = new PlayerPackage {
MaxSize = player.PackageSize
};
//玩家道具列表
if (!string.IsNullOrEmpty(player.UserPackage))
{
package.Items = JsonTool.Deserialize <List <PlayerItem> >(player.UserPackage);
}
if (equip != null)
{
if (!string.IsNullOrEmpty(equip.UserEquipValues))
{
package.Equips = JsonTool.Deserialize <List <Equip> >(equip.UserEquipValues);
}
}
return(package);
}
public void RecordPackage()
{
goldTemp = Gold;
coinTemp = Coin;
byte[] data;
using (var mem = new MemoryStream())
{
using (var bw = new BinaryWriter(mem))
{
Package.ToBinary(bw);
}
data = mem.ToArray();
}
using (var mem = new MemoryStream(data))
{
using (var br = new BinaryReader(mem))
{
packagetemp = new PlayerPackage();
packagetemp.ParseFormBinary(br);
}
}
}
public void SetPackage(PlayerPackage package)
{
Package = package;
CurrentSize = package.Items.Count;
}
public async Task <IActionResult> EndGame(string playerid, string playerdata)
{
try
{
if (!PlayerManager.IsActive)
{
return new ContentResult {
StatusCode = 500, Content = "Service is still starting up. Please retry."
}
}
;
// Get newer game data from the active room
Player player = JsonConvert.DeserializeObject <Player>(playerdata);
IReliableDictionary <string, PlayerPackage> playdict =
await this.stateManager.GetOrAddAsync <IReliableDictionary <string, PlayerPackage> >(PlayersDictionaryName);
using (ITransaction tx = this.stateManager.CreateTransaction())
{
ConditionalValue <PlayerPackage> playerOption = await playdict.TryGetValueAsync(tx, playerid, LockMode.Update);
if (!playerOption.HasValue)
{
// Tried to end game for a player that isn't here. This is a fail state.
await tx.CommitAsync();
return(new ContentResult {
StatusCode = 500, Content = "Cannot log out a player not in this system. Check partition."
});
}
// Player says already logged out, this means the last log in attempt was successful, but the return message never got back to
// room manager or it failed to remove the player.
if (playerOption.Value.State == LogState.LoggedOut)
{
await tx.CommitAsync();
return(new ContentResult {
StatusCode = 200
});
}
//The normal functionality, update the player and return a success
if (playerOption.Value.State == LogState.LoggedIn)
{
PlayerPackage newPlayerPackage = playerOption.Value;
newPlayerPackage.Player = player;
newPlayerPackage.State = LogState.LoggedOut;
await playdict.SetAsync(tx, playerid, newPlayerPackage);
await tx.CommitAsync();
return(new ContentResult {
StatusCode = 200
});
}
await tx.CommitAsync();
Environment.FailFast("Player must have one of the above states: doesn't exist, loggedin, or loggedout.");
return(new ContentResult {
StatusCode = 500
});
}
}
catch (Exception e)
{
return(exceptionHandler(e));
}
}
public async Task <IActionResult> NewGame(string playerid, string roomid, string roomtype)
{
try
{
if (!PlayerManager.IsActive)
{
return new ContentResult {
StatusCode = 500, Content = "Service is still starting up. Please retry."
}
}
;
IReliableDictionary <string, PlayerPackage> playdict =
await this.stateManager.GetOrAddAsync <IReliableDictionary <string, PlayerPackage> >(PlayersDictionaryName);
PlayerPackage playerPackage; //for handing up player information if login is needed in scenario 2
using (ITransaction tx = this.stateManager.CreateTransaction())
{
ConditionalValue <PlayerPackage> playerOption = await playdict.TryGetValueAsync(tx, playerid, LockMode.Update);
/////////////////////////////////////////////////
// SCENARIO 1: PLAYER DOES NOT HAVE AN ACCOUNT //
/////////////////////////////////////////////////
if (!playerOption.HasValue)
{
//State: Player does not exist / Cannot be in a game
Random rand = new Random(Environment.TickCount);
//Generate a new player with a random position
Player newPlayer = new Player(
rand.Next() % 100 - 6,
rand.Next() % 96 - 6,
this.startingColors[rand.Next() % this.startingColors.Length]);
//Package the new player with its baseline statistics
PlayerPackage newPlayerPackage = new PlayerPackage(newPlayer, LogState.LoggedIn, 1, DateTime.UtcNow, roomid);
await playdict.AddAsync(tx, playerid, newPlayerPackage);
await tx.CommitAsync();
return(await this.NewGameRequestHelper(roomid, playerid, roomtype, newPlayer));
}
//////////////////////////////////////////////////////
// SCENARIO 2: PLAYER HAS ACCOUNT AND IS LOGGED OUT //
//////////////////////////////////////////////////////
if (playerOption.Value.State == LogState.LoggedOut)
{
/*
* Scenario: We think player is logged out (LO-N), in which case this is normal functionality.
* The state could also be (LO-LI), which could happen if an EndGame failed halfway through.
* If this is the case, there are two scenarios: The first is that the room we are about to log into was
* the room that failed to log out, in which case we will override that data since we have the most updated
* data and the situation is resolved. The second case is that we are trying to log into a different room.
* In this case we trust that the protocol has removed that clients access to the player, which means the
* player will eventually be cleaned up by the timeout, keeping the game consistent.
*/
//Grab our player data and update the package
PlayerPackage updatedPlayerPackage = playerOption.Value;
updatedPlayerPackage.State = LogState.LoggedIn;
updatedPlayerPackage.RoomId = roomid;
updatedPlayerPackage.NumLogins++;
await playdict.SetAsync(tx, playerid, updatedPlayerPackage);
//finish our transaction
await tx.CommitAsync();
// Request a newgame in the room we want to join
return(await this.NewGameRequestHelper(roomid, playerid, roomtype, playerOption.Value.Player));
}
await tx.CommitAsync();
playerPackage = playerOption.Value;
} // end of tx
/////////////////////////////////////////////////////
// SCENARIO 3: PLAYER HAS ACCOUNT AND IS LOGGED IN //
/////////////////////////////////////////////////////
if (playerPackage.State == LogState.LoggedIn)
{
// Scenario: This state will generally be the success state, where the player thinks they are logged in and the
// appropriate room has the game. However, during login, it is possible that the process crashed between the time
// that the login transaction marked the data as logged in and that data being put in the room. We must check to
// verify that this is not the state we are in.
int key = Partitioners.GetRoomPartition(playerPackage.RoomId);
// We first ask if the room has the data to determine which of the above states we are in.
string url = this.proxy + $"Exists/?playerid={playerid}&roomid={playerPackage.RoomId}&PartitionKind=Int64Range&PartitionKey={key}";
HttpResponseMessage response = await this.httpClient.GetAsync(url);
if ((int)response.StatusCode == 404)
{
this.RenewProxy();
url = this.proxy + $"Exists/?playerid={playerid}&roomid={playerPackage.RoomId}&PartitionKind=Int64Range&PartitionKey={key}";
response = await this.httpClient.GetAsync(url);
}
string responseMessage = await response.Content.ReadAsStringAsync();
if ((int)response.StatusCode == 200)
{
//Player is logged in, so we must deny this request
if (responseMessage == "true")
{
return new ContentResult {
StatusCode = 400, Content = "This player is already logged in"
}
}
;
//Player is not logged in, so we can log into whichever room we want
if (responseMessage == "false")
{
using (ITransaction tx1 = this.stateManager.CreateTransaction())
{
playerPackage.RoomId = roomid;
playerPackage.NumLogins++;
await playdict.SetAsync(tx1, playerid, playerPackage);
await tx1.CommitAsync();
}
return(await this.NewGameRequestHelper(roomid, playerid, roomtype, playerPackage.Player));
}
Environment.FailFast("If returning a success code, the message must be either true or false.");
}
else
{
return(new ContentResult {
StatusCode = 500, Content = "Something went wrong, please retry"
});
}
}
Environment.FailFast("Players must exist with a valid state attached to them");
return(new ContentResult {
StatusCode = 500
});
}
catch (Exception e)
{
return(exceptionHandler(e));
}
}
public static void RegisterPlayer(PlayerPackage player)
{
client.RegisterPlayer(player);
}
public void ClearRecord()
{
packagetemp = null;
goldTemp = -1;
coinTemp = -1;
}
