Exemple #1
0
        public override void SetUpSteps()
        {
            base.SetUpSteps();

            AddStep("import beatmap", () =>
            {
                beatmaps.Import(TestResources.GetQuickTestBeatmapForImport()).Wait();
                importedSet = beatmaps.GetAllUsableBeatmapSetsEnumerable(IncludedDetails.All).First();
            });

            AddStep("load multiplayer", () => LoadScreen(multiplayerScreenStack = new TestMultiplayerScreenStack()));
            AddUntilStep("wait for multiplayer to load", () => multiplayerScreenStack.IsLoaded);
            AddUntilStep("wait for lounge to load", () => this.ChildrenOfType <MultiplayerLoungeSubScreen>().FirstOrDefault()?.IsLoaded == true);
        }
        public new void Setup() => Schedule(() =>
        {
            AvailabilityTracker.SelectedItem.BindTo(selectedItem);

            importedSet        = beatmaps.GetAllUsableBeatmapSetsEnumerable(IncludedDetails.All).First();
            Beatmap.Value      = beatmaps.GetWorkingBeatmap(importedSet.Beatmaps.First());
            selectedItem.Value = new PlaylistItem
            {
                Beatmap = { Value = Beatmap.Value.BeatmapInfo },
                Ruleset = { Value = Beatmap.Value.BeatmapInfo.Ruleset },
            };

            Child = new FillFlowContainer
            {
                AutoSizeAxes = Axes.Both,
                Direction    = FillDirection.Vertical,
                Children     = new Drawable[]
                {
                    spectateButton = new MultiplayerSpectateButton
                    {
                        Anchor          = Anchor.Centre,
                        Origin          = Anchor.Centre,
                        Size            = new Vector2(200, 50),
                        OnSpectateClick = () =>
                        {
                            readyClickOperation = OngoingOperationTracker.BeginOperation();

                            Task.Run(async() =>
                            {
                                await Client.ToggleSpectate();
                                readyClickOperation.Dispose();
                            });
                        }
                    },
                    readyButton = new MultiplayerReadyButton
                    {
                        Anchor       = Anchor.Centre,
                        Origin       = Anchor.Centre,
                        Size         = new Vector2(200, 50),
                        OnReadyClick = () =>
                        {
                            readyClickOperation = OngoingOperationTracker.BeginOperation();

                            Task.Run(async() =>
                            {
                                if (Client.IsHost && Client.LocalUser?.State == MultiplayerUserState.Ready)
                                {
                                    await Client.StartMatch();
                                    return;
                                }

                                await Client.ToggleReady();

                                readyClickOperation.Dispose();
                            });
                        }
                    }
                }
            };
        });
Exemple #3
0
        public new void Setup() => Schedule(() =>
        {
            importedSet        = beatmaps.GetAllUsableBeatmapSetsEnumerable(IncludedDetails.All).First();
            Beatmap.Value      = beatmaps.GetWorkingBeatmap(importedSet.Beatmaps.First());
            selectedItem.Value = new PlaylistItem
            {
                Beatmap = { Value = Beatmap.Value.BeatmapInfo },
                Ruleset = { Value = Beatmap.Value.BeatmapInfo.Ruleset },
            };

            if (button != null)
            {
                Remove(button);
            }

            Add(button = new MultiplayerReadyButton
            {
                Anchor       = Anchor.Centre,
                Origin       = Anchor.Centre,
                Size         = new Vector2(200, 50),
                OnReadyClick = async() =>
                {
                    readyClickOperation = OngoingOperationTracker.BeginOperation();

                    if (Client.IsHost && Client.LocalUser?.State == MultiplayerUserState.Ready)
                    {
                        await Client.StartMatch();
                        return;
                    }

                    await Client.ToggleReady();
                    readyClickOperation.Dispose();
                }
            });
        });
        private void load(BeatmapManager beatmaps)
        {
            this.beatmaps = beatmaps;

            BeatmapSet.BindValueChanged(setInfo =>
            {
                if (setInfo.NewValue == null)
                {
                    attachDownload(null);
                }
                else if (beatmaps.GetAllUsableBeatmapSetsEnumerable().Any(s => s.OnlineBeatmapSetID == setInfo.NewValue.OnlineBeatmapSetID))
                {
                    State.Value = DownloadState.LocallyAvailable;
                }
                else
                {
                    attachDownload(beatmaps.GetExistingDownload(setInfo.NewValue));
                }
            }, true);

            beatmaps.BeatmapDownloadBegan += download =>
            {
                if (download.BeatmapSet.OnlineBeatmapSetID == BeatmapSet.Value?.OnlineBeatmapSetID)
                {
                    attachDownload(download);
                }
            };

            beatmaps.ItemAdded   += setAdded;
            beatmaps.ItemRemoved += setRemoved;
        }
Exemple #5
0
        private void load(GameHost host, AudioManager audio)
        {
            Dependencies.Cache(rulesets = new RulesetStore(ContextFactory));
            Dependencies.Cache(beatmaps = new BeatmapManager(LocalStorage, ContextFactory, rulesets, null, audio, host, Beatmap.Default));
            beatmaps.Import(TestResources.GetQuickTestBeatmapForImport()).Wait();

            importedSet = beatmaps.GetAllUsableBeatmapSetsEnumerable(IncludedDetails.All).First();
        }
        public new void SetUpSteps()
        {
            AddStep("import beatmap", () =>
            {
                beatmaps.Import(TestResources.GetQuickTestBeatmapForImport()).Wait();
                importedSet     = beatmaps.GetAllUsableBeatmapSetsEnumerable(IncludedDetails.All).First();
                importedBeatmap = importedSet.Beatmaps.First(b => b.RulesetID == 0);
            });

            AddStep("change to all players mode", () => Client.ChangeSettings(new MultiplayerRoomSettings {
                QueueMode = QueueMode.AllPlayers
            }));
        }
Exemple #7
0
        public override void SetUpSteps()
        {
            base.SetUpSteps();

            AddStep("import beatmap", () =>
            {
                beatmaps.Import(TestResources.GetQuickTestBeatmapForImport()).Wait();
                importedSet    = beatmaps.GetAllUsableBeatmapSetsEnumerable(IncludedDetails.All).First();
                InitialBeatmap = importedSet.Beatmaps.First(b => b.RulesetID == 0);
                OtherBeatmap   = importedSet.Beatmaps.Last(b => b.RulesetID == 0);
            });

            AddStep("load multiplayer", () => LoadScreen(multiplayerScreenStack = new TestMultiplayerScreenStack()));
            AddUntilStep("wait for multiplayer to load", () => multiplayerScreenStack.IsLoaded);
            AddUntilStep("wait for lounge to load", () => this.ChildrenOfType <MultiplayerLoungeSubScreen>().FirstOrDefault()?.IsLoaded == true);

            AddUntilStep("wait for lounge", () => multiplayerScreenStack.ChildrenOfType <LoungeSubScreen>().SingleOrDefault()?.IsLoaded == true);
            AddStep("open room", () => multiplayerScreenStack.ChildrenOfType <LoungeSubScreen>().Single().Open(new Room
            {
                Name      = { Value = "Test Room" },
                QueueMode = { Value = Mode },
                Playlist  =
                {
                    new PlaylistItem
                    {
                        Beatmap ={ Value               = InitialBeatmap               },
                        Ruleset ={ Value               = new OsuRuleset().RulesetInfo },
                    }
                }
            }));

            AddUntilStep("wait for room open", () => this.ChildrenOfType <MultiplayerMatchSubScreen>().FirstOrDefault()?.IsLoaded == true);
            AddWaitStep("wait for transition", 2);

            AddStep("create room", () =>
            {
                InputManager.MoveMouseTo(this.ChildrenOfType <MultiplayerMatchSettingsOverlay.CreateOrUpdateButton>().Single());
                InputManager.Click(MouseButton.Left);
            });

            AddUntilStep("wait for join", () => RoomManager.RoomJoined);
        }
        public new void Setup() => Schedule(() =>
        {
            importedSet   = beatmaps.GetAllUsableBeatmapSetsEnumerable(IncludedDetails.All).First();
            Beatmap.Value = beatmaps.GetWorkingBeatmap(importedSet.Beatmaps.First());

            Child = button = new MultiplayerReadyButton
            {
                Anchor       = Anchor.Centre,
                Origin       = Anchor.Centre,
                Size         = new Vector2(200, 50),
                SelectedItem =
                {
                    Value       = new PlaylistItem
                    {
                        Beatmap = { Value = Beatmap.Value.BeatmapInfo         },
                        Ruleset = { Value = Beatmap.Value.BeatmapInfo.Ruleset }
                    }
                }
            };
        });
        public new void Setup() => Schedule(() =>
        {
            var beatmap = beatmaps.GetAllUsableBeatmapSetsEnumerable(IncludedDetails.All).First().Beatmaps.First();

            Beatmap.Value = beatmaps.GetWorkingBeatmap(beatmap);

            Child = button = new RealtimeReadyButton
            {
                Anchor       = Anchor.Centre,
                Origin       = Anchor.Centre,
                Size         = new Vector2(200, 50),
                SelectedItem =
                {
                    Value       = new PlaylistItem
                    {
                        Beatmap = { Value = beatmap         },
                        Ruleset = { Value = beatmap.Ruleset }
                    }
                }
            };

            Client.AddUser(API.LocalUser.Value);
        });