示例#1
0
        public static CreateSquadRequest GenerateCreateSquadRequest(SquadMsg message)
        {
            SqmSquadData squadData = message.SquadData;

            return(new CreateSquadRequest(WWW.EscapeURL(squadData.Name), WWW.EscapeURL(squadData.Desc), squadData.Icon, squadData.MinTrophies, squadData.Open)
            {
                PlayerId = message.OwnerData.PlayerId
            });
        }
示例#2
0
        private static SquadMsg CreateSquadMessage(string squadId, SquadAction action, SquadController.ActionCallback callback, object cookie)
        {
            SqmSquadData sqmSquadData = new SqmSquadData();

            sqmSquadData.Id = squadId;
            SquadMsg squadMsg = SquadMsgUtils.CreateActionMessage(action, callback, cookie);

            squadMsg.SquadData = sqmSquadData;
            return(squadMsg);
        }
示例#3
0
        public static EditSquadRequest GenerateEditSquadRequest(SquadMsg message)
        {
            SqmSquadData squadData = message.SquadData;

            return(new EditSquadRequest
            {
                Desc = WWW.EscapeURL(squadData.Desc),
                Icon = squadData.Icon,
                OpenSquad = squadData.Open,
                MinTrophy = squadData.MinTrophies,
                PlayerId = message.OwnerData.PlayerId
            });
        }
示例#4
0
        private void OnSquadLeveledUp(SquadMsg msg)
        {
            Squad        currentSquad = this.StateManager.GetCurrentSquad();
            SqmSquadData squadData    = msg.SquadData;
            int          level        = squadData.Level;

            if (level > currentSquad.Level)
            {
                currentSquad.Level = level;
            }
            currentSquad.TotalRepInvested = squadData.TotalRepInvested;
            Service.EventManager.SendEvent(EventId.SquadLeveledUp, null);
        }
示例#5
0
        private static SquadMsg CreateSquadMessage(string name, string description, string symbolName, int scoreReq, bool openEnrollment, SquadAction action, SquadController.ActionCallback callback, object cookie)
        {
            SqmSquadData sqmSquadData = new SqmSquadData();

            sqmSquadData.Name        = name;
            sqmSquadData.Desc        = description;
            sqmSquadData.Icon        = symbolName;
            sqmSquadData.MinTrophies = scoreReq;
            sqmSquadData.Open        = openEnrollment;
            SquadMsg squadMsg = SquadMsgUtils.CreateActionMessage(action, callback, cookie);

            squadMsg.SquadData = sqmSquadData;
            return(squadMsg);
        }
示例#6
0
        public static SquadMsg GenerateMessageFromSquadResponse(SquadResponse response, LeaderboardController lbc)
        {
            SqmSquadData sqmSquadData = new SqmSquadData();

            sqmSquadData.Id = response.SquadId;
            Squad orCreateSquad = lbc.GetOrCreateSquad(sqmSquadData.Id);

            orCreateSquad.FromObject(response.SquadData);
            return(new SquadMsg
            {
                SquadData = sqmSquadData,
                RespondedSquad = orCreateSquad
            });
        }
示例#7
0
        private void OnPerkInvestment(SquadMsg msg)
        {
            Squad        currentSquad = this.StateManager.GetCurrentSquad();
            SquadPerks   perks        = currentSquad.Perks;
            SqmSquadData squadData    = msg.SquadData;
            SqmPerkData  perkData     = msg.PerkData;
            int          level        = squadData.Level;

            if (level > currentSquad.Level)
            {
                currentSquad.Level = level;
            }
            currentSquad.TotalRepInvested = squadData.TotalRepInvested;
            perks.UpdatePerkInvestedAmt(perkData.PerkUId, perkData.PerkInvestedAmt);
            Service.EventManager.SendEvent(EventId.SquadPerkUpdated, null);
            Service.EventManager.SendEvent(EventId.PerkInvestment, null);
        }
示例#8
0
        public static SquadMsg GenerateMessageFromServerMessageObject(object messageObj)
        {
            Dictionary <string, object> dictionary = messageObj as Dictionary <string, object>;

            if (dictionary == null)
            {
                return(null);
            }
            SquadMsg squadMsg = new SquadMsg();

            if (dictionary.ContainsKey("notification"))
            {
                squadMsg = SquadMsgUtils.GenerateMessageFromNotifObject(dictionary["notification"]);
                if (dictionary.ContainsKey("guildId"))
                {
                    if (squadMsg.SquadData == null)
                    {
                        squadMsg.SquadData = new SqmSquadData();
                    }
                    squadMsg.SquadData.Id = Convert.ToString(dictionary["guildId"]);
                    if (dictionary.ContainsKey("guildName"))
                    {
                        squadMsg.SquadData.Name = WWW.UnEscapeURL(Convert.ToString(dictionary["guildName"]));
                    }
                }
                return(squadMsg);
            }
            if (dictionary.ContainsKey("serverTime"))
            {
                squadMsg.TimeSent = Convert.ToUInt32(dictionary["serverTime"]);
            }
            if (dictionary.ContainsKey("event"))
            {
                string name = Convert.ToString(dictionary["event"]);
                squadMsg.Type = StringUtils.ParseEnum <SquadMsgType>(name);
            }
            if (dictionary.ContainsKey("guildId"))
            {
                SqmSquadData sqmSquadData = new SqmSquadData();
                squadMsg.SquadData = sqmSquadData;
                sqmSquadData.Id    = Convert.ToString(dictionary["guildId"]);
                if (dictionary.ContainsKey("guildName"))
                {
                    sqmSquadData.Name = WWW.UnEscapeURL(Convert.ToString(dictionary["guildName"]));
                }
            }
            if (dictionary.ContainsKey("senderId"))
            {
                SqmFriendInviteData sqmFriendInviteData = new SqmFriendInviteData();
                squadMsg.FriendInviteData    = sqmFriendInviteData;
                sqmFriendInviteData.SenderId = Convert.ToString(dictionary["senderId"]);
                if (dictionary.ContainsKey("senderName"))
                {
                    sqmFriendInviteData.SenderName = Convert.ToString(dictionary["senderName"]);
                }
            }
            if (dictionary.ContainsKey("recipientId"))
            {
                if (squadMsg.FriendInviteData == null)
                {
                    squadMsg.FriendInviteData = new SqmFriendInviteData();
                }
                squadMsg.FriendInviteData.PlayerId = Convert.ToString(dictionary["recipientId"]);
            }
            if (dictionary.ContainsKey("warId"))
            {
                SqmWarEventData sqmWarEventData = new SqmWarEventData();
                squadMsg.WarEventData = sqmWarEventData;
                sqmWarEventData.WarId = Convert.ToString(dictionary["warId"]);
                if (dictionary.ContainsKey("empireName"))
                {
                    sqmWarEventData.EmpireSquadName = Convert.ToString(dictionary["empireName"]);
                }
                if (dictionary.ContainsKey("empireScore"))
                {
                    sqmWarEventData.EmpireScore = Convert.ToInt32(dictionary["empireScore"]);
                }
                if (dictionary.ContainsKey("rebelName"))
                {
                    sqmWarEventData.RebelSquadName = Convert.ToString(dictionary["rebelName"]);
                }
                if (dictionary.ContainsKey("rebelScore"))
                {
                    sqmWarEventData.RebelScore = Convert.ToInt32(dictionary["rebelScore"]);
                }
                if (dictionary.ContainsKey("buffBaseUid"))
                {
                    sqmWarEventData.BuffBaseUid = Convert.ToString(dictionary["buffBaseUid"]);
                }
                if (dictionary.ContainsKey("empireCrateTier"))
                {
                    sqmWarEventData.EmpireCrateId = Convert.ToString(dictionary["empireCrateTier"]);
                }
                else if (dictionary.ContainsKey("empireCrateId"))
                {
                    sqmWarEventData.EmpireCrateId = Convert.ToString(dictionary["empireCrateId"]);
                }
                if (dictionary.ContainsKey("rebelCrateTier"))
                {
                    sqmWarEventData.RebelCrateId = Convert.ToString(dictionary["rebelCrateTier"]);
                }
                else if (dictionary.ContainsKey("rebelCrateId"))
                {
                    sqmWarEventData.RebelCrateId = Convert.ToString(dictionary["rebelCrateId"]);
                }
            }
            if (dictionary.ContainsKey("level") || dictionary.ContainsKey("totalRepInvested"))
            {
                SquadMsgUtils.AddSquadLevelToSquadMessageData(dictionary, squadMsg);
            }
            if (dictionary.ContainsKey("perkId"))
            {
                SquadMsgUtils.AddPerkUnlockUpgrdeDataToSquadMessageData(dictionary, squadMsg);
            }
            return(squadMsg);
        }
示例#9
0
        public void OnPlayerActionSuccess(SquadAction actionType, SquadMsg msg)
        {
            Squad currentSquad = this.StateManager.GetCurrentSquad();

            switch (actionType)
            {
            case SquadAction.Create:
                GameUtils.SpendCurrency(GameConstants.SQUAD_CREATE_COST, 0, 0, true);
                this.StateManager.SetCurrentSquad(msg.RespondedSquad);
                this.ClearPrefsForNewSquad(0);
                break;

            case SquadAction.Join:
                this.StateManager.SetCurrentSquad(msg.RespondedSquad);
                this.StateManager.OnSquadJoined(msg.BISource);
                this.SetLastViewedSquadLevelUp(msg.RespondedSquad.Level);
                break;

            case SquadAction.Leave:
            {
                string message = Service.Lang.Get("LEAVE_A_SQUAD", new object[]
                    {
                        currentSquad.SquadName
                    });
                this.LeaveSquad(message);
                break;
            }

            case SquadAction.Edit:
            {
                SqmSquadData squadData = msg.SquadData;
                this.StateManager.EditSquad(squadData.Open, squadData.Icon, squadData.Desc, squadData.MinTrophies);
                break;
            }

            case SquadAction.ApplyToJoin:
                if (!this.StateManager.SquadJoinRequestsPending.Contains(msg.SquadData.Id))
                {
                    this.StateManager.SquadJoinRequestsPending.Add(msg.SquadData.Id);
                }
                break;

            case SquadAction.AcceptApplicationToJoin:
                SquadUtils.AddSquadMember(currentSquad, msg.SquadMemberResponse);
                this.UpdateCurrentSquad();
                this.StateManager.OnSquadJoinApplicationAcceptedByCurrentPlayer(msg.BISource);
                break;

            case SquadAction.SendInviteToJoin:
                this.StateManager.PlayersInvitedToSquad.Add(msg.FriendInviteData.PlayerId);
                break;

            case SquadAction.AcceptInviteToJoin:
                this.StateManager.RemoveInviteToSquad(msg.SquadData.Id);
                this.UpdateCurrentSquad();
                this.StateManager.OnSquadJoinInviteAccepted();
                break;

            case SquadAction.RejectInviteToJoin:
                this.StateManager.RemoveInviteToSquad(msg.SquadData.Id);
                break;

            case SquadAction.PromoteMember:
                SquadUtils.SetSquadMemberRole(currentSquad, msg.MemberData.MemberId, msg.MemberData.MemberRole);
                break;

            case SquadAction.DemoteMember:
                SquadUtils.SetSquadMemberRole(currentSquad, msg.MemberData.MemberId, msg.MemberData.MemberRole);
                break;

            case SquadAction.RemoveMember:
                SquadUtils.RemoveSquadMember(currentSquad, msg.MemberData.MemberId);
                break;

            case SquadAction.RequestTroops:
                this.StateManager.TroopRequestDate = Service.ServerAPI.ServerTime;
                this.StateManager.OnSquadTroopsRequested();
                break;

            case SquadAction.DonateTroops:
            case SquadAction.DonateWarTroops:
            {
                Dictionary <string, int> donations     = msg.DonationData.Donations;
                CurrentPlayer            currentPlayer = Service.CurrentPlayer;
                int num = 0;
                foreach (KeyValuePair <string, int> current in donations)
                {
                    string key   = current.Key;
                    int    value = current.Value;
                    currentPlayer.Inventory.Troop.ModifyItemAmount(key, -value);
                    num += value;
                }
                StorageSpreadUtils.UpdateAllStarportFullnessMeters();
                Service.ISupportController.UnfreezeAllBuildings(ServerTime.Time);
                this.StateManager.NumTroopDonationsInSession += num;
                this.StateManager.OnSquadTroopsDonated(donations);
                break;
            }

            case SquadAction.RequestWarTroops:
                this.StateManager.WarTroopRequestDate = Service.ServerAPI.ServerTime;
                this.StateManager.OnSquadWarTroopsRequested();
                break;

            case SquadAction.ShareReplay:
                this.StateManager.OnSquadReplayShared(msg.ReplayData);
                break;
            }
        }