public static void HandleWindowItems(IPacket _packet, MultiplayerClient client)
{
var packet = (WindowItemsPacket)_packet;
if (packet.WindowID == 0)
client.Inventory.SetSlots(packet.Items);
else
client.CurrentWindow.SetSlots(packet.Items);
}
public static void HandlePositionAndLook(IPacket _packet, MultiplayerClient client)
{
var packet = (SetPlayerPositionPacket)_packet;
client._Position = new Vector3(packet.X, packet.Y, packet.Z);
client.QueuePacket(packet);
client.LoggedIn = true;
// TODO: Pitch and yaw
}
public static void HandleHandshake(IPacket _packet, MultiplayerClient client)
{
var packet = (HandshakeResponsePacket)_packet;
if (packet.ConnectionHash != "-")
{
Console.WriteLine("Online mode is not supported");
Process.GetCurrentProcess().Kill();
}
// TODO: Authentication
client.QueuePacket(new LoginRequestPacket(PacketReader.Version, client.User.Username));
}
public static void RegisterHandlers(MultiplayerClient client)
{
client.RegisterPacketHandler(new HandshakeResponsePacket().ID, HandleHandshake);
client.RegisterPacketHandler(new ChatMessagePacket().ID, HandleChatMessage);
client.RegisterPacketHandler(new SetPlayerPositionPacket().ID, HandlePositionAndLook);
client.RegisterPacketHandler(new LoginResponsePacket().ID, HandleLoginResponse);
client.RegisterPacketHandler(new ChunkPreamblePacket().ID, ChunkHandler.HandleChunkPreamble);
client.RegisterPacketHandler(new ChunkDataPacket().ID, ChunkHandler.HandleChunkData);
client.RegisterPacketHandler(new BlockChangePacket().ID, ChunkHandler.HandleBlockChange);
}
public static void HandleOpenWindowPacket(IPacket _packet, MultiplayerClient client)
{
var packet = (OpenWindowPacket)_packet;
IWindow window = null;
switch (packet.Type)
{
case 1: // Crafting bench window
window = new CraftingBenchWindow(client.CraftingRepository, client.Inventory);
break;
}
window.ID = packet.WindowID;
client.CurrentWindow = window;
}
public ChatInterface(MultiplayerClient client, KeyboardComponent keyboard, FontRenderer font)
{
Client = client;
Keyboard = keyboard;
Font = font;
Input = string.Empty;
Messages = new List<ChatMessage>();
DummyTexture = new Texture2D(keyboard.Game.GraphicsDevice, 1, 1);
DummyTexture.SetData(new[] { Color.White });
Client.ChatMessage += OnChatMessage;
Keyboard.KeyDown += OnKeyDown;
}
private void mouseTimerTick(MultiplayerClient client)
{
int curX = System.Windows.Forms.Cursor.Position.X;
int curY = System.Windows.Forms.Cursor.Position.Y;
if (lastX != -1)
{
float velX = curX - lastX;
float velY = curY - lastY;
client.clientPos += new Vector3(velX / 10f, 0, velY / 10f);
client.PacketSender.UpdatePlayerLocation(client.clientPos, Quaternion.identity, Quaternion.identity, Optional <VehicleModel> .Empty(), Optional <String> .Empty());
}
lastX = curX;
lastY = curY;
}
public void TestStartWithCountdown()
{
ClickButtonWhenEnabled <MultiplayerReadyButton>();
AddUntilStep("countdown button shown", () => this.ChildrenOfType <MultiplayerCountdownButton>().SingleOrDefault()?.IsPresent == true);
ClickButtonWhenEnabled <MultiplayerCountdownButton>();
AddStep("click the first countdown button", () =>
{
var popoverButton = this.ChildrenOfType <Popover>().Single().ChildrenOfType <OsuButton>().First();
InputManager.MoveMouseTo(popoverButton);
InputManager.Click(MouseButton.Left);
});
AddStep("finish countdown", () => MultiplayerClient.SkipToEndOfCountdown());
AddUntilStep("match started", () => MultiplayerClient.LocalUser?.State == MultiplayerUserState.WaitingForLoad);
}
public void TestBecomeHostWhileReady()
{
AddStep("add host", () =>
{
MultiplayerClient.AddUser(new APIUser {
Id = 2, Username = "******"
});
MultiplayerClient.TransferHost(2);
});
ClickButtonWhenEnabled <MultiplayerReadyButton>();
AddStep("make user host", () => MultiplayerClient.TransferHost(MultiplayerClient.Room?.Users[0].UserID ?? 0));
verifyGameplayStartFlow();
}
public void TestReadyButtonDisabledWhenNotHostAndUsersReady()
{
AddStep("add user and transfer host", () =>
{
MultiplayerClient.AddUser(new APIUser {
Id = PLAYER_1_ID
});
MultiplayerClient.TransferHost(PLAYER_1_ID);
});
AddStep("set user ready", () => MultiplayerClient.ChangeUserState(PLAYER_1_ID, MultiplayerUserState.Ready));
ClickButtonWhenEnabled <MultiplayerSpectateButton>();
assertReadyButtonEnablement(false);
}
public static void HandleSetSlot(IPacket _packet, MultiplayerClient client)
{
var packet = (SetSlotPacket)_packet;
IWindow window = null;
if (packet.WindowID == 0)
window = client.Inventory;
else
window = client.CurrentWindow;
if (window != null)
{
if (packet.SlotIndex >= 0 && packet.SlotIndex < window.Length)
{
window[packet.SlotIndex] = new ItemStack(packet.ItemID, packet.Count, packet.Metadata);
}
}
}
public void TestToggleStateWhenNotHost()
{
AddStep("add second user as host", () =>
{
MultiplayerClient.AddUser(new APIUser {
Id = 2, Username = "******"
});
MultiplayerClient.TransferHost(2);
});
ClickButtonWhenEnabled <MultiplayerReadyButton>();
AddUntilStep("user is ready", () => MultiplayerClient.Room?.Users[0].State == MultiplayerUserState.Ready);
ClickButtonWhenEnabled <MultiplayerReadyButton>();
AddUntilStep("user is idle", () => MultiplayerClient.Room?.Users[0].State == MultiplayerUserState.Idle);
}
public void TestCountdownWhileSpectating()
{
AddStep("set spectating", () => MultiplayerClient.ChangeUserState(API.LocalUser.Value.OnlineID, MultiplayerUserState.Spectating));
AddUntilStep("local user is spectating", () => MultiplayerClient.LocalUser?.State == MultiplayerUserState.Spectating);
AddAssert("countdown button is visible", () => this.ChildrenOfType <MultiplayerCountdownButton>().Single().IsPresent);
AddAssert("countdown button enabled", () => this.ChildrenOfType <MultiplayerCountdownButton>().Single().Enabled.Value);
AddStep("add second user", () => MultiplayerClient.AddUser(new APIUser {
Id = 2, Username = "******"
}));
AddAssert("countdown button enabled", () => this.ChildrenOfType <MultiplayerCountdownButton>().Single().Enabled.Value);
AddStep("set second user ready", () => MultiplayerClient.ChangeUserState(2, MultiplayerUserState.Ready));
AddAssert("countdown button enabled", () => this.ChildrenOfType <MultiplayerCountdownButton>().Single().Enabled.Value);
}
public override void Execute(MultiplayerClient client, string[] args)
{
Console.WriteLine("Mouse is now attached. Press any key to exit");
Timer mouseTimer = new Timer();
mouseTimer.Elapsed += delegate
{
MouseTimerTick(client);
};
mouseTimer.Interval = 50;
mouseTimer.Start();
Console.ReadKey();
lastX = -1;
lastY = -1;
mouseTimer.Stop();
}
private void verifyGameplayStartFlow()
{
AddUntilStep("user is ready", () => MultiplayerClient.Room?.Users[0].State == MultiplayerUserState.Ready);
ClickButtonWhenEnabled <MultiplayerReadyButton>();
AddUntilStep("user waiting for load", () => MultiplayerClient.Room?.Users[0].State == MultiplayerUserState.WaitingForLoad);
AddAssert("ready button disabled", () => !button.ChildrenOfType <OsuButton>().Single().Enabled.Value);
AddStep("transitioned to gameplay", () => readyClickOperation.Dispose());
AddStep("finish gameplay", () =>
{
MultiplayerClient.ChangeUserState(MultiplayerClient.Room?.Users[0].UserID ?? 0, MultiplayerUserState.Loaded);
MultiplayerClient.ChangeUserState(MultiplayerClient.Room?.Users[0].UserID ?? 0, MultiplayerUserState.FinishedPlay);
});
AddUntilStep("ready button enabled", () => button.ChildrenOfType <OsuButton>().Single().Enabled.Value);
}
public static void RegisterHandlers(MultiplayerClient client)
{
client.RegisterPacketHandler(new HandshakeResponsePacket().ID, HandleHandshake);
client.RegisterPacketHandler(new ChatMessagePacket().ID, HandleChatMessage);
client.RegisterPacketHandler(new SetPlayerPositionPacket().ID, HandlePositionAndLook);
client.RegisterPacketHandler(new LoginResponsePacket().ID, HandleLoginResponse);
client.RegisterPacketHandler(new UpdateHealthPacket().ID, HandleUpdateHealth);
client.RegisterPacketHandler(new ChunkPreamblePacket().ID, ChunkHandlers.HandleChunkPreamble);
client.RegisterPacketHandler(new ChunkDataPacket().ID, ChunkHandlers.HandleChunkData);
client.RegisterPacketHandler(new BlockChangePacket().ID, ChunkHandlers.HandleBlockChange);
client.RegisterPacketHandler(new WindowItemsPacket().ID, InventoryHandlers.HandleWindowItems);
client.RegisterPacketHandler(new SetSlotPacket().ID, InventoryHandlers.HandleSetSlot);
client.RegisterPacketHandler(new CloseWindowPacket().ID, InventoryHandlers.HandleCloseWindowPacket);
client.RegisterPacketHandler(new OpenWindowPacket().ID, InventoryHandlers.HandleOpenWindowPacket);
}
private void MouseTimerTick(MultiplayerClient client)
{
int curX = System.Windows.Forms.Cursor.Position.X;
int curY = System.Windows.Forms.Cursor.Position.Y;
if (lastX != -1)
{
float velX = curX - lastX;
float velY = curY - lastY;
Vector3 velocity = new Vector3(velX / 10f, 0, velY / 10f);
client.ClientPos += velocity;
playerBroadcaster.UpdateLocation(client.ClientPos, velocity, Quaternion.identity, Quaternion.identity, Optional <VehicleModel> .Empty(), Optional <string> .Empty());
}
lastX = curX;
lastY = curY;
}
public void TestManyUsers()
{
AddStep("add many users", () =>
{
for (int i = 0; i < 20; i++)
{
MultiplayerClient.AddUser(new APIUser
{
Id = i,
Username = $"User {i}",
RulesetsStatistics = new Dictionary <string, UserStatistics>
{
{
Ruleset.Value.ShortName,
new UserStatistics {
GlobalRank = RNG.Next(1, 100000),
}
}
},
CoverUrl = @"https://osu.ppy.sh/images/headers/profile-covers/c3.jpg",
});
MultiplayerClient.ChangeUserState(i, (MultiplayerUserState)RNG.Next(0, (int)MultiplayerUserState.Results + 1));
if (RNG.NextBool())
{
var beatmapState = (DownloadState)RNG.Next(0, (int)DownloadState.LocallyAvailable + 1);
switch (beatmapState)
{
case DownloadState.NotDownloaded:
MultiplayerClient.ChangeUserBeatmapAvailability(i, BeatmapAvailability.NotDownloaded());
break;
case DownloadState.Downloading:
MultiplayerClient.ChangeUserBeatmapAvailability(i, BeatmapAvailability.Downloading(RNG.NextSingle()));
break;
case DownloadState.Importing:
MultiplayerClient.ChangeUserBeatmapAvailability(i, BeatmapAvailability.Importing());
break;
}
}
}
});
}
public void TestHostGetsPinnedToTop()
{
AddStep("add user", () => MultiplayerClient.AddUser(new APIUser
{
Id = 3,
Username = "******",
CoverUrl = @"https://osu.ppy.sh/images/headers/profile-covers/c3.jpg",
}));
AddStep("make second user host", () => MultiplayerClient.TransferHost(3));
AddAssert("second user above first", () =>
{
var first = this.ChildrenOfType <ParticipantPanel>().ElementAt(0);
var second = this.ChildrenOfType <ParticipantPanel>().ElementAt(1);
return(second.Y < first.Y);
});
}
public static void RegisterHandlers(MultiplayerClient client)
{
client.RegisterPacketHandler(new HandshakeResponsePacket().ID, HandleHandshake);
client.RegisterPacketHandler(new ChatMessagePacket().ID, HandleChatMessage);
client.RegisterPacketHandler(new SetPlayerPositionPacket().ID, HandlePositionAndLook);
client.RegisterPacketHandler(new LoginResponsePacket().ID, HandleLoginResponse);
client.RegisterPacketHandler(new UpdateHealthPacket().ID, HandleUpdateHealth);
client.RegisterPacketHandler(new ChunkPreamblePacket().ID, ChunkHandlers.HandleChunkPreamble);
client.RegisterPacketHandler(new ChunkDataPacket().ID, ChunkHandlers.HandleChunkData);
client.RegisterPacketHandler(new BlockChangePacket().ID, ChunkHandlers.HandleBlockChange);
client.RegisterPacketHandler(new WindowItemsPacket().ID, InventoryHandlers.HandleWindowItems);
client.RegisterPacketHandler(new SetSlotPacket().ID, InventoryHandlers.HandleSetSlot);
client.RegisterPacketHandler(new CloseWindowPacket().ID, InventoryHandlers.HandleCloseWindowPacket);
client.RegisterPacketHandler(new OpenWindowPacket().ID, InventoryHandlers.HandleOpenWindowPacket);
}
public override void Execute(MultiplayerClient client, string[] args)
{
if (args.Length < 1)
{
CommandManager.NotEnoughArgumentsMessage(1, Syntax);
return;
}
if (args.Length >= 2)
{
client.PacketSender.SendChatMessage(String.Join(" ", args)); //does not support double spaces!
}
else
{
client.PacketSender.SendChatMessage(args[0]);
}
}
public void TestQueueTabCount()
{
assertQueueTabCount(1);
addItemStep();
assertQueueTabCount(2);
addItemStep();
assertQueueTabCount(3);
AddStep("finish current item", () => MultiplayerClient.FinishCurrentItem().WaitSafely());
assertQueueTabCount(2);
AddStep("leave room", () => RoomManager.PartRoom());
AddUntilStep("wait for room part", () => !RoomJoined);
assertQueueTabCount(0);
}
public void TestCrownChangesStateWhenHostTransferred()
{
AddStep("add user", () => MultiplayerClient.AddUser(new APIUser
{
Id = 3,
Username = "******",
CoverUrl = @"https://osu.ppy.sh/images/headers/profile-covers/c3.jpg",
}));
AddUntilStep("first user crown visible", () => this.ChildrenOfType <ParticipantPanel>().ElementAt(0).ChildrenOfType <SpriteIcon>().First().Alpha == 1);
AddUntilStep("second user crown hidden", () => this.ChildrenOfType <ParticipantPanel>().ElementAt(1).ChildrenOfType <SpriteIcon>().First().Alpha == 0);
AddStep("make second user host", () => MultiplayerClient.TransferHost(3));
AddUntilStep("first user crown hidden", () => this.ChildrenOfType <ParticipantPanel>().ElementAt(0).ChildrenOfType <SpriteIcon>().First().Alpha == 0);
AddUntilStep("second user crown visible", () => this.ChildrenOfType <ParticipantPanel>().ElementAt(1).ChildrenOfType <SpriteIcon>().First().Alpha == 1);
}
public void TestRemoveUser()
{
APIUser secondUser = null;
AddStep("add a user", () =>
{
MultiplayerClient.AddUser(secondUser = new APIUser
{
Id = 3,
Username = "******",
CoverUrl = @"https://osu.ppy.sh/images/headers/profile-covers/c3.jpg",
});
});
AddStep("remove host", () => MultiplayerClient.RemoveUser(API.LocalUser.Value));
AddAssert("single panel is for second user", () => this.ChildrenOfType <ParticipantPanel>().Single().User.User == secondUser);
}
public void TestTaikoOnlyMod()
{
AddStep("add playlist item", () =>
{
SelectedRoom.Value.Playlist.Add(new PlaylistItem(new TestBeatmap(new TaikoRuleset().RulesetInfo).BeatmapInfo)
{
RulesetID = new TaikoRuleset().RulesetInfo.OnlineID,
AllowedMods = new[] { new APIMod(new TaikoModSwap()) }
});
});
ClickButtonWhenEnabled <MultiplayerMatchSettingsOverlay.CreateOrUpdateButton>();
AddUntilStep("wait for join", () => RoomJoined);
AddStep("select swap mod", () => MultiplayerClient.ChangeUserMods(API.LocalUser.Value.OnlineID, new[] { new TaikoModSwap() }));
AddUntilStep("participant panel has mod", () => this.ChildrenOfType <ParticipantPanel>().Any(p => p.ChildrenOfType <ModIcon>().Any(m => m.Mod is TaikoModSwap)));
}
public void TestButtonEnableStateChanges()
{
IDisposable joiningRoomOperation = null;
assertButtonEnableState(true);
AddStep("begin joining room", () => joiningRoomOperation = OngoingOperationTracker.BeginOperation());
assertButtonEnableState(false);
AddStep("end joining room", () => joiningRoomOperation.Dispose());
assertButtonEnableState(true);
AddStep("disconnect client", () => MultiplayerClient.Disconnect());
assertButtonEnableState(false);
AddStep("re-connect client", () => MultiplayerClient.Connect());
assertButtonEnableState(true);
}
public static void HandleBlockChange(IPacket _packet, MultiplayerClient client)
{
var packet = (BlockChangePacket)_packet;
var coordinates = new Coordinates3D(packet.X, packet.Y, packet.Z);
Coordinates3D adjusted;
IChunk chunk;
try
{
adjusted = client.World.World.FindBlockPosition(coordinates, out chunk);
}
catch (ArgumentException)
{
// Relevant chunk is not loaded - ignore packet
return;
}
chunk.SetBlockID(adjusted, packet.ID);
chunk.SetMetadata(adjusted, (byte)packet.Metadata);
client.OnChunkModified(new ChunkEventArgs(new ReadOnlyChunk(chunk)));
}
public void TestToggleStateWhenHost(bool allReady)
{
AddStep("setup", () =>
{
MultiplayerClient.TransferHost(MultiplayerClient.Room?.Users[0].UserID ?? 0);
if (!allReady)
{
MultiplayerClient.AddUser(new APIUser {
Id = 2, Username = "******"
});
}
});
ClickButtonWhenEnabled <MultiplayerReadyButton>();
AddUntilStep("user is ready", () => MultiplayerClient.Room?.Users[0].State == MultiplayerUserState.Ready);
verifyGameplayStartFlow();
}
public void TestLoseHostWhileReady()
{
AddStep("setup", () =>
{
MultiplayerClient.TransferHost(MultiplayerClient.Room?.Users[0].UserID ?? 0);
MultiplayerClient.AddUser(new APIUser {
Id = 2, Username = "******"
});
});
ClickButtonWhenEnabled <MultiplayerReadyButton>();
AddUntilStep("user is ready", () => MultiplayerClient.Room?.Users[0].State == MultiplayerUserState.Ready);
AddStep("transfer host", () => MultiplayerClient.TransferHost(MultiplayerClient.Room?.Users[1].UserID ?? 0));
ClickButtonWhenEnabled <MultiplayerReadyButton>();
AddUntilStep("user is idle (match not started)", () => MultiplayerClient.Room?.Users[0].State == MultiplayerUserState.Idle);
AddAssert("ready button enabled", () => button.ChildrenOfType <OsuButton>().Single().Enabled.Value);
}
public void TestKickButtonOnlyPresentWhenHost()
{
AddStep("add user", () => MultiplayerClient.AddUser(new APIUser
{
Id = 3,
Username = "******",
CoverUrl = @"https://osu.ppy.sh/images/headers/profile-covers/c3.jpg",
}));
AddUntilStep("kick buttons visible", () => this.ChildrenOfType <ParticipantPanel.KickButton>().Count(d => d.IsPresent) == 1);
AddStep("make second user host", () => MultiplayerClient.TransferHost(3));
AddUntilStep("kick buttons not visible", () => this.ChildrenOfType <ParticipantPanel.KickButton>().Count(d => d.IsPresent) == 0);
AddStep("make local user host again", () => MultiplayerClient.TransferHost(API.LocalUser.Value.Id));
AddUntilStep("kick buttons visible", () => this.ChildrenOfType <ParticipantPanel.KickButton>().Count(d => d.IsPresent) == 1);
}
public new void Setup() => Schedule(() =>
{
AvailabilityTracker.SelectedItem.BindTo(selectedItem);
beatmaps.Import(TestResources.GetQuickTestBeatmapForImport()).WaitSafely();
importedSet = beatmaps.GetAllUsableBeatmapSets().First();
Beatmap.Value = beatmaps.GetWorkingBeatmap(importedSet.Beatmaps.First());
selectedItem.Value = new PlaylistItem(Beatmap.Value.BeatmapInfo)
{
RulesetID = Beatmap.Value.BeatmapInfo.Ruleset.OnlineID
};
if (button != null)
{
Remove(button);
}
Add(button = new MultiplayerReadyButton
{
Anchor = Anchor.Centre,
Origin = Anchor.Centre,
Size = new Vector2(200, 50),
OnReadyClick = () =>
{
readyClickOperation = OngoingOperationTracker.BeginOperation();
Task.Run(async() =>
{
if (MultiplayerClient.IsHost && MultiplayerClient.LocalUser?.State == MultiplayerUserState.Ready)
{
await MultiplayerClient.StartMatch();
return;
}
await MultiplayerClient.ToggleReady();
readyClickOperation.Dispose();
});
}
});
});
public static void HandleBlockChange(IPacket _packet, MultiplayerClient client)
{
var packet = (BlockChangePacket)_packet;
var coordinates = new Coordinates3D(packet.X, packet.Y, packet.Z);
Coordinates3D adjusted;
IChunk chunk;
try
{
adjusted = client.World.World.FindBlockPosition(coordinates, out chunk);
}
catch (ArgumentException)
{
// Relevant chunk is not loaded - ignore packet
return;
}
chunk.SetBlockID(adjusted, packet.ID);
chunk.SetMetadata(adjusted, (byte)packet.Metadata);
client.OnChunkModified(new ChunkEventArgs(new ReadOnlyChunk(chunk)));
}
public void TestReadyAndUnReadyDuringCountdown()
{
AddStep("add second user as host", () =>
{
MultiplayerClient.AddUser(new APIUser {
Id = 2, Username = "******"
});
MultiplayerClient.TransferHost(2);
});
AddStep("start with countdown", () => MultiplayerClient.SendMatchRequest(new StartMatchCountdownRequest {
Duration = TimeSpan.FromMinutes(2)
}).WaitSafely());
ClickButtonWhenEnabled <MultiplayerReadyButton>();
AddUntilStep("user is ready", () => MultiplayerClient.Room?.Users[0].State == MultiplayerUserState.Ready);
ClickButtonWhenEnabled <MultiplayerReadyButton>();
AddUntilStep("user is idle", () => MultiplayerClient.Room?.Users[0].State == MultiplayerUserState.Idle);
}
public void TestRange(int min, int max)
{
AddStep("add users", () =>
{
MultiplayerClient.AddUser(new APIUser
{
Id = 2,
Statistics = { GlobalRank = min }
});
MultiplayerClient.AddUser(new APIUser
{
Id = 3,
Statistics = { GlobalRank = max }
});
// Remove the local user so only the ones above are displayed.
MultiplayerClient.RemoveUser(API.LocalUser.Value);
});
}
public void TestBeatmapDownloadingStates()
{
AddStep("set to no map", () => MultiplayerClient.ChangeBeatmapAvailability(BeatmapAvailability.NotDownloaded()));
AddStep("set to downloading map", () => MultiplayerClient.ChangeBeatmapAvailability(BeatmapAvailability.Downloading(0)));
checkProgressBarVisibility(true);
AddRepeatStep("increment progress", () =>
{
float progress = this.ChildrenOfType <ParticipantPanel>().Single().User.BeatmapAvailability.DownloadProgress ?? 0;
MultiplayerClient.ChangeBeatmapAvailability(BeatmapAvailability.Downloading(progress + RNG.NextSingle(0.1f)));
}, 25);
AddAssert("progress bar increased", () => this.ChildrenOfType <ProgressBar>().Single().Current.Value > 0);
AddStep("set to importing map", () => MultiplayerClient.ChangeBeatmapAvailability(BeatmapAvailability.Importing()));
checkProgressBarVisibility(false);
AddStep("set to available", () => MultiplayerClient.ChangeBeatmapAvailability(BeatmapAvailability.LocallyAvailable()));
}
public static void HandleSetSlot(IPacket _packet, MultiplayerClient client)
{
var packet = (SetSlotPacket)_packet;
IWindow window = null;
if (packet.WindowID == 0)
{
window = client.Inventory;
}
else
{
window = client.CurrentWindow;
}
if (window != null)
{
if (packet.SlotIndex >= 0 && packet.SlotIndex < window.Length)
{
window[packet.SlotIndex] = new ItemStack(packet.ItemID, packet.Count, packet.Metadata);
}
}
}
public override void Execute(MultiplayerClient client, string[] args)
{
assertMinimumArgs(args, 2);
AnimChangeState state;
if (args[1] == "on" || args[1] == "1" || args[1] == "true")
{
state = AnimChangeState.ON;
}
else if (args[1] == "off" || args[1] == "0" || args[1] == "false")
{
state = AnimChangeState.OFF;
}
else
{
state = AnimChangeState.UNSET;
}
localPlayer.AnimationChange((AnimChangeType)int.Parse(args[0]), state);
}
public void TestUserWithMods()
{
AddStep("add user", () =>
{
MultiplayerClient.AddUser(new APIUser
{
Id = 0,
Username = "******",
RulesetsStatistics = new Dictionary <string, UserStatistics>
{
{
Ruleset.Value.ShortName,
new UserStatistics {
GlobalRank = RNG.Next(1, 100000),
}
}
},
CoverUrl = @"https://osu.ppy.sh/images/headers/profile-covers/c3.jpg",
});
MultiplayerClient.ChangeUserMods(0, new Mod[]
{
new OsuModHardRock(),
new OsuModDifficultyAdjust {
ApproachRate = { Value = 1 }
}
});
});
for (var i = MultiplayerUserState.Idle; i < MultiplayerUserState.Results; i++)
{
var state = i;
AddStep($"set state: {state}", () => MultiplayerClient.ChangeUserState(0, state));
}
AddStep("set state: downloading", () => MultiplayerClient.ChangeUserBeatmapAvailability(0, BeatmapAvailability.Downloading(0)));
AddStep("set state: locally available", () => MultiplayerClient.ChangeUserBeatmapAvailability(0, BeatmapAvailability.LocallyAvailable()));
}
public override void Execute(MultiplayerClient client, string[] args)
{
assertMinimumArgs(args, 1);
IEnumerable <object> numericArgs = args
.Skip(1)
.Select(x =>
{
float r;
if (float.TryParse(x, out r))
{
return((object)r);
}
throw new InvalidArgumentException($"{x} is not a number!");
});
numericArgs = numericArgs.Concat(Enumerable.Repeat((object)1f, 5 - numericArgs.Count()));
PlayerStats playerStats = (PlayerStats)Activator.CreateInstance(typeof(PlayerStats), new object[] { args[0] }.Concat(numericArgs).ToArray());
client.PacketSender.Send(playerStats);
}
public static void HandleCloseWindowPacket(IPacket _packet, MultiplayerClient client)
{
client.CurrentWindow = null;
}
public static void HandleTimeUpdate(IPacket _packet, MultiplayerClient client)
{
var packet = (TimeUpdatePacket)_packet;
var time = packet.Time / 20.0;
client.World.World.BaseTime = DateTime.UtcNow - TimeSpan.FromSeconds(time);
}
public static void HandleUpdateHealth(IPacket _packet, MultiplayerClient client)
{
var packet = (UpdateHealthPacket)_packet;
client.Health = packet.Health;
}
public static void HandleLoginResponse(IPacket _packet, MultiplayerClient client)
{
var packet = (LoginResponsePacket)_packet;
client.EntityID = packet.EntityID;
client.QueuePacket(new PlayerGroundedPacket());
}
public static void HandleLoginResponse(IPacket _packet, MultiplayerClient client)
{
client.QueuePacket(new PlayerGroundedPacket());
}
public static void HandleChunkPreamble(IPacket _packet, MultiplayerClient client)
{
var packet = (ChunkPreamblePacket)_packet;
var coords = new Coordinates2D(packet.X, packet.Z);
client.World.SetChunk(coords, new Chunk(coords));
}
public static void HandleChatMessage(IPacket _packet, MultiplayerClient client)
{
var packet = (ChatMessagePacket)_packet;
client.OnChatMessage(new ChatMessageEventArgs(packet.Message));
}
public DebugInterface(MultiplayerClient client, FontRenderer font)
{
Client = client;
Font = font;
}
public static void HandleChunkData(IPacket _packet, MultiplayerClient client)
{
var packet = (ChunkDataPacket)_packet;
var data = ZlibStream.UncompressBuffer(packet.CompressedData);
IChunk chunk;
var adjustedCoords = client.World.World.FindBlockPosition(
new Coordinates3D(packet.X, packet.Y, packet.Z), out chunk);
if (packet.Width == Chunk.Width
&& packet.Height == Chunk.Height
&& packet.Depth == Chunk.Depth) // Fast path
{
// Block IDs
Buffer.BlockCopy(data, 0, chunk.Blocks, 0, chunk.Blocks.Length);
// Block metadata
Buffer.BlockCopy(data, chunk.Blocks.Length, chunk.Metadata.Data, 0, chunk.Metadata.Data.Length);
// Block light
Buffer.BlockCopy(data, chunk.Blocks.Length + chunk.Metadata.Data.Length,
chunk.BlockLight.Data, 0, chunk.BlockLight.Data.Length);
// Sky light
Buffer.BlockCopy(data, chunk.Blocks.Length + chunk.Metadata.Data.Length + chunk.BlockLight.Data.Length,
chunk.SkyLight.Data, 0, chunk.SkyLight.Data.Length);
}
else // Slow path
{
int x = adjustedCoords.X, y = adjustedCoords.Y, z = adjustedCoords.Z;
int fullLength = packet.Width * packet.Height * packet.Depth; // Length of full sized byte section
int nibbleLength = fullLength / 2; // Length of nibble sections
for (int i = 0; i < fullLength; i++) // Iterate through block IDs
{
chunk.SetBlockID(new Coordinates3D(x, y, z), data[i]);
y++;
if (y >= packet.Height)
{
y = 0;
z++;
if (z >= packet.Depth)
{
z = 0;
x++;
if (x >= packet.Width)
{
x = 0;
}
}
}
}
x = adjustedCoords.X; y = adjustedCoords.Y; z = adjustedCoords.Z;
for (int i = fullLength; i < nibbleLength; i++) // Iterate through metadata
{
byte m = data[i];
chunk.SetMetadata(new Coordinates3D(x, y, z), (byte)(m & 0xF));
chunk.SetMetadata(new Coordinates3D(x, y + 1, z), (byte)(m & 0xF0 << 8));
y += 2;
if (y >= packet.Height)
{
y = 0;
z++;
if (z >= packet.Depth)
{
z = 0;
x++;
if (x >= packet.Width)
{
x = 0;
}
}
}
}
// TODO: Lighting
}
chunk.UpdateHeightMap();
client.OnChunkLoaded(new ChunkEventArgs(new ReadOnlyChunk(chunk)));
}
