private void SendShopMessage(Message rtn, CommonPlayer player, bool refresh)
{
rtn.Add(refresh, player.Energy, player.SecondsToNextEnergy, player.MaxEnergy, player.EnergyDelay);
if (this.CanUseShop(player, true))
{
foreach (var item in this.Items.Where(it => it.Enabled))
{
rtn.Add(item.Key,
item.PriceEnergy,
item.EnergyPerClick,
this.GetEnergyStatus(item.Key),
item.PriceCoins,
this.GetCount(item),
item.Title,
item.Description,
item.BitmapOffset,
item.OnSale,
item.IsFeatured,
item.IsNew,
item.MaxPurchases > 0,
item.MaxPurchases,
!this.CanBuy(item, player),
item.Label,
item.LabelColor);
}
}
player.Send(rtn);
}
// Use this for initialization
void Start()
{
_btn = GetComponent <Button>();
_btn.onClick.AddListener(OnClick);
_player = ObjectManager.GetInstance().GetPlayer(1);
//Idle.onClick.AddListener(OnClickIdle);
GameObject pGo = GameObject.Find("Plane");
new InputMouseController(pGo.transform).ClickEvent += OnClickIdle;
}
private bool CanUseShop(CommonPlayer player, bool ignoreEnergy = false)
{
if (!ignoreEnergy && this.crew.GetRankId(player) != 0 && player.MaxEnergy < 260)
{
return(false);
}
return(this.crew.HasPower(player, CrewPower.ShopAccess) &&
!player.IsBanned && !player.IsTempBanned);
}
private void AwardWorldRewards(CommonPlayer player, CampaignWorld world, Shop shop)
{
foreach (var reward in world.Rewards)
{
switch (reward.Key)
{
case "maxEnergy":
player.MaxEnergy += (int)reward.Value;
Console.WriteLine("Rewarded {0} with +{1} maximum energy.", player.Name, reward.Value);
break;
case "energy":
player.AddEnergy((int)reward.Value);
Console.WriteLine("Rewarded {0} with +{1} energy.", player.Name, reward.Value);
break;
case "energyRefill":
player.RefillEnergy();
Console.WriteLine("Rewarded {0} with energy refill.", player.Name);
break;
case "gems":
var amount = reward.Value;
player.PayVault.Credit(amount, "Completing " + this.Data.Title + " campaign",
delegate { Console.WriteLine("Rewarded {0} with {1} gems.", player.Name, amount); });
break;
default:
var item = shop.GetShopItem(reward.Key);
if (item != null && item.Key == reward.Key && (!player.PayVault.Has(item.Key) || item.Reusable))
{
var count = item.Reusable ? reward.Value : 1;
var items = new BuyItemInfo[count];
for (var i = 0; i < items.Length; i++)
{
items[i] = new BuyItemInfo(item.Key);
}
player.PayVault.Give(items,
delegate
{
Console.WriteLine("Rewarded {0} with {1} x{2}.", player.Name, item.Key, count);
});
}
break;
}
}
}
private bool AuraPayVaultIsLegit(CommonPlayer player, string payVaultId, Shop shop)
{
if (payVaultId == null)
{
return(false);
}
if (payVaultId == "" || payVaultId == "goldmember" /* && player.HasGoldMembership*/)
{
return(true);
}
var shopItem = shop.GetShopItem(payVaultId);
return(shopItem != null); /*&& player.PayVault.Has(payVaultId);*/
}
private void AnswerInvitation(string senderName, bool accept, Callback <string> successCallback,
Callback <InvitationError> errorCallback)
{
InvitationHelper.GetInvitation(this.client.BigDB, InvitationType.Friend,
senderName, this.name, invitation =>
{
if (!invitation.Exists)
{
errorCallback(InvitationError.InvitationNotFound);
return;
}
CommonPlayer.GetId(this.client.BigDB, senderName, senderId =>
{
if (senderId == null)
{
InvitationHelper.DeleteInvitation(this.client.BigDB, InvitationType.Friend, senderName,
this.name, result =>
errorCallback(InvitationError.PlayerNotFound));
return;
}
this.GetFriendsCount(numFriends =>
{
if (accept)
{
if (numFriends >= this.MaxFriendsAllowed)
{
errorCallback(InvitationError.LimitReached);
return;
}
invitation.Status = InvitationStatus.Accepted;
this.AddOrRemoveFriend(senderId, true);
}
else
{
invitation.Status = InvitationStatus.Rejected;
}
invitation.Save(() => successCallback(senderId));
});
});
});
}
/// <summary>
/// 创建一个玩家
/// </summary>
/// <param name="pData"></param>
/// <returns></returns>
public CommonPlayer CreatePlayer(PlayerData pData)
{
if (_playerList.ContainsKey(pData.Guid))
{
LogManager.Error("duplicate player, guid:" + pData.Guid);
return(_playerList[pData.Guid]);
}
CommonPlayer tPlayer = new CommonPlayer(pData, DataConfigManager.GetInstance(), ResourceManager.GetInstance());
tPlayer.Create();
_playerList[pData.Guid] = tPlayer;
_sceneObjectList.Add(tPlayer);
if (CreatePlayerCompleteEvent != null)
{
CreatePlayerCompleteEvent(pData.Guid);
}
return(tPlayer);
}
private bool CanBuy(CrewItem item, CommonPlayer player)
{
switch (item.Key)
{
case "logoworld":
return(this.crew.LogoWorld == "");
case "rankcreation":
return(!this.crew.Unlocked("Ranks"));
case "rank":
return(this.crew.Unlocked("Ranks") && this.crew.Ranks.Count < item.MaxPurchases + 2);
case "memberdescriptions":
return(!this.crew.Unlocked("Descriptions"));
case "unlockprofilecolor":
return(!this.crew.Unlocked("Colors"));
case "picknewcolor":
return(this.crew.Unlocked("Colors") && !this.crew.Unlocked("ColorPick"));
case "profiledivider":
return(false);
case "unlockfaceplates":
return(!this.crew.Unlocked("Faceplates"));
default:
{
if (!item.Key.StartsWith("faceplate"))
{
return(false);
}
if (!this.crew.Unlocked("Faceplates"))
{
return(false);
}
var id = item.Key.Substring(9);
return(!this.crew.Faceplates.Contains(id) && (id != "gold" || player.HasGoldMembership));
}
}
}
public bool SmileyIsLegit(CommonPlayer player, int smileyId, Shop shop)
{
if (this.freeForAll.Contains(smileyId))
{
return(true);
}
if (this.GetSmileyVaultIdById(smileyId) == "goldmember" /*&& player.HasGoldMembership*/)
{
return(true);
}
if (this.beta.Contains(smileyId) && player.HasBeta)
{
return(true);
}
var smileyNameInVault = this.GetSmileyVaultIdById(smileyId);
var shopItem = shop.GetShopItem(smileyNameInVault);
return(shopItem != null); /* && player.PayVault.Has(smileyNameInVault); */
}
private void AwardBadge(CommonPlayer player, Callback <Achievement> callback)
{
player.Achievements.Refresh(() =>
{
// Don't award if it's already completed
var a = player.Achievements.Get(this.Data.Badge);
if (a.Completed)
{
callback(a);
return;
}
player.Achievements.ProgressComplete(this.Data.Badge, delegate(Achievement a2)
{
callback(a2);
Console.WriteLine("Rewarded {0} with {1} badge.", player.Name, this.Data.Badge);
}, error =>
{
this.client.ErrorLog.WriteError("Error giving " + this.Data.Badge + " badge to " + player.Name,
error);
callback(a);
});
});
}
public QueueItem(CommonPlayer player, Message message)
{
this.Player = player;
this.Message = message;
}
public bool AuraIsLegit(CommonPlayer player, int auraId, int colorId, Shop shop)
{
return(this.AuraPayVaultIsLegit(player, this.GetAuraShapeVaultIdById(auraId), shop) &&
this.AuraPayVaultIsLegit(player, this.GetAuraColorVaultIdById(colorId), shop));
}
public void GotMessage(CommonPlayer player, Message message)
{
switch (message.Type)
{
case "useEnergy":
{
if (!this.CanUseShop(player))
{
player.Send(this.CantUseShopError(message.Type));
break;
}
var target = message.GetString(0);
var item = this.GetShopItem(target);
if (item != null &&
this.CanBuy(item, player) && item.PriceEnergy > 0 &&
(item.Enabled || player.IsAdmin || player.IsModerator))
{
player.RefreshPlayerObject(() =>
{
if (this.EnergyStatus.GetInt(item.Key) > item.PriceEnergy)
{
this.BuyItem(item.Key);
player.PlayerObject.Save(() =>
this.SendShopMessage(Message.Create(message.Type), player, true));
}
else if (player.UseEnergy(item.EnergyPerClick))
{
this.UpdateEnergyStatus(item.Key, item.EnergyPerClick);
if (this.EnergyStatus.GetInt(item.Key) >= item.PriceEnergy)
{
this.BuyItem(item.Key);
player.PlayerObject.Save(() =>
this.SendShopMessage(Message.Create(message.Type), player, true));
}
else
{
player.PlayerObject.Save(() =>
this.SendShopMessage(Message.Create(message.Type), player, false));
}
}
else
{
player.Send(Shop.NotEnoughEnergyError(message.Type));
}
});
}
break;
}
case "useAllEnergy":
{
if (!this.CanUseShop(player))
{
player.Send(this.CantUseShopError(message.Type));
break;
}
var target = message.GetString(0);
var item = this.GetShopItem(target);
if (item != null &&
this.CanBuy(item, player) && item.PriceEnergy > 0 &&
(item.Enabled || player.IsAdmin || player.IsModerator))
{
player.RefreshPlayerObject(() =>
{
if (player.UseEnergy(item.PriceEnergy - this.GetEnergyStatus(item.Key)))
{
this.BuyItem(item.Key);
player.PlayerObject.Save(() =>
this.SendShopMessage(Message.Create(message.Type), player, true));
}
else
{
var energyMultiplier = player.Energy / item.EnergyPerClick;
if (energyMultiplier > 0)
{
var energyToUse = item.EnergyPerClick * energyMultiplier;
if (player.UseEnergy(energyToUse))
{
this.UpdateEnergyStatus(item.Key, energyToUse);
player.PlayerObject.Save(() =>
this.SendShopMessage(Message.Create(message.Type), player, false));
}
else
{
player.Send(Shop.NotEnoughEnergyError(message.Type));
}
}
else
{
player.Send(Shop.NotEnoughEnergyError(message.Type));
}
}
});
}
else
{
player.Send(message.Type, false);
}
break;
}
case "useGems":
{
if (!this.CanUseShop(player))
{
player.Send(this.CantUseShopError(message.Type));
break;
}
var target = message.GetString(0);
var item = this.GetShopItem(target);
if (item != null &&
this.CanBuy(item, player) &&
(item.Enabled || player.IsAdmin || player.IsModerator))
{
player.PayVault.Refresh(() =>
{
player.PayVault.Debit(item.PriceCoins, "Bought " + item.Title + " for " + this.crew.Name,
() =>
{
this.BuyItem(item.Key);
this.SendShopMessage(Message.Create(message.Type), player, false);
},
error =>
{
player.Send(message.Type, "error", "Oops",
"Looks like something went wrong. Do you have enough gems?");
});
});
}
break;
}
case "getShop":
{
player.RefreshPlayerObject(
() =>
{
player.PayVault.Refresh(
() => this.SendShopMessage(Message.Create(message.Type), player, true));
});
break;
}
}
}
private void CreateInvitation(string recipientName,
Callback successCallback, Callback <InvitationError> errorCallback)
{
if (this.name == recipientName)
{
errorCallback(InvitationError.SendingToSelf);
return;
}
CommonPlayer.GetId(this.client.BigDB, recipientName, recipientId =>
{
if (recipientId == null)
{
errorCallback(InvitationError.PlayerNotFound);
return;
}
this.GetFriendKeys(this.connectUserId, friends =>
{
if (friends.Contains(recipientId))
{
errorCallback(InvitationError.AlreadyAdded);
return;
}
InvitationHelper.GetInvitation(this.client.BigDB, InvitationType.Friend,
this.name, recipientName, oldInvitation =>
{
if (oldInvitation.Exists)
{
errorCallback(InvitationError.AlreadySent);
return;
}
this.GetPendingInvitationsCount(pendingInvitationsCount =>
{
if (friends.Count + pendingInvitationsCount >= this.MaxFriendsAllowed)
{
errorCallback(InvitationError.LimitReached);
return;
}
InvitationHelper.GetInvitation(this.client.BigDB, InvitationType.Friend,
recipientName, this.name, invitationToMe =>
{
if (invitationToMe.Exists && invitationToMe.Status == InvitationStatus.Pending)
{
invitationToMe.Status = InvitationStatus.Accepted;
this.AddOrRemoveFriend(recipientId, true,
() => invitationToMe.Save(successCallback));
return;
}
InvitationBlocking.IsUserBlocked(this.client.BigDB, recipientId, this.name,
blocked =>
{
if (blocked)
{
errorCallback(InvitationError.Blocked);
return;
}
var newInvitation = new DatabaseObject();
newInvitation.Set("Sender", this.name);
newInvitation.Set("Recipient", recipientName);
newInvitation.Set("Status", (int)InvitationStatus.Pending);
InvitationHelper.CreateInvitation(this.client.BigDB,
InvitationType.Friend,
this.name, recipientName,
invitation => successCallback());
});
});
});
});
});
});
}
public void ProcessMessages(QueueItem item, LobbyPlayer player)
{
switch (item.Method)
{
case "getFriends":
{
this.GetFriendKeys(player.ConnectUserId, keys =>
{
if (keys.Count <= 0)
{
player.Send(item.Method);
return;
}
OnlineStatus.GetOnlineStatus(this.client, keys.ToArray(), status =>
{
var rtn = Message.Create(item.Method);
foreach (var stat in status.Where(stat => stat != null))
{
stat.ToMessage(rtn);
}
player.Send(rtn);
});
});
break;
}
case "getPending":
{
InvitationHelper.GetInvitationsFrom(this.client.BigDB, InvitationType.Friend,
this.name, invites =>
{
var rtn = Message.Create(item.Method);
foreach (var invite in invites)
{
rtn.Add(invite.Recipient);
rtn.Add((int)invite.Status);
}
player.Send(rtn);
});
break;
}
case "getInvitesToMe":
{
InvitationHelper.GetInvitationsTo(this.client.BigDB, InvitationType.Friend,
this.name, invites =>
{
var rtn = Message.Create(item.Method);
foreach (var invite in invites.Where(it => it.Status == InvitationStatus.Pending))
{
rtn.Add(invite.Sender);
}
player.Send(rtn);
});
break;
}
case "getBlockedUsers":
{
InvitationBlocking.GetBlockedUsers(this.client.BigDB, this.connectUserId, blockedUsers =>
{
var rtn = Message.Create(item.Method);
foreach (var blockedUser in blockedUsers)
{
rtn.Add(blockedUser);
}
player.Send(rtn);
});
break;
}
case "createInvite":
{
if (!player.HasFriendFeatures)
{
player.Send(item.Method, false);
return;
}
var friendName = item.Message.GetString(0).ToLower();
this.CreateInvitation(friendName,
() => player.Send(item.Method, true),
error =>
{
switch (error)
{
case InvitationError.PlayerNotFound:
{
player.Send(item.Method, false,
"Unknown user. Please check your spelling.");
break;
}
case InvitationError.AlreadyAdded:
{
player.Send(item.Method, false,
"This user is already on your friendslist!");
break;
}
case InvitationError.AlreadySent:
{
player.Send(item.Method, false,
"You already have a pending invitation for this user.");
break;
}
case InvitationError.LimitReached:
{
player.Send(item.Method, false,
"You cannot have more than " +
this.MaxFriendsAllowed +
" friends and invites.");
break;
}
case InvitationError.Blocked:
{
player.Send(item.Method, false,
"This user is blocking friend requests.");
break;
}
case InvitationError.SendingToSelf:
{
player.Send(item.Method, false,
"You cannot add yourself.");
break;
}
}
});
break;
}
case "answerInvite":
{
if (!player.HasFriendFeatures)
{
player.Send(item.Method, false);
return;
}
var invitedBy = item.Message.GetString(0).ToLower();
var accept = item.Message.GetBoolean(1);
this.AnswerInvitation(invitedBy, accept,
senderId =>
{
OnlineStatus.GetOnlineStatus(this.client, senderId, onlineStatus =>
{
var rtn = Message.Create(item.Method, true);
player.Send(onlineStatus.ToMessage(rtn));
});
},
error =>
{
switch (error)
{
case InvitationError.PlayerNotFound:
{
player.Send(item.Method, false,
"Sorry, the sender of this friend request does not exist.");
break;
}
case InvitationError.InvitationNotFound:
{
player.Send(item.Method, false,
"Sorry, the friend request does not exist anymore.");
break;
}
case InvitationError.LimitReached:
{
player.Send(item.Method, false,
"You cannot have more than " +
this.MaxFriendsAllowed +
" friends.");
break;
}
}
});
break;
}
case "deleteInvite":
{
var recipientName = item.Message.GetString(0).ToLower();
InvitationHelper.DeleteInvitation(this.client.BigDB, InvitationType.Friend,
this.name, recipientName, success =>
{
if (!success)
{
this.client.ErrorLog.WriteError(
"Error deleting invitation from " + player.Name + " to " +
recipientName, "Invite not found",
"Error deleting pending invitation", null);
}
player.Send(item.Method, success);
});
break;
}
case "blockUserInvites":
{
var invitedByName = item.Message.GetString(0).ToLower();
var shouldBlock = item.Message.GetBoolean(1);
InvitationBlocking.BlockUser(this.client.BigDB, this.connectUserId, invitedByName, shouldBlock,
() =>
{
if (shouldBlock)
{
InvitationHelper.GetInvitation(this.client.BigDB, InvitationType.Friend, invitedByName,
this.name, invitation =>
{
if (invitation.Exists)
{
invitation.Status = InvitationStatus.Rejected;
invitation.Save(() => player.Send(item.Method, true));
}
else
{
player.Send(item.Method, true);
}
});
}
else
{
player.Send(item.Method, true);
}
});
break;
}
case "getBlockStatus":
{
InvitationBlocking.IsBlockingAllUsers(this.client.BigDB, this.connectUserId,
isBlocking => { player.Send(item.Method, isBlocking); });
break;
}
case "blockAllInvites":
{
var shouldBlock = item.Message.GetBoolean(0);
InvitationBlocking.BlockAllFriends(this.client.BigDB, this.connectUserId, shouldBlock);
player.Send(item.Method, shouldBlock);
break;
}
case "deleteFriend":
{
CommonPlayer.GetId(this.client.BigDB, item.Message.GetString(0).ToLower(), friendId =>
{
this.AddOrRemoveFriend(friendId, false,
delegate { player.Send(item.Method, true); });
});
break;
}
case "GetOnlineStatus":
{
var id = item.Message.Count > 0 ? item.Message.GetString(0) : player.ConnectUserId;
OnlineStatus.GetOnlineStatus(this.client, id,
onlineStatus => player.Send(onlineStatus.ToMessage(item.Method)));
break;
}
}
}
