private void GetFashionModelAvatars(ServerAccount serverAccount, Guid sessionId, Action <List <object> > returnFunc)
{
// Get the local avatar assets
AvatarManagerServiceAPI.GetAvatarForUser(serverAccount, delegate(XmlDocument localAvatarXml)
{
List <object> responseData = new List <object>();
XmlElement avatarNode = (XmlElement)localAvatarXml.SelectSingleNode("//Avatar");
XmlAttribute localAvatarAttrib = localAvatarXml.CreateAttribute("LocalAvatar");
localAvatarAttrib.InnerText = "true";
avatarNode.Attributes.Append(localAvatarAttrib);
ReplaceItemIdsWithDna(avatarNode);
AddFacebookData
(
avatarNode,
new FacebookFriendInfo
(
serverAccount.AccountId,
serverAccount.FacebookAccountId,
serverAccount.Nickname,
"",
""
)
);
responseData.Add(avatarNode.OuterXml);
FashionMinigameServiceAPI.GetHiredFriendsForJob(serverAccount, Jobs.Model, delegate(ICollection <long> hiredFriendIds)
{
ProcessHiredFriends(serverAccount, returnFunc, responseData, hiredFriendIds);
});
});
}
private void GetPlayerGameData(Message message, Guid sessionId)
{
mLogger.Debug("GetPlayerGameData: " + message.ToString());
if (message.Data.Count < 2)
{
mLogger.Error("Dropping Message (" + message + "), expected Data to be Count == 2, actual was " + message.Data.Count);
return;
}
string callbackId = CheckType.TryAssignType <string>(message.Data[0]);
string dataKey = CheckType.TryAssignType <string>(message.Data[1]);
ServerAccount serverAccount = mServerStateMachine.SessionManager.GetServerAccountFromSessionId(sessionId);
mLogger.Debug("GetGameData: SENT");
FashionMinigameServiceAPI.GetGameData(serverAccount, dataKey, delegate(XmlDocument resultXml)
{
mLogger.Debug("GetGameData: RECEIVED");
Message responseMessage = new Message();
List <object> responseData = new List <object>();
responseData.Add(callbackId);
responseData.Add(resultXml.OuterXml);
responseMessage.FashionGameGetData(responseData);
SendMessageToClient(responseMessage, sessionId);
});
}
private void GetAvatarsForJob(Message message, Guid sessionId)
{
mLogger.Debug("GetAvatarsForJob: " + message.ToString());
if (message.Data.Count < 2)
{
mLogger.Error("Dropping Message (" + message + "), expected Data to be Count == 3, actual was " + message.Data.Count);
return;
}
Jobs avatarJob = (Jobs)Enum.Parse(typeof(Jobs), message.Data[1].ToString());
ServerAccount localUserServerAccount = mServerStateMachine.SessionManager.GetServerAccountFromSessionId(sessionId);
Action <List <object> > returnFunc = delegate(List <object> resultData)
{
Message responseMessage = new Message();
resultData.Insert(0, message.Data[0]); // callbackId
resultData.Insert(1, avatarJob.ToString());
responseMessage.FashionGameModelAssetMessage(resultData);
SendMessageToClient(responseMessage, sessionId);
};
if (avatarJob == Jobs.Model)
{
// Model is the same as other jobs, but it also has a listing for the local user's avatar
GetFashionModelAvatars(localUserServerAccount, sessionId, returnFunc);
}
else
{
FashionMinigameServiceAPI.GetHiredFriendsForJob(localUserServerAccount, avatarJob, delegate(ICollection <long> hiredFriendIds)
{
ProcessHiredFriends(localUserServerAccount, returnFunc, new List <object>(), hiredFriendIds);
});
}
}
/// <summary>
/// Calculates all the parameters required to call Energy.CalculateCurrentEnergy
/// </summary>
/// <param name="serverAccount"></param>
/// <param name="result">returns (float lastEnergy, float maxEnergy, DateTime rechargeDate)</param>
public void GetCurrentEnergyData(ServerAccount serverAccount, Action <float, float, DateTime> result)
{
FashionMinigameServiceAPI.GetGameData
(
serverAccount,
new string[] { PLAYER_ENERGY_KEY, ENERGY_REGEN_DATE, PLAYER_MAX_ENERGY },
delegate(XmlDocument resultXml)
{
string playerEnergyData = null;
string energyRegenDateData = null;
string playerMaxEnergyData = null;
foreach (XmlNode dataNode in resultXml.SelectNodes("//DataKey"))
{
switch (dataNode.Attributes["KeyName"].InnerText)
{
case PLAYER_ENERGY_KEY:
playerEnergyData = dataNode.InnerText;
break;
case ENERGY_REGEN_DATE:
energyRegenDateData = dataNode.InnerText;
break;
case PLAYER_MAX_ENERGY:
playerMaxEnergyData = dataNode.InnerText;
break;
default:
throw new Exception("Error in FashionMinigameServiceAPI.GetGameData, result XML has an unexpected key: " + dataNode.Attributes["KeyName"].InnerText + "\nXML:\n" + resultXml.OuterXml);
}
}
if (playerMaxEnergyData == null)
{
SetMaxEnergy(serverAccount, INITIAL_MAX_ENERGY);
playerMaxEnergyData = INITIAL_MAX_ENERGY.ToString();
}
if (energyRegenDateData == null)
{
SetEnergyRegenDate(serverAccount, DateTime.UtcNow);
energyRegenDateData = DateTime.UtcNow.ToString();
}
if (playerEnergyData == null)
{
SetEnergy(serverAccount, INITIAL_MAX_ENERGY);
playerEnergyData = playerMaxEnergyData;
}
float lastEnergy = float.Parse(playerEnergyData);
float maxEnergy = float.Parse(playerMaxEnergyData);
DateTime lastUpdate = DateTime.Parse(energyRegenDateData);
result(lastEnergy, maxEnergy, lastUpdate);
}
);
}
/// <summary>
/// Saves a friend as hired for the provided job and then returns that friend's avatar's DNA to the client
/// </summary>
/// <param name="message"></param>
private void HireFriend(Message message, Guid sessionId)
{
mLogger.Debug("HireFriend: " + message.ToString());
if (message.Data.Count != 3)
{
mLogger.Error("Dropping Message (" + message + "), expected Data to be Count == 4, actual was " + message.Data.Count);
return;
}
long facebookId;
if (!long.TryParse(message.Data[1].ToString(), out facebookId))
{
mLogger.Error("Dropping Message (" + message + "), expected Data[1] to be able to parse to long. Value: " + message.Data[1]);
return;
}
Jobs job = (Jobs)Enum.Parse(typeof(Jobs), message.Data[2].ToString());
string jobName = job.ToString();
ServerAccount serverAccount = mServerStateMachine.SessionManager.GetServerAccountFromSessionId(sessionId);
FashionMinigameServiceAPI.GetGameData(serverAccount, jobName, delegate(XmlDocument resultXml)
{
XmlNode hiredFriendsListNode = resultXml.SelectSingleNode
(
"//DataKey[@KeyName='" + jobName + "']"
);
string dataValue;
if (hiredFriendsListNode == null)
{
dataValue = facebookId.ToString();
}
else
{
dataValue = String.Format("{0},{1}", hiredFriendsListNode.InnerText, facebookId.ToString());
}
FashionMinigameServiceAPI.SetGameData(serverAccount, jobName, dataValue, delegate(XmlDocument responseXml)
{
VerifySuccess(responseXml);
Action <List <object> > returnHiredFriend = delegate(List <object> responseData)
{
Message responseMessage = new Message();
responseData.Insert(0, message.Data[0]); // callback Id
responseData.Insert(1, jobName);
responseMessage.FashionGameHireFriend(responseData);
SendMessageToClient(responseMessage, sessionId);
};
ProcessHiredFriends(serverAccount, returnHiredFriend, new List <object>(), new long[] { facebookId });
});
});
}
private void BuildFashionGameLoadingInfo(Message message, Guid sessionId)
{
mLogger.Debug("BuildFashionGameLoadingInfo: " + message.ToString());
if (message.Data.Count < 1)
{
mLogger.Error("Dropping Message (" + message + "), expected Data to be Count == 2, actual was " + message.Data.Count);
return;
}
// TODO: Hard coded values
XmlDocument modelDefaultsXml = mServerStateMachine.ServerAssetRepository.GetXmlDna(new ItemId[] { new ItemId(135u), new ItemId(136u), new ItemId(137u) });
// TODO: Replace these items with the real station worker defaults
XmlDocument stationWorkerDefaultsXml = mServerStateMachine.ServerAssetRepository.GetXmlDna(new ItemId[] { new ItemId(240u), new ItemId(244u) });
ServerAccount localUserServerAccount = mServerStateMachine.SessionManager.GetServerAccountFromSessionId(sessionId);
mEnergyManager.GetCurrentEnergyData(localUserServerAccount, delegate(float lastEnergy, float maxEnergy, DateTime lastUpdate)
{
FashionMinigameServiceAPI.GetGameData(localUserServerAccount, GameDataKeys.PLAYER_EXPERIENCE_KEY, delegate(XmlDocument resultXml)
{
XmlNode minigameUserDataNode = resultXml.SelectSingleNode("MiniGameUserData");
if (minigameUserDataNode == null)
{
throw new Exception("The server is returning playerData in an unexpected format: " + resultXml.OuterXml);
}
XmlNode xpNode = minigameUserDataNode.SelectSingleNode("//DataKey[@KeyName='" + GameDataKeys.PLAYER_EXPERIENCE_KEY + "']");
string xpString;
if (xpNode != null)
{
xpString = xpNode.InnerText;
}
else // No experience node, this is a new user
{
xpString = "0";
}
Message responseMessage = new Message();
List <object> responseData = new List <object>();
responseData.Add(message.Data[0]); // callback Id
responseData.Add(modelDefaultsXml.OuterXml);
responseData.Add(stationWorkerDefaultsXml.OuterXml);
responseData.Add(lastEnergy);
responseData.Add(maxEnergy);
responseData.Add(lastUpdate.ToString());
responseData.Add(uint.Parse(xpString));
responseData.Add((uint)localUserServerAccount.EntourageSize);
responseMessage.FashionGameLoadingInfoMessage(responseData);
SendMessageToClient(responseMessage, sessionId);
});
});
}
/// <summary>
/// Give coins to friends who were hired in this show.
/// These coins are stored in the db in the escrow table until the friend logs in next time.
/// </summary>
/// <param name="serverAccount"></param>
/// <param name="coins"></param>
public static void GiveFashionMinigameHiredFriendsCoins(ServerAccount serverAccount, int coins)
{
if (coins <= 0)
{
// No coins to give, done.
return;
}
FashionMinigameServiceAPI.GetAllHiredFriends(serverAccount, delegate(ICollection <long> friendList)
{
EscrowManagerServiceAPI.CreateEscrowTransaction(friendList, serverAccount.FacebookAccountId, EscrowType.FashionCityJobCoins.ToString(), coins, VerifyGiveCoinSuccess);
});
}
private void SetPlayerGameData(Message message, Guid sessionId)
{
mLogger.Debug("SetPlayerGameData: " + message.ToString());
if (message.Data.Count < 2)
{
mLogger.Error("Dropping Message (" + message + "), expected Data to be Count == 3, actual was " + message.Data.Count);
return;
}
string dataKey = CheckType.TryAssignType <string>(message.Data[0]);
string dataValue = CheckType.TryAssignType <string>(message.Data[1]);
ServerAccount serverAccount = mServerStateMachine.SessionManager.GetServerAccountFromSessionId(sessionId);
FashionMinigameServiceAPI.SetGameData(serverAccount, dataKey, dataValue, VerifySuccess);
}
public void FacebookFriendsReady(ServerAccount serverAccount, Guid sessionId)
{
try
{
if (serverAccount.FacebookFriendsRequested)
{
mLogger.Debug("FacebookFriendsReady: " + serverAccount.AccountId.ToString());
serverAccount.FacebookFriendsRequested = false;
IDictionary <long, FacebookFriendInfo> possibleHires = new Dictionary <long, FacebookFriendInfo>(serverAccount.FacebookFriendsLookupTable);
FashionMinigameServiceAPI.GetAllHiredFriends(serverAccount, delegate(ICollection <long> hiredFriendIds)
{
// Filter out any users that have already been hired
foreach (long facebookId in hiredFriendIds)
{
possibleHires.Remove(facebookId);
}
Message responseMessage = new Message();
List <object> responseData = new List <object>();
responseData.Add(serverAccount.FacebookFriendsReadyCallbackId); // callback Id
if (possibleHires.Count == 0)
{
responseData.Add(false);
}
else
{
responseData.Add(possibleHires);
}
responseMessage.FashionGameFriendsToHire(responseData);
SendMessageToClient(responseMessage, sessionId);
});
}
}
catch (System.Exception ex)
{
StateServerAssert.Assert(new Exception("Something went wrong with sending the facebook friends to the client.", ex));
}
}
/// <summary>
/// On level up, the user gains a little more max energy and their energy is refilled
/// </summary>
public void UserLeveledUp(ServerAccount account)
{
GetCurrentEnergyData(account, delegate(float energy, float maxEnergy, DateTime rechargeDate)
{
// not worried about this silly chain of messages because the client isn't waiting on it
float newMaxEnergy = maxEnergy + Energy.MAX_ENERGY_INCREASE_PER_LEVEL;
FashionMinigameServiceAPI.SetGameData(account, PLAYER_MAX_ENERGY, newMaxEnergy,
delegate(XmlDocument maxEnergyResult)
{
FashionMinigameServer.VerifySuccess(maxEnergyResult);
FashionMinigameServiceAPI.SetGameData(account, ENERGY_REGEN_DATE, DateTime.UtcNow,
delegate(XmlDocument dateResult)
{
FashionMinigameServer.VerifySuccess(dateResult);
FashionMinigameServiceAPI.SetGameData(account, PLAYER_ENERGY_KEY, newMaxEnergy.ToString(),
delegate(XmlDocument currentEnergyResult)
{
FashionMinigameServer.VerifySuccess(currentEnergyResult);
});
});
});
});
}
/// <summary>
/// Directly sets the amount of energy in the database without any bounds or other safety checks.
/// Only to be used on values after they've been verified
/// </summary>
private void SetEnergy(ServerAccount account, float energy)
{
FashionMinigameServiceAPI.SetGameData(account, PLAYER_ENERGY_KEY, energy.ToString(), FashionMinigameServer.VerifySuccess);
}
private void SetEnergyRegenDate(ServerAccount account, DateTime time)
{
FashionMinigameServiceAPI.SetGameData(account, ENERGY_REGEN_DATE, time.ToString(), FashionMinigameServer.VerifySuccess);
}
private void GetAllHiredAvatars(Message message, Guid sessionId)
{
ServerAccount localUserServerAccount = mServerStateMachine.SessionManager.GetServerAccountFromSessionId(sessionId);
AvatarManagerServiceAPI.GetAvatarForUser(localUserServerAccount, delegate(XmlDocument localAvatarXml)
{
FashionMinigameServiceAPI.GetAllHiredFriends(localUserServerAccount, delegate(XmlDocument hiredFriendsXml)
{
Dictionary <long, Jobs> friendFbIds = Functionals.Reduce <Dictionary <long, Jobs> >
(
delegate(Dictionary <long, Jobs> accumulator, object friendIdNode)
{
XmlNode friendNode = (XmlNode)friendIdNode;
foreach (string idText in friendNode.InnerText.Split(','))
{
accumulator.Add(long.Parse(idText), (Jobs)Enum.Parse(typeof(Jobs), friendNode.SelectSingleNode("@KeyName").InnerText));
}
return(accumulator);
},
hiredFriendsXml.SelectNodes("//DataKey")
);
List <object> resultData = new List <object>();
XmlNode localAvatarNode = localAvatarXml.SelectSingleNode("//Avatar");
XmlAttribute fbidAttrib = localAvatarXml.CreateAttribute("FBID");
fbidAttrib.InnerText = localUserServerAccount.FacebookAccountId.ToString();
localAvatarNode.Attributes.Append(fbidAttrib);
XmlAttribute firstnameAttrib = localAvatarXml.CreateAttribute("FirstName");
firstnameAttrib.InnerText = localUserServerAccount.Nickname;
localAvatarNode.Attributes.Append(firstnameAttrib);
XmlAttribute lastnameAttrib = localAvatarXml.CreateAttribute("LastName");
lastnameAttrib.InnerText = "";
localAvatarNode.Attributes.Append(lastnameAttrib);
resultData.Add(localAvatarXml.OuterXml);
ProcessHiredFriends
(
localUserServerAccount,
delegate(List <object> messageData)
{
friendFbIds.Add(localUserServerAccount.FacebookAccountId, Jobs.Model);
Message responseMessage = new Message();
List <object> responseData = new List <object>();
responseData.Insert(0, message.Data[0]); // callbackId
// Build asset lists for all the avatars and add minigame data
foreach (XmlDocument avatarXml in MessageUtil.GetXmlDocumentsFromMessageData(messageData))
{
XmlNode avatarNode = avatarXml.SelectSingleNode("//Avatar");
ReplaceItemIdsWithDna((XmlElement)avatarNode);
// The job name will be the DataKey the FBID was stored under
XmlAttribute avatarJobAttrib = avatarXml.CreateAttribute("job");
long fbid = long.Parse(avatarNode.SelectSingleNode("@FBID").InnerText);
Jobs friendJob;
if (friendFbIds.TryGetValue(fbid, out friendJob))
{
avatarJobAttrib.InnerText = friendJob.ToString();
}
else if (fbid == 0) // Unknown user
{
}
else
{
string errorMessage = "Unable to find job info for FBID: " + fbid;
mLogger.Error(errorMessage);
avatarJobAttrib.InnerText = errorMessage;
}
avatarNode.Attributes.Append(avatarJobAttrib);
responseData.Add(avatarNode.OuterXml);
}
responseMessage.FashionGameModelAssetMessage(responseData);
SendMessageToClient(responseMessage, sessionId);
},
resultData,
friendFbIds.Keys
);
});
});
}
private void SetLevelComplete(Message message, Guid sessionId)
{
mLogger.Debug("SetLevelComplete: " + message.ToString());
if (message.Data.Count < 4)
{
mLogger.Error("Dropping Message (" + message + "), expected Data to be Count == 3, actual was " + message.Data.Count);
return;
}
int totalXP = CheckType.TryAssignType <int>(message.Data[1]);
int XPEarnedOnThisLevel = CheckType.TryAssignType <int>(message.Data[2]);
bool leveledUp = CheckType.TryAssignType <bool>(message.Data[3]);
ServerAccount serverAccount = mServerStateMachine.SessionManager.GetServerAccountFromSessionId(sessionId);
// Save experience to the database
FashionMinigameServiceAPI.SetGameData(serverAccount, GameDataKeys.PLAYER_EXPERIENCE_KEY, totalXP.ToString(), VerifySuccess);
// Reward coins for experience
int coinsEarned = Rewards.GetCoinsFromExperience(XPEarnedOnThisLevel);
NameValueCollection args = new NameValueCollection();
args.Add("userId", mServerStateMachine.PaymentItemsManager.GetPaymentItemsUserId(sessionId));
args.Add("amount", coinsEarned.ToString());
args.Add("ipAddress", mServerStateMachine.ServerMessageProcessor.ServerReflector.GetClientIPAddress(sessionId));
PaymentItemsProcessClientMessage clientMessage = new PaymentItemsProcessClientMessage();
PaymentCommand cmd = clientMessage.AddVirtualCoinForUser(args);
mServerStateMachine.PaymentItemsManager.ProcessPaymentCommand(cmd, delegate(string response)
{
XmlDocument xmlResponse = new XmlDocument();
xmlResponse.LoadXml(response);
mLogger.Debug("SetLevelComplete success: " + response);
XmlElement vcoinNode = (XmlElement)xmlResponse.SelectSingleNode("//accounts/account[@currencyName='VCOIN']");
// Convert to double, cast to int and then back to string to strip off decimal points
string totalCoins = String.Empty;
if (vcoinNode != null)
{
totalCoins = ((int)Double.Parse(vcoinNode.GetAttribute("balance"))).ToString();
}
Hangout.Shared.Action resultMessage = delegate()
{
// Return a message to the user with the results of SetLevelComplete
List <object> data = new List <object>();
data.Add(message.Data[0]); // callback id
data.Add(coinsEarned.ToString());
data.Add(totalCoins);
Message responseMessage = new Message(MessageType.FashionMinigame, data);
SendMessageToClient(responseMessage, sessionId);
};
});
// Award friends a fraction of earned coins for working in this show
int friendEscrowCoins = Rewards.GetFriendCoins(XPEarnedOnThisLevel, serverAccount.EntourageSize);
if (friendEscrowCoins > 0)
{
EscrowManager.GiveFashionMinigameHiredFriendsCoins(serverAccount, friendEscrowCoins);
}
if (leveledUp)
{
mEnergyManager.UserLeveledUp(serverAccount);
}
}
