Example #1
0
        public override void RefreshView()
        {
            SquadController squadController = Service.SquadController;

            switch (squadController.StateManager.GetSquadScreenChatFilterType())
            {
            case ChatFilterType.ShowAll:
                this.chatOpenFiltersLabel.Text = this.lang.Get("s_ShowAll", new object[0]);
                break;

            case ChatFilterType.Messages:
                this.chatOpenFiltersLabel.Text = this.lang.Get("s_Messages", new object[0]);
                break;

            case ChatFilterType.Requests:
                this.chatOpenFiltersLabel.Text = this.lang.Get("s_Requests", new object[0]);
                break;

            case ChatFilterType.Replays:
                this.chatOpenFiltersLabel.Text = this.lang.Get("s_Replays", new object[0]);
                break;

            case ChatFilterType.Updates:
                this.chatOpenFiltersLabel.Text = this.lang.Get("s_Updates", new object[0]);
                break;
            }
        }
        private void CountChatMessages()
        {
            this.msgCount       = 0;
            this.requestCount   = 0;
            this.replayCount    = 0;
            this.updateCount    = 0;
            this.videoCount     = 0;
            this.totalChatCount = 0;
            SquadController squadController  = Service.Get <SquadController>();
            List <SquadMsg> existingMessages = squadController.MsgManager.GetExistingMessages();
            CurrentPlayer   currentPlayer    = Service.Get <CurrentPlayer>();
            int             i     = 0;
            int             count = existingMessages.Count;

            while (i < count)
            {
                SquadMsg squadMsg = existingMessages[i];
                if (squadMsg != null && squadMsg.OwnerData != null && squadMsg.OwnerData.PlayerId != currentPlayer.PlayerId && squadMsg.TimeSent > this.GetLastViewedTimeByMessageType(squadMsg.Type))
                {
                    this.IncrementBadgeByMessageType(squadMsg.Type);
                }
                i++;
            }
            this.totalChatCount = this.msgCount + this.requestCount + this.replayCount + this.updateCount + this.videoCount;
        }
Example #3
0
        public void CloseView()
        {
            SquadController squadController = Service.Get <SquadController>();

            squadController.StateManager.SquadScreenState = SquadScreenState.Chat;
            this.screen.RefreshViews();
        }
Example #4
0
        private void SetStandardDataForAction(out string tier1, out string tier2, out string tier6)
        {
            string text  = "u";
            string text2 = "u";
            string text3 = string.Empty;
            int    num   = -1;
            string text4 = string.Empty;

            if (Service.IsSet <CurrentPlayer>())
            {
                CurrentPlayer currentPlayer = Service.Get <CurrentPlayer>();
                text  = currentPlayer.Faction.ToString();
                text2 = currentPlayer.PlanetId;
                if (currentPlayer.Map != null)
                {
                    num = currentPlayer.Map.FindHighestHqLevel();
                }
            }
            if (Service.IsSet <SquadController>())
            {
                SquadController squadController = Service.Get <SquadController>();
                text3 = ((squadController.StateManager.GetCurrentSquad() != null) ? squadController.StateManager.GetCurrentSquad().SquadID : string.Empty);
            }
            if (Service.IsSet <BattleController>())
            {
                CurrentBattle currentBattle = Service.Get <BattleController>().GetCurrentBattle();
                if (currentBattle != null)
                {
                    text4 = currentBattle.BattleUid;
                }
            }
            tier1 = text + "|" + num;
            tier2 = text2;
            tier6 = text3 + "|" + text4;
        }
Example #5
0
        private void SetStandardDataForAction(out string tier1, out string tier2, out string tier6)
        {
            string arg  = "u";
            string text = "u";
            string str  = string.Empty;
            int    num  = -1;
            string str2 = string.Empty;

            if (Service.CurrentPlayer != null)
            {
                CurrentPlayer currentPlayer = Service.CurrentPlayer;
                arg  = currentPlayer.Faction.ToString();
                text = currentPlayer.PlanetId;
                if (currentPlayer.Map != null)
                {
                    num = currentPlayer.Map.FindHighestHqLevel();
                }
            }
            if (Service.SquadController != null)
            {
                SquadController squadController = Service.SquadController;
                str = ((squadController.StateManager.GetCurrentSquad() == null) ? string.Empty : squadController.StateManager.GetCurrentSquad().SquadID);
            }
            if (Service.BattleController != null)
            {
                CurrentBattle currentBattle = Service.BattleController.GetCurrentBattle();
                if (currentBattle != null)
                {
                    str2 = currentBattle.BattleUid;
                }
            }
            tier1 = arg + "|" + num;
            tier2 = text;
            tier6 = str + "|" + str2;
        }
Example #6
0
 public override void RefreshView()
 {
     this.UpdateMembers();
     if (Service.SquadController.WarManager.MatchMakingPrepMode)
     {
         this.groupStartWarBtns.Visible = true;
         this.memberPanel.SetPanelUnifiedAnchorBottomOffset(120);
         SquadController squadController = Service.SquadController;
         SquadWarManager warManager      = squadController.WarManager;
         int             warPartyCount   = warManager.GetWarPartyCount();
         this.labelStartWarSelected.Text = this.lang.Get("WAR_MEMBERS_SELECTED", new object[]
         {
             warPartyCount,
             GameConstants.WAR_PARTICIPANT_COUNT
         });
         if (warPartyCount < GameConstants.WAR_PARTICIPANT_COUNT)
         {
             this.btnStartWarConfirm.Enabled = false;
             this.btnStartWarConfirm.VisuallyDisableButton();
         }
         else
         {
             this.btnStartWarConfirm.Enabled = true;
             this.btnStartWarConfirm.VisuallyEnableButton();
         }
     }
     else
     {
         this.groupStartWarBtns.Visible = false;
         this.memberPanel.SetPanelUnifiedAnchorBottomOffset(15);
     }
 }
 private void OnDisable()
 {
     if (Instance == this)
     {
         Instance = null;
     }
 }
        public void RetornaStatusOKGetId()
        {
            // Arrange
            int valorEsperado = 200;

            var squad = new SquadDto
            {
                Id        = 1,
                Id_Tribo  = 1,
                Nome      = "NerdBunker",
                NomeTribo = "Formacao",
                Ativo     = true
            };
            var repoMock = new Mock <ISquadNegocio>();
            Expression <Func <ISquadNegocio, SquadDto> > call = x => x.SelecionarPorId(squad.Id);

            repoMock.Setup(call).Returns(squad).Verifiable("Metodo nao chamado");
            var _squadController = new SquadController(repoMock.Object);


            // Act
            var actionResult   = _squadController.GetId(squad.Id);
            var okObjectResult = (OkObjectResult)actionResult;

            // Assert
            Assert.Equal(valorEsperado, okObjectResult.StatusCode);
            repoMock.Verify(call, Times.Once);
        }
Example #9
0
        public void OnViewFrameTime(float dt)
        {
            List <UXElement>   elementList          = this.gridWarLog.GetElementList();
            SquadController    squadController      = Service.SquadController;
            uint               serverTime           = Service.ServerAPI.ServerTime;
            SquadMemberWarData currentMemberWarData = squadController.WarManager.GetCurrentMemberWarData();
            int i     = 0;
            int count = elementList.Count;

            while (i < count)
            {
                string             text         = elementList[i].Tag as string;
                UXLabel            subElement   = this.gridWarLog.GetSubElement <UXLabel>(text, "LabelWarlogExpires");
                SquadWarRewardData rewardForWar = SquadUtils.GetRewardForWar(text, currentMemberWarData);
                if (rewardForWar != null)
                {
                    int num = (int)(rewardForWar.ExpireDate - serverTime);
                    if (num < 0)
                    {
                        this.HideCollectButton(text);
                    }
                    else
                    {
                        string text2 = LangUtils.FormatTime((long)num);
                        subElement.Visible = true;
                        subElement.Text    = text2;
                    }
                }
                else
                {
                    this.HideCollectButton(text);
                }
                i++;
            }
        }
Example #10
0
    // Start is called before the first frame update
    void Start()
    {
        currentHealth = maxHealth;

        animator = GetComponent <Animator>();
        Squad    = GetComponentInParent <SquadController>();
    }
Example #11
0
        public override void ShowView()
        {
            EventManager eventManager = Service.EventManager;

            this.viewContainer.Visible = true;
            eventManager.SendEvent(EventId.SquadSelect, null);
            eventManager.SendEvent(EventId.UISquadScreenTabShown, "warlog");
            SquadController    squadController      = Service.SquadController;
            SquadMemberWarData currentMemberWarData = squadController.WarManager.GetCurrentMemberWarData();
            uint serverTime = Service.ServerAPI.ServerTime;

            if (SquadUtils.DoesRewardWithoutWarHistoryExist(squadController, currentMemberWarData, serverTime))
            {
                ProcessingScreen.Show();
                EventManager eventManager2 = Service.EventManager;
                eventManager2.RegisterObserver(this, EventId.SquadUpdateCompleted);
                squadController.UpdateCurrentSquad();
            }
            else
            {
                this.RefreshView();
            }
            this.tabButton.Selected = true;
            Service.ViewTimeEngine.RegisterFrameTimeObserver(this);
        }
 public Entity ReplaceSquadView(SquadController newView) {
     var componentPool = GetComponentPool(UnitsComponentIds.SquadView);
     var component = (SquadViewComponent)(componentPool.Count > 0 ? componentPool.Pop() : new SquadViewComponent());
     component.View = newView;
     ReplaceComponent(UnitsComponentIds.SquadView, component);
     return this;
 }
Example #13
0
        public override void RefreshView()
        {
            SquadController squadController = Service.SquadController;
            Squad           currentSquad    = squadController.StateManager.GetCurrentSquad();

            if (currentSquad == null)
            {
                return;
            }
            if (currentSquad.InviteType == 1)
            {
                this.statsTypeLabel.Text = this.lang.Get("SQUAD_OPEN_TO_ALL", new object[0]);
            }
            else
            {
                this.statsTypeLabel.Text = this.lang.Get("SQUAD_INVITE_ONLY", new object[0]);
            }
            this.statsTrophiesLabel.Text = this.lang.ThousandsSeparated(currentSquad.RequiredTrophies);
            this.squadTitleLabel.Text    = currentSquad.SquadName;
            this.squadDescLabel.Text     = currentSquad.Description;
            this.squadIcon.SpriteName    = currentSquad.Symbol;
            this.SetupButtonBasedOnRole(this.editButton, null, true);
            this.UpdateStatsLabels();
            this.UpdateSquadRank();
        }
Example #14
0
        private void InternalOnLeaveSquadClicked(object cookie)
        {
            Service.EventManager.SendEvent(EventId.SquadEdited, null);
            SquadController    squadController      = Service.SquadController;
            SquadMemberWarData currentMemberWarData = squadController.WarManager.GetCurrentMemberWarData();
            uint serverTime = Service.ServerAPI.ServerTime;
            int  unclaimedSquadWarRewardsCount = SquadUtils.GetUnclaimedSquadWarRewardsCount(currentMemberWarData, serverTime);

            if (!SquadUtils.CanLeaveSquad())
            {
                string message = Service.Lang.Get("IN_WAR_CANT_LEAVE_SQUAD", new object[0]);
                AlertScreen.ShowModal(false, null, message, null, null, true);
                this.screen.ShowSquadSlideButton();
            }
            else if (unclaimedSquadWarRewardsCount > 0)
            {
                YesNoScreen.ShowModal(this.lang.Get("LEAVING_SQUAD_ALERT_WITH_REWARDS_TITLE", new object[0]), this.lang.Get("LEAVING_SQUAD_ALERT_WITH_REWARDS", new object[]
                {
                    unclaimedSquadWarRewardsCount
                }), false, this.lang.Get("LEAVING_SQUAD_CONFIRM", new object[0]), this.lang.Get("ACCOUNT_CONFLICT_CONFIRM_CANCEL", new object[0]), new OnScreenModalResult(this.OnAlertLeaveResult), null);
            }
            else
            {
                YesNoScreen.ShowModal(this.lang.Get("LEAVING_SQUAD_ALERT_TITLE", new object[0]), this.lang.Get("LEAVING_SQUAD_ALERT", new object[0]), false, this.lang.Get("LEAVING_SQUAD_CONFIRM", new object[0]), this.lang.Get("ACCOUNT_CONFLICT_CONFIRM_CANCEL", new object[0]), new OnScreenModalResult(this.OnAlertLeaveResult), null);
            }
        }
Example #15
0
        private List <NotificationObject> GetSquadWarNotifications()
        {
            SquadController squadController = Service.SquadController;

            if (squadController.StateManager.GetCurrentSquad() == null)
            {
                return(null);
            }
            SquadWarData currentSquadWar = squadController.WarManager.CurrentSquadWar;

            if (currentSquadWar == null)
            {
                return(null);
            }
            if (squadController.WarManager.GetCurrentParticipantState() == null)
            {
                return(null);
            }
            List <NotificationObject> list = new List <NotificationObject>();
            uint serverTime = Service.ServerAPI.ServerTime;

            if ((long)currentSquadWar.PrepEndTimeStamp > (long)((ulong)serverTime))
            {
                DateTime           time = DateUtils.DateFromSeconds(currentSquadWar.PrepEndTimeStamp);
                NotificationObject item = this.CreateReengagementNotification("squadwars_action_phase_start", time, false);
                list.Add(item);
            }
            if ((long)currentSquadWar.ActionEndTimeStamp > (long)((ulong)serverTime))
            {
                DateTime           time2 = DateUtils.DateFromSeconds(currentSquadWar.ActionEndTimeStamp);
                NotificationObject item2 = this.CreateReengagementNotification("squadwars_reward_unknown", time2, false);
                list.Add(item2);
            }
            return(list);
        }
Example #16
0
        public static bool CanLeaveSquad()
        {
            bool            result          = true;
            SquadController squadController = Service.Get <SquadController>();
            CurrentPlayer   currentPlayer   = Service.Get <CurrentPlayer>();
            Squad           currentSquad    = squadController.StateManager.GetCurrentSquad();

            if (currentSquad == null)
            {
                return(result);
            }
            SquadWarStatusType currentStatus = squadController.WarManager.GetCurrentStatus();

            if (currentStatus == SquadWarStatusType.PhaseCooldown)
            {
                return(result);
            }
            SquadMember squadMemberById = SquadUtils.GetSquadMemberById(currentSquad, currentPlayer.PlayerId);

            if (squadController.WarManager.IsMemberInWarParty(squadMemberById.MemberID) || squadController.WarManager.IsSquadMemberInWarOrMatchmaking(squadMemberById))
            {
                result = false;
            }
            return(result);
        }
Example #17
0
    public void ReceivePosList(object parm)
    {
        //LogModule.DebugLog("ReceivePosList");
        if (mBattleState != BattleState.prepare && mBattleState != BattleState.Start)
        {
            //LogModule.DebugLog("AssetNotOk");
            return;
        }
        GC_OBJPOSLIST tObjPosList = (GC_OBJPOSLIST)parm;

        if (mSceneID != tObjPosList.SceneId)
        {
            return;
        }
        foreach (var item in tObjPosList.objPosListList)
        {
            SquadController tSquadController = mSquadGameObjDict[item.ObjId].GetComponent <SquadController>();

            GameObject targetSquadController = null;
            mSquadGameObjDict.TryGetValue(item.TargetId, out targetSquadController);
            SquadController tAimController = null;
            if (targetSquadController != null)
            {
                tAimController = mSquadGameObjDict[item.TargetId].GetComponent <SquadController>();
            }
            tSquadController.CorretSquadInfor(item, tAimController);
            //tSquadController.UnitMarching(SetPosition(item.PosX,item.PosZ));
        }
    }
Example #18
0
        private void OnClickStartWarButton(UXButton button)
        {
            SquadController squadController = Service.SquadController;

            switch (squadController.WarManager.GetCurrentStatus())
            {
            case SquadWarStatusType.PhaseOpen:
                if (squadController.WarManager.IsCurrentSquadMatchmaking())
                {
                    this.screen.AnimateClosed(false, null);
                    Service.ScreenController.AddScreen(new SquadWarMatchMakeScreen());
                }
                else
                {
                    this.btnStartWar.Visible = false;
                    squadController.WarManager.StartMatchMakingPreparation();
                    this.screen.RefreshViews();
                }
                break;

            case SquadWarStatusType.PhasePrep:
            case SquadWarStatusType.PhasePrepGrace:
            case SquadWarStatusType.PhaseAction:
            case SquadWarStatusType.PhaseActionGrace:
            case SquadWarStatusType.PhaseCooldown:
                this.screen.InstantClose(false, null);
                Service.EventManager.SendEvent(EventId.WarLaunchFlow, null);
                break;
            }
        }
Example #19
0
        public override void Perform()
        {
            Service.BotRunner.Log("Sending troop request", new object[0]);
            SquadController squadController = Service.SquadController;

            squadController.SendTroopRequest(null, false);
            base.Perform();
        }
Example #20
0
        public void OpenDonationView(string recipientId, string recipientUserName, int alreadyDonatedSize, int totalCapacity, int currentPlayerDonationCount, string requestId, bool isWarRequest, int troopDonationLimit, TroopDonationProgress donationProgress)
        {
            this.troopDonationView.InitView(recipientId, recipientUserName, alreadyDonatedSize, totalCapacity, currentPlayerDonationCount, requestId, isWarRequest, troopDonationLimit, donationProgress);
            SquadController squadController = Service.Get <SquadController>();

            squadController.StateManager.SquadScreenState = SquadScreenState.Donation;
            this.RefreshViews();
        }
 void SquadAttackEffect()
 {
     if (BattleMode.Client)
     {
         SquadController mAttackAimController = mAttackAim.GetComponent <SquadController>();
         mAttackAimController.SetSquadHP(mAttackAimController.GetSquadData().GetSquadHP() - GetSquadData().GetAttack(), transform);
     }
 }
Example #22
0
        public void CloseDonationView()
        {
            SquadController squadController = Service.Get <SquadController>();

            if (squadController.StateManager.SquadScreenState == SquadScreenState.Donation)
            {
                this.troopDonationView.CloseView();
            }
        }
        private void OnChatMessageSend(UXButton button)
        {
            Service.Get <EventManager>().SendEvent(EventId.SquadSend, null);
            string          text            = this.chatInputBox.Text;
            SquadController squadController = Service.Get <SquadController>();

            squadController.PublishChatMessage(text);
            this.chatInputBox.Text = string.Empty;
        }
 private void OnTabButtonSelected(UXCheckbox button, bool selected)
 {
     if (selected)
     {
         SquadController squadController = Service.Get <SquadController>();
         squadController.StateManager.SquadScreenState = SquadScreenState.Advancement;
         this.screen.RefreshViews();
     }
 }
Example #25
0
 private void OnTabButtonSelected(UXCheckbox checkbox, bool selected)
 {
     if (selected)
     {
         SquadController squadController = Service.SquadController;
         squadController.StateManager.SquadScreenState = SquadScreenState.Overview;
         this.screen.RefreshViews();
     }
 }
Example #26
0
        public SquadWarBuffManager(SquadController controller)
        {
            this.controller = controller;
            EventManager eventManager = Service.EventManager;

            eventManager.RegisterObserver(this, EventId.BattleLoadStart, EventPriority.Default);
            eventManager.RegisterObserver(this, EventId.BattleReplaySetup, EventPriority.Default);
            eventManager.RegisterObserver(this, EventId.BattleEndFullyProcessed, EventPriority.Default);
            eventManager.RegisterObserver(this, EventId.BattleLeftBeforeStarting, EventPriority.Default);
        }
Example #27
0
        protected override void OnClose()
        {
            base.OnClose();
            this.HideAllViews();
            this.bgDialog.Visible        = false;
            this.squadNavigation.Visible = false;
            Service.Get <SquadController>().WarManager.MatchMakingPrepMode = false;
            SquadController squadController = Service.Get <SquadController>();

            squadController.StateManager.SetSquadScreenOpen(false);
        }
Example #28
0
        public void RefreshVisibility()
        {
            IState          currentState     = Service.Get <GameStateMachine>().CurrentState;
            HUD             hUD              = Service.Get <UXController>().HUD;
            HudConfig       currentHudConfig = hUD.CurrentHudConfig;
            SquadController squadController  = Service.Get <SquadController>();
            Squad           currentSquad     = squadController.StateManager.GetCurrentSquad();
            bool            visible          = (currentState is GalaxyState || currentHudConfig.Has("SquadScreen")) && currentSquad != null;

            this.Visible = visible;
        }
        public override void RefreshView()
        {
            SquadController squadController = Service.Get <SquadController>();

            this.HideAllInputs();
            int panelUnifiedAnchorTopOffset = -141;

            switch (squadController.StateManager.GetSquadScreenChatFilterType())
            {
            case ChatFilterType.ShowAll:
                this.inputModeChat.Visible  = true;
                panelUnifiedAnchorTopOffset = -141;
                break;

            case ChatFilterType.Messages:
                this.inputModeChat.Visible  = true;
                panelUnifiedAnchorTopOffset = -141;
                break;

            case ChatFilterType.Requests:
                this.inputModeRequest.Visible = true;
                panelUnifiedAnchorTopOffset   = -141;
                this.UpdateTroopRequestMode();
                break;

            case ChatFilterType.Replays:
            {
                this.inputModeShare.Visible = true;
                CurrentPlayer currentPlayer        = Service.Get <CurrentPlayer>();
                BattleEntry   latestValidPvPBattle = currentPlayer.BattleHistory.GetLatestValidPvPBattle();
                if (latestValidPvPBattle != null)
                {
                    this.FillOutReplayShare(latestValidPvPBattle);
                    panelUnifiedAnchorTopOffset = -195;
                }
                else
                {
                    this.inputModeShare.Visible = false;
                    panelUnifiedAnchorTopOffset = -71;
                }
                break;
            }

            case ChatFilterType.Updates:
                panelUnifiedAnchorTopOffset = -71;
                break;

            case ChatFilterType.Videos:
                panelUnifiedAnchorTopOffset = -71;
                break;
            }
            this.chatPanel.SetPanelUnifiedAnchorTopOffset(panelUnifiedAnchorTopOffset);
            this.chatItemTable.RepositionItems();
        }
    public void SquadAttackEnemy(SquadController tEnemySquad)
    {
        int tTargetID = 0;

        if (mAttackAim != tEnemySquad.transform || mAttackAim == null)
        {
            mAttackAim = tEnemySquad.transform;
            tTargetID  = mAttackAim.GetComponent <SquadController>().GetSquadData().GetID();
            RefreshUnitEnemyList(tTargetID);
        }
        UnitAttackEnemy(tTargetID);
    }
Example #31
0
        protected override void OnOpen()
        {
            base.OnOpen();
            this.chatHolderPanel.RefreshPanel();
            SquadController squadController = Service.Get <SquadController>();

            squadController.StateManager.SetSquadScreenOpen(true);
            if (!this.chatView.ChatDisplaySetup)
            {
                this.chatView.SetupChatDisplay();
            }
        }
 void OnEnable()
 {
     sc = (SquadController)target;
 }