示例#1
0
        public void StartLoading()
        {
            GetPanel <LoadingPanel>().OpenPanel();

            _invoker = GetSystem <CommandInvoker>();

            // create mission command
            var missionCommand = new LoadingCommand <MissionModel>(ApiList.Missions);

            missionCommand.OnComplete += result => _models.missions = result;
            _invoker.AddCommand(missionCommand);

            //create history command
            var historyCommand = new LoadingCommand <HistoryModel>(ApiList.History);

            historyCommand.OnComplete += result => _models.history = result;
            _invoker.AddCommand(historyCommand);

            //create rockets command
            var rocketsCommand = new LoadingCommand <RocketModel>(ApiList.Rockets);

            rocketsCommand.OnComplete += result => _models.rocket = result;
            _invoker.AddCommand(rocketsCommand);


            _invoker.OnComplete += LoadingComplete;
            _invoker.StartInvoker();
        }
示例#2
0
        public void Init()
        {
            if (Loaded)
            {
                return;
            }

            Loaded = true;

            LoadingCommand?.Execute();
        }
        public MainPageViewModel(MyIndicatorView myIndicatorView)
        {
            VAligns.Add(LayoutAlignment.Start);
            VAligns.Add(LayoutAlignment.Center);
            VAligns.Add(LayoutAlignment.End);

            HAligns.Add(LayoutAlignment.Start);
            HAligns.Add(LayoutAlignment.Center);
            HAligns.Add(LayoutAlignment.End);

            VAlign.Value = VAligns[1];
            HAlign.Value = HAligns[1];

            Configurations.LoadingConfig = new LoadingConfig {
                DefaultMessage = "Loading...", IsReusable = true
            };

            var loadingFlg = false;

            LoadingCommand.Subscribe(async _ =>
            {
                //Loading.Instance.Show();
                //await Task.Delay(1);
                //Loading.Instance.Hide();

                await Loading.Instance.StartAsync(async progress => {
                    //await Task.Delay(1);
                    progress.Report(0d);
                    for (var i = 0; i < 100; i++)
                    {
                        if (i == 50)
                        {
                            Loading.Instance.SetMessage("Soon...");
                        }
                        await Task.Delay(25);
                        progress.Report((i + 1) * 0.01d);
                    }
                }, null, loadingFlg).ConfigureAwait(false);

                loadingFlg = !loadingFlg;
            });


            CustomLoadingCommand.Subscribe(async _ =>
            {
                var customLoading = Loading.Instance.Create <MyIndicatorView>(new
                {
                    Message = "Loading...",
                    VAlign  = VAlign.Value,
                    HAlign  = HAlign.Value,
                    OffsetX = OffsetX.Value,
                    OffsetY = OffsetY.Value
                });
                await customLoading.StartAsync(async p =>
                {
                    await Task.Delay(1);
                    p.Report(0d);
                    for (var i = 0; i < 100; i++)
                    {
                        await Task.Delay(25);
                        p.Report((i + 1) * 0.01d);
                    }
                });
            });

            var dlgPage = new MyDialogView();


            DialogCommand.Subscribe(async _ =>
            {
                //var ret = await redlg.ShowAsync();

                //dlg.Dispose();
                var vmm = new {
                    Title          = "Title", Description = "This is a forms view.",
                    VAlign         = VAlign.Value,
                    HAlign         = HAlign.Value,
                    OffsetX        = OffsetX.Value,
                    OffsetY        = OffsetY.Value,
                    IsPageLocation = UseCurrentPageLocation.Value,
                };

                var ret = await Dialog.Instance.ShowAsync <MyDialogView>(vmm);
                //var ret = await Dialog.Instance.ShowAsync(page, vm);
            });

            ToastCommand.Subscribe(_ =>
            {
                Toast.Instance.Show <MyToastView>(new {
                    VAlign = VAlign.Value, HAlign = HAlign.Value, OffsetX = OffsetX.Value, OffsetY = OffsetY.Value
                });
            });
        }
示例#4
0
        //private static void UpdatebuttonText(string newValue)
        //{
        //btnEmpty.Text = newValue;
        //}

        private void BtnEmpty_Clicked(object sender, EventArgs e)
        {
            LoadingCommand?.Execute(null);
        }
    void Update()
    {
        for (int i = updatePreclist.Count - 1; i >= 0; i--)
        {
            UpdatePrec up = updatePreclist[i];
            up.curTime += Time.deltaTime;
            if (up.curTime > updatePreclist[i].targetTime)
            {
                up.PrecValue--;
                up.curTime = 0.0f;
                up.loadingItem.percentage++;
                LuaComponent loadingItem = up.loadingItem.transform.GetComponent <LuaComponent>();
                if (loadingItem.table != null)
                {
                    loadingItem.table.Set("loadingState", CommonFunction.GetConstString("STR_LOADING") + up.loadingItem.percentage + "%");
                }
            }
            if (up.PrecValue == 0)
            {
                if (m_curLoadingCmd != null)
                {
                    if (up.loadingItem.ri != null)
                    {
                        if (up.loadingItem.ri.acc_id == MainPlayer.Instance.AccountID)
                        {
                            m_curLoadingCmd.m_bDone = true;
                        }
                    }
                    else
                    {
                        m_curLoadingCmd.m_bDone = true;
                    }
                }

                updatePreclist.RemoveAt(i);
            }
        }

        _InitGameMsgHandler();

        //loading queue process
        if (m_curLoadingCmd == null && m_loadingQueue.Count != 0)
        {
            m_curLoadingCmd = m_loadingQueue.Dequeue();
            m_curLoadingCmd.Execute();
        }
        if (m_curLoadingCmd != null && m_curLoadingCmd.m_bDone)
        {
            if (m_curLoadingCmd.m_bFinalCmd)
            {
                m_curLoadingStep = LoadingStep.eLoadingComplete;
            }
            m_curLoadingCmd = null;
        }
        if (m_curLoadingStep == LoadingStep.eInit)
        {
            return;
        }

        if (m_wait != null)
        {
            m_wait.Update(Time.deltaTime);
        }

        GameMatch_PVP match = GameSystem.Instance.mClient.mCurMatch as GameMatch_PVP;

        if (match == null)
        {
            if (m_curLoadingStep == LoadingStep.eLoadingComplete)
            {
                if (onComplete != null)
                {
                    onComplete();
                }
                Object.Destroy(gameObject);
            }
        }
        else
        {
            if (m_curLoadingStep == LoadingStep.eLoadedScene && match.m_bPlayerDataReady && !m_pvpLoadPlayer)
            {
                LoadCharacter(GameSystem.Instance.mClient.mPlayerManager, match);
                m_pvpLoadPlayer = true;
            }

            if (m_curLoadingStep == LoadingStep.eLoadedPlayers && !m_pvpLoadUI)
            {
                LoadUI(match);
                m_pvpLoadUI = true;
            }

            if (m_curLoadingStep == LoadingStep.eLoadingComplete && !m_pvpLoadComplete)
            {
                if (onComplete != null)
                {
                    onComplete();
                }
                m_pvpLoadComplete = true;
                GameMsgSender.SendLoadingComplete(match.GetMatchType());
            }

            if (m_curLoadingStep == LoadingStep.eLoadingComplete && disConnected)
            {
                disConnected = false;
                ShowOffLine();
            }

            if (m_delayDestroy && !MainPlayer.Instance.inPvpJoining)
            {
//               if( m_delayLoadLua != null)
//               {
//                   m_delayLoadLua.ForEach((LuaComponent item) =>
//                                 {
//                                     item.table.Set("loadingState", CommonFunction.GetConstString("STR_LOAD_COMPLETE"));
//                                     item.table.Set("loadDone", true);
//                                 });

//               }
                Object.Destroy(gameObject);
            }
        }
    }