public async Task TalkingStick_Race_PresenterLeaves_RemoveScene()
{
// arrange
var(conn, conference) = await ConnectToOpenedConference();
AssertSuccess(await conn.Hub.InvokeAsync <SuccessOrError <Unit> >(nameof(CoreHub.SetScene),
new TalkingStickScene(TalkingStickMode.Race)));
var pleb = CreateUser();
var plebConn = await ConnectUserToConference(pleb, conference);
AssertSuccess(await plebConn.Hub.InvokeAsync <SuccessOrError <Unit> >(nameof(CoreHub.TalkingStickTake)));
await conn.SyncObjects.AssertSyncObject <SynchronizedScene>(
SynchronizedScene.SyncObjId(RoomOptions.DEFAULT_ROOM_ID), syncObj =>
{
Assert.Equal(syncObj.SceneStack, new IScene[]
{
new TalkingStickScene(TalkingStickMode.Race), new PresenterScene(pleb.Sub),
new ActiveSpeakerScene(),
});
});
// act
await plebConn.Hub.DisposeAsync();
// assert
await conn.SyncObjects.AssertSyncObject <SynchronizedScene>(
SynchronizedScene.SyncObjId(RoomOptions.DEFAULT_ROOM_ID), syncObj =>
{
Assert.Equal(syncObj.SceneStack, new IScene[]
{
new TalkingStickScene(TalkingStickMode.Race),
});
});
}
public async Task TalkingStick_Race_ParticipantsTakeStick_MakePresenter()
{
// arrange
var(conn, conference) = await ConnectToOpenedConference();
AssertSuccess(await conn.Hub.InvokeAsync <SuccessOrError <Unit> >(nameof(CoreHub.SetScene),
new TalkingStickScene(TalkingStickMode.Race)));
var pleb = CreateUser();
var plebConn = await ConnectUserToConference(pleb, conference);
// act
AssertSuccess(await plebConn.Hub.InvokeAsync <SuccessOrError <Unit> >(nameof(CoreHub.TalkingStickTake)));
// assert
await conn.SyncObjects.AssertSyncObject <SynchronizedScene>(
SynchronizedScene.SyncObjId(RoomOptions.DEFAULT_ROOM_ID), syncObj =>
{
Assert.Equal(syncObj.SceneStack, new IScene[]
{
new TalkingStickScene(TalkingStickMode.Race), new PresenterScene(pleb.Sub),
new ActiveSpeakerScene(),
});
});
await plebConn.SyncObjects.AssertSyncObject <SynchronizedParticipantPermissions>(
SynchronizedParticipantPermissions.SyncObjId(pleb.Sub),
permissions =>
{
Assert.Contains(permissions.Permissions,
x => Equals(x, DefinedPermissions.Scenes.CanOverwriteContentScene.Configure(true)));
});
}
public async Task TalkingStick_Queue_Enqueue_MakePresenter()
{
// arrange
var(conn, conference) = await ConnectToOpenedConference();
AssertSuccess(await conn.Hub.InvokeAsync <SuccessOrError <Unit> >(nameof(CoreHub.SetScene),
new TalkingStickScene(TalkingStickMode.Queue)));
var pleb = CreateUser();
var plebConn = await ConnectUserToConference(pleb, conference);
// act
AssertSuccess(await plebConn.Hub.InvokeAsync <SuccessOrError <Unit> >(nameof(CoreHub.TalkingStickEnqueue)));
// assert
await conn.SyncObjects.AssertSyncObject <SynchronizedScene>(
SynchronizedScene.SyncObjId(RoomOptions.DEFAULT_ROOM_ID), syncObj =>
{
Assert.Equal(syncObj.SceneStack, new IScene[]
{
new TalkingStickScene(TalkingStickMode.Queue), new PresenterScene(pleb.Sub),
new ActiveSpeakerScene(),
});
});
await conn.SyncObjects.AssertSyncObject <SynchronizedSceneTalkingStick>(
SynchronizedSceneTalkingStick.SyncObjId(RoomOptions.DEFAULT_ROOM_ID), syncObj =>
{
Assert.Equal(pleb.Sub, syncObj.CurrentSpeakerId);
Assert.Empty(syncObj.SpeakerQueue);
});
}
public async Task TalkingStick_Moderated_PassToParticipant_MakePresenter()
{
// arrange
var(conn, conference) = await ConnectToOpenedConference();
AssertSuccess(await conn.Hub.InvokeAsync <SuccessOrError <Unit> >(nameof(CoreHub.SetScene),
new TalkingStickScene(TalkingStickMode.Moderated)));
var pleb = CreateUser();
await ConnectUserToConference(pleb, conference);
await conn.SyncObjects.AssertSyncObject <SynchronizedRooms>(SynchronizedRooms.SyncObjId,
participants => Assert.Equal(2, participants.Participants.Count));
// act
AssertSuccess(await conn.Hub.InvokeAsync <SuccessOrError <Unit> >(nameof(CoreHub.TalkingStickPass), pleb.Sub));
// assert
await conn.SyncObjects.AssertSyncObject <SynchronizedScene>(
SynchronizedScene.SyncObjId(RoomOptions.DEFAULT_ROOM_ID), syncObj =>
{
Assert.Equal(syncObj.SceneStack, new IScene[]
{
new TalkingStickScene(TalkingStickMode.Moderated), new PresenterScene(pleb.Sub),
new ActiveSpeakerScene(),
});
});
await conn.SyncObjects.AssertSyncObject <SynchronizedSceneTalkingStick>(
SynchronizedSceneTalkingStick.SyncObjId(RoomOptions.DEFAULT_ROOM_ID),
syncObj => { Assert.Equal(pleb.Sub, syncObj.CurrentSpeakerId); });
}
public async ValueTask <IEnumerable <PermissionLayer> > FetchPermissionsForParticipant(Participant participant)
{
var rooms = await _mediator.FetchSynchronizedObject <SynchronizedRooms>(participant.ConferenceId,
SynchronizedRooms.SyncObjId);
if (!rooms.Participants.TryGetValue(participant.Id, out var roomId))
{
return(Enumerable.Empty <PermissionLayer>());
}
var permissions = new List <PermissionLayer>();
var scenes = await _mediator.FetchSynchronizedObject <SynchronizedScene>(participant.ConferenceId,
SynchronizedScene.SyncObjId(roomId));
foreach (var scene in scenes.SceneStack)
{
var provider = FindProviderForScene(scene);
var sceneLayers = await provider.FetchPermissionsForParticipant(scene, participant, scenes.SceneStack);
permissions.AddRange(sceneLayers);
}
return(permissions);
}
public async ValueTask InvalidateTalkingSceneWithLockAcquired(string conferenceId, string roomId)
{
var scenes =
await _mediator.FetchSynchronizedObject <SynchronizedScene>(conferenceId,
SynchronizedScene.SyncObjId(roomId));
var talkingStickScene = GetTalkingStickScene(scenes);
if (talkingStickScene == null)
{
return;
}
var rooms = await _mediator.FetchSynchronizedObject <SynchronizedRooms>(conferenceId,
SynchronizedRooms.SyncObjId);
var currentSpeaker = await _repository.GetCurrentSpeaker(conferenceId, roomId);
currentSpeaker = await VerifyCurrentSpeakerInRoom(currentSpeaker, roomId, rooms);
if (currentSpeaker == null)
{
await ElectNewCurrentSpeaker(conferenceId, roomId, rooms, talkingStickScene.Mode);
}
}
/// <summary>
/// Causes this ped to start performing the specified <see cref="SynchronizedScene"/>
/// </summary>
/// <param name="ped">The target ped</param>
/// <param name="duration">in second</param>
/// <param name="flag">can be 0 or 16</param>
/// <returns></returns>
public static Rage.Task StartSynchronizedScene(this Ped ped, SynchronizedScene synchronizedScene, AnimationDictionary animDictionary, string animationName, float speed, float speedMultiplier, int duration, int flag, float playbackRate)
{
animDictionary.LoadAndWait();
uint handle = synchronizedScene.Handle;
NativeWrappers.TaskSynchronizedScene(ped, handle, animDictionary, animationName, speed, speedMultiplier, duration, flag, playbackRate, 0);
return(Rage.Task.GetTask(ped, "TASK_SYNCHRONIZED_SCENE"));
}
public static bool HasSceneStackChanged(SynchronizedScene current, SynchronizedScene?previous)
{
if (previous == null)
{
return(true);
}
return(!current.SceneStack.SequenceEqual(previous.SceneStack));
}
public void HasSceneStackChanged_PreviousNull_ReturnTrue()
{
// arrange
var current = new SynchronizedScene(AutonomousScene.Instance, null, ImmutableList <IScene> .Empty,
ImmutableList <IScene> .Empty);
SynchronizedScene?previous = null;
// act
var result = SceneUtilities.HasSceneStackChanged(current, previous);
// assert
Assert.True(result);
}
public async Task JoinToRoom_DoNothing_SynchronizeAvailableScenes()
{
// arrange
var(conn, _) = await ConnectToOpenedConference();
// assert
await conn.SyncObjects.AssertSyncObject <SynchronizedScene>(
SynchronizedScene.SyncObjId(RoomOptions.DEFAULT_ROOM_ID), syncObj =>
{
Assert.NotEmpty(syncObj.AvailableScenes);
Assert.Equal(AutonomousScene.Instance, syncObj.SelectedScene);
Assert.Equal(DefaultSceneStack, syncObj.SceneStack);
});
}
public async Task SetScene_MakePresenter_UpdateSceneStack()
{
// arrange
var(conn, _) = await ConnectToOpenedConference();
// act
await conn.Hub.InvokeAsync <SuccessOrError <Unit> >(nameof(CoreHub.SetScene),
new PresenterScene(conn.User.Sub));
// assert
await conn.SyncObjects.AssertSyncObject <SynchronizedScene>(
SynchronizedScene.SyncObjId(RoomOptions.DEFAULT_ROOM_ID),
syncObj => Assert.Equal(new IScene[] { new PresenterScene(conn.User.Sub), ActiveSpeakerScene.Instance },
syncObj.SceneStack));
}
public void HasSceneStackChanged_NotChanged_ReturnFalse()
{
// arrange
var current = new SynchronizedScene(AutonomousScene.Instance, null, ImmutableList <IScene> .Empty,
new IScene[] { AutonomousScene.Instance, GridScene.Instance });
var previous = new SynchronizedScene(GridScene.Instance, null, ImmutableList <IScene> .Empty,
new IScene[] { AutonomousScene.Instance, GridScene.Instance });
// act
var result = SceneUtilities.HasSceneStackChanged(current, previous);
// assert
Assert.False(result);
}
public async Task OpenBreakoutRooms_Joined_BreakoutRoomSceneBecomesAvailable()
{
// arrange
var(conn, _) = await ConnectToOpenedConference();
await conn.SyncObjects.AssertSyncObject(SynchronizedScene.SyncObjId(RoomOptions.DEFAULT_ROOM_ID),
(SynchronizedScene syncObj) =>
Assert.DoesNotContain(syncObj.AvailableScenes, x => x is BreakoutRoomScene));
// act
AssertSuccess(await conn.Hub.InvokeAsync <SuccessOrError <Unit> >(nameof(CoreHub.OpenBreakoutRooms),
new OpenBreakoutRoomsDto(5, null, null, null)));
// assert
await conn.SyncObjects.AssertSyncObject <SynchronizedScene>(
SynchronizedScene.SyncObjId(RoomOptions.DEFAULT_ROOM_ID),
syncObj => Assert.Contains(syncObj.AvailableScenes, x => x is BreakoutRoomScene));
}
public async Task SetScene_SceneIsAvailable_UpdateSynchronizedObject()
{
// arrange
var(conn, _) = await ConnectToOpenedConference();
// act
var result = await conn.Hub.InvokeAsync <SuccessOrError <Unit> >(nameof(CoreHub.SetScene), GridScene.Instance);
// assert
AssertSuccess(result);
await conn.SyncObjects.AssertSyncObject <SynchronizedScene>(
SynchronizedScene.SyncObjId(RoomOptions.DEFAULT_ROOM_ID), syncObj =>
{
Assert.Equal(GridScene.Instance, syncObj.SelectedScene);
Assert.Single(syncObj.SceneStack, GridScene.Instance);
});
}
public async Task SetScene_SceneIsNotAvailable_DontChangeCurrentScene()
{
// arrange
var(conn, _) = await ConnectToOpenedConference();
var current =
await conn.SyncObjects.WaitForSyncObj <SynchronizedScene>(
SynchronizedScene.SyncObjId(RoomOptions.DEFAULT_ROOM_ID));
// act
await conn.Hub.InvokeAsync <SuccessOrError <Unit> >(nameof(CoreHub.SetScene), new ScreenShareScene("5342"));
// assert
await conn.SyncObjects.AssertSyncObject <SynchronizedScene>(
SynchronizedScene.SyncObjId(RoomOptions.DEFAULT_ROOM_ID),
syncObj => Assert.Equal(current.SceneStack, syncObj.SceneStack));
}
public async Task SetOverwrittenScene_SceneIsNotAvailable_DontSetScene()
{
// arrange
var(conn, _) = await ConnectToOpenedConference();
// act
var result = await conn.Hub.InvokeAsync <SuccessOrError <Unit> >(nameof(CoreHub.SetOverwrittenScene),
new ScreenShareScene("1235"));
// assert
AssertSuccess(result);
await conn.SyncObjects.AssertSyncObject <SynchronizedScene>(
SynchronizedScene.SyncObjId(RoomOptions.DEFAULT_ROOM_ID), syncObj =>
{
Assert.Null(syncObj.OverwrittenContent);
Assert.Equal(syncObj.SceneStack, DefaultSceneStack);
});
}
public async Task <Unit> Handle(UpdateScenesRequest request, CancellationToken cancellationToken)
{
var(conferenceId, roomId) = request;
await using (await _sceneRepository.LockScene(conferenceId, roomId))
{
var scene = await _sceneRepository.GetScene(conferenceId, roomId);
scene ??= SynchronizedSceneProvider.GetDefaultActiveScene();
var state = await _sceneRepository.GetSceneState(conferenceId, roomId);
state ??= SynchronizedSceneProvider.GetEmptySceneState();
await ApplyScene(conferenceId, roomId, scene, state);
}
await _mediator.Send(
new UpdateSynchronizedObjectRequest(conferenceId, SynchronizedScene.SyncObjId(roomId)));
return(Unit.Value);
}
public async Task CloseBreakoutRooms_BreakoutRoomIsCurrentScene_RemoveCurrentScene()
{
// arrange
var(conn, _) = await ConnectToOpenedConference();
// act
AssertSuccess(await conn.Hub.InvokeAsync <SuccessOrError <Unit> >(nameof(CoreHub.OpenBreakoutRooms),
new OpenBreakoutRoomsDto(5, null, null, null)));
AssertSuccess(
await conn.Hub.InvokeAsync <SuccessOrError <Unit> >(nameof(CoreHub.SetScene), BreakoutRoomScene.Instance));
await conn.SyncObjects.AssertSyncObject <SynchronizedScene>(
SynchronizedScene.SyncObjId(RoomOptions.DEFAULT_ROOM_ID),
syncObj => Assert.Equal(BreakoutRoomScene.Instance, syncObj.SelectedScene));
AssertSuccess(await conn.Hub.InvokeAsync <SuccessOrError <Unit> >(nameof(CoreHub.CloseBreakoutRooms)));
// assert
await conn.SyncObjects.AssertSyncObject <SynchronizedScene>(
SynchronizedScene.SyncObjId(RoomOptions.DEFAULT_ROOM_ID),
syncObj => Assert.Equal(AutonomousScene.Instance, syncObj.SelectedScene));
}
public static void Command_SynchronizedSceneTest()
{
if (BenchThreadActivated)
{
return;
}
GameFiber.StartNew(delegate
{
BenchThreadActivated = true;
SynchronizedScene syncScene = null;
List <uint> benchHash = new List <uint>()
{
0x6ba514ac, //prop_bench_01a
0x7977b051, //prop_bench_01b
0xb78a2c75, //prop_bench_01c
0xda867f80, //prop_bench_02
0xc0a6cbcd, //prop_bench_03
0xd2786f70, //prop_bench_04
0x9ec80810, //prop_bench_05
0xb17ead7d, //prop_bench_06
0xfbbe41fb, //prop_bench_07
0xe7ed1a59, //prop_bench_08
0xfa11bea2, //prop_bench_09
0x1a117fd1, //prop_bench_10
0x4cece57b, //prop_bench_11
0xfbca504f, //prop_fib_3b_bench
0x723e2ae0, //prop_ld_bench01
0x0ff3a92b, //prop_wait_bench_01
0x5515a05a, //v_res_fh_benchlong
0x883cb2e8, //v_res_fh_benchshort
0xbac3f7a8, //v_ind_rc_bench
0x90aa8a87, //hei_heist_stn_benchshort
};
Rage.Object bench = null;
int benchStatus = 0;
Vector3 benchInitialPos = Vector3.Zero;
Vector3 sitPos = Vector3.Zero;
Rage.Task closeTask = null;
string sitStr = Game.GetLocalizedString("MPTV_WALK"); //Press ~INPUT_CONTEXT~ to sit down.
string standUpStr = Game.GetLocalizedString("MPOFSEAT_PCEXIT");
string[] benchIdles = { "idle_a", "idle_b", "idle_c" };
AnimationDictionary seating = Game.LocalPlayer.Character.IsMale ? "anim@amb@office@seating@male@var_a@base@" : "anim@amb@office@seating@female@var_d@base@";
seating.LoadAndWait();
while (true)
{
GameFiber.Yield();
if (Game.LocalPlayer.Character.IsInAnyVehicle(false) || Game.LocalPlayer.Character.IsDead || Game.IsPaused || Game.Console.IsOpen || Game.IsScreenFadingOut)
{
continue;
}
switch (benchStatus)
{
case 0:
Entity[] objs = World.GetEntities(Game.LocalPlayer.Character.Position, 2f, GetEntitiesFlags.ConsiderAllObjects).ToArray();
bench = (Rage.Object)objs.Where(x => x && benchHash.Contains(x.Model.Hash)).OrderBy(x => Vector3.DistanceSquared(x.Position, Game.LocalPlayer.Character)).FirstOrDefault();
if (!bench)
{
break;
}
Game.DisplayHelp(sitStr, 100);
if (Game.IsControlPressed(2, GameControl.Context))
{
benchStatus = 1;
}
break;
case 1:
sitPos = bench.Position + bench.RightVector * 0.85f;
benchInitialPos = sitPos + bench.ForwardVector * -1;
closeTask = Game.LocalPlayer.Character.Tasks.FollowNavigationMeshToPosition(benchInitialPos, bench.Heading - 180, 1f, 10000);
benchStatus = 2;
break;
case 2:
if (closeTask.Status == TaskStatus.InProgress)
{
break;
}
syncScene = new SynchronizedScene(sitPos, bench.Rotation);
synchronizedScenes.Add(syncScene);
syncScene.TaskToPed(Game.LocalPlayer.Character, seating, "enter", 13);
benchStatus = 3;
break;
case 3:
if (syncScene.Phase != 1f)
{
break;
}
syncScene = new SynchronizedScene(sitPos, bench.Rotation);
synchronizedScenes.Add(syncScene);
syncScene.TaskToPed(Game.LocalPlayer.Character, seating, "base", 13, playbackRate: 1148846080);
benchStatus = 4;
break;
case 4:
Game.DisplayHelp(standUpStr, 100);
if (Game.IsControlPressed(2, GameControl.ScriptRRight))
{
benchStatus = 5;
}
if (syncScene.Phase != 1f)
{
break;
}
syncScene = new SynchronizedScene(sitPos, bench.Rotation);
synchronizedScenes.Add(syncScene);
syncScene.TaskToPed(Game.LocalPlayer.Character, seating, benchIdles.GetRandomElement(), 13, playbackRate: 1148846080);
benchStatus = 3;
break;
case 5:
syncScene = new SynchronizedScene(sitPos, bench.Rotation);
synchronizedScenes.Add(syncScene);
syncScene.TaskToPed(Game.LocalPlayer.Character, seating, "exit", 13, playbackRate: 1000f);
benchStatus = 6;
break;
case 6:
if (syncScene.Phase != 1f)
{
break;
}
Game.LocalPlayer.Character.Tasks.Clear();
synchronizedScenes.ForEach(x =>
{
if (x.IsValid())
{
x.Delete();
}
});
synchronizedScenes = new List <SynchronizedScene>();
benchStatus = 0;
break;
}
}
});
}
private TalkingStickScene?GetTalkingStickScene(SynchronizedScene scenes)
{
return(scenes.SceneStack.OfType <TalkingStickScene>().LastOrDefault());
}
public async Task JoinRoom_DoNothing_HasSceneStack()
{
// arrange
await Mediator.Send(new OpenConferenceRequest(ConferenceId));
// act
await JoinParticipant(TestData.Sven);
// assert
var scenes = SynchronizedObjectListener.GetSynchronizedObject <SynchronizedScene>(TestData.Sven.Participant,
SynchronizedScene.SyncObjId(DefaultRoomId));
Assert.Equal(SynchronizedSceneProvider.GetDefaultScene(), scenes.SelectedScene);
Assert.Equal(DefaultSceneStack, scenes.SceneStack);
Assert.Null(scenes.OverwrittenContent);
Assert.NotNull(scenes.AvailableScenes);
}
public async Task SetSceneRequest_InvalidScene_UpdateSynchronizedObject()
{
// arrange
await Mediator.Send(new OpenConferenceRequest(ConferenceId));
await JoinParticipant(TestData.Sven);
var scene = new ScreenShareScene("some participant");
// act
await Mediator.Send(new SetSceneRequest(ConferenceId, DefaultRoomId, scene));
// assert
var scenes = SynchronizedObjectListener.GetSynchronizedObject <SynchronizedScene>(TestData.Sven.Participant,
SynchronizedScene.SyncObjId(DefaultRoomId));
Assert.Equal(DefaultSceneStack, scenes.SceneStack);
}
public async Task SetOverwrittenContentSceneRequest_ValidScene_UpdateSynchronizedObject()
{
// arrange
await Mediator.Send(new OpenConferenceRequest(ConferenceId));
await JoinParticipant(TestData.Sven);
var scene = ActiveSpeakerScene.Instance;
// act
await Mediator.Send(new SetOverwrittenContentSceneRequest(ConferenceId, DefaultRoomId, scene));
// assert
var scenes = SynchronizedObjectListener.GetSynchronizedObject <SynchronizedScene>(TestData.Sven.Participant,
SynchronizedScene.SyncObjId(DefaultRoomId));
Assert.Equal(DefaultSceneStack.Concat(new[] { ActiveSpeakerScene.Instance }), scenes.SceneStack);
Assert.Equal(scene, scenes.OverwrittenContent);
}
public async Task SetSceneRequest_BreakoutRoomsClosed_RevertToOverwrittenScene()
{
// arrange
await Mediator.Send(new OpenConferenceRequest(ConferenceId));
await JoinParticipant(TestData.Sven);
await Mediator.Send(new OpenBreakoutRoomsRequest(5, null, null, null, ConferenceId));
await Mediator.Send(new SetSceneRequest(ConferenceId, DefaultRoomId, BreakoutRoomScene.Instance));
await Mediator.Send(new SetOverwrittenContentSceneRequest(ConferenceId, DefaultRoomId, GridScene.Instance));
var scenes = SynchronizedObjectListener.GetSynchronizedObject <SynchronizedScene>(TestData.Sven.Participant,
SynchronizedScene.SyncObjId(DefaultRoomId));
Assert.Equal(new IScene[] { BreakoutRoomScene.Instance, GridScene.Instance }, scenes.SceneStack);
// act
await Mediator.Send(new CloseBreakoutRoomsRequest(ConferenceId));
// assert
scenes = SynchronizedObjectListener.GetSynchronizedObject <SynchronizedScene>(TestData.Sven.Participant,
SynchronizedScene.SyncObjId(DefaultRoomId));
Assert.Equal(GridScene.Instance, scenes.SelectedScene);
Assert.Null(scenes.OverwrittenContent);
Assert.Equal(new IScene[] { GridScene.Instance }, scenes.SceneStack);
}
public async Task ConferenceChanged_DefaultSceneSelected_UpdateSynchronizedObject()
{
// arrange
await Mediator.Send(new OpenConferenceRequest(ConferenceId));
await JoinParticipant(TestData.Sven);
var scenes = SynchronizedObjectListener.GetSynchronizedObject <SynchronizedScene>(TestData.Sven.Participant,
SynchronizedScene.SyncObjId(DefaultRoomId));
Assert.Equal(DefaultSceneStack, scenes.SceneStack);
// act
var patchResult = await Mediator.Send(new PatchConferenceRequest(ConferenceId,
new JsonPatchDocument <ConferenceData>().Add(x => x.Configuration.Scenes.DefaultScene,
SceneOptions.BasicSceneType.ActiveSpeaker)));
Assert.True(patchResult.Success);
// assert
scenes = SynchronizedObjectListener.GetSynchronizedObject <SynchronizedScene>(TestData.Sven.Participant,
SynchronizedScene.SyncObjId(DefaultRoomId));
Assert.Equal(new IScene[] { AutonomousScene.Instance, ActiveSpeakerScene.Instance }, scenes.SceneStack);
}
private void AssertSceneStack(Participant participant, params IScene[] expectedStack)
{
var scenes = SynchronizedObjectListener.GetSynchronizedObject <SynchronizedScene>(participant,
SynchronizedScene.SyncObjId(DefaultRoomId));
Assert.Equal(expectedStack, scenes.SceneStack);
}
public async Task SetScene_SetToTalkingStick_UpdateSynchronizedObject()
{
// arrange
await Mediator.Send(new OpenConferenceRequest(ConferenceId));
await JoinParticipant(TestData.Sven);
var talkingStickScene = new TalkingStickScene(TalkingStickMode.Queue);
// act
await Mediator.Send(new SetSceneRequest(ConferenceId, DefaultRoomId, talkingStickScene));
// assert
var scenes = SynchronizedObjectListener.GetSynchronizedObject <SynchronizedScene>(TestData.Sven.Participant,
SynchronizedScene.SyncObjId(DefaultRoomId));
Assert.Equal(talkingStickScene, scenes.SelectedScene);
Assert.Equal(new[] { talkingStickScene }, scenes.SceneStack);
}
