private void TimerOnElapsed(object sender, HighResolutionTimerElapsedEventArgs e)
{
if (observedCollections.Any(c => c.Count > 0))
{
executedAction();
}
}
public virtual void BroadcastVoIPData(object sender, HighResolutionTimerElapsedEventArgs e)
{
if (!Settings.Instance.Server.AllowVoiceChat)
{
return;
}
NetOutgoingMessage outMsg = HubListener.ListenerServer.CreateMessage();
outMsg.Write((byte)CommandType.UpdateVoIPData);
outMsg.Write(roomClients.Count(x => x != null && x.playerVoIPQueue != null && x.playerVoIPQueue.Count > 0));
for (int i = 0; i < roomClients.Count; i++)
{
if (roomClients.Count > i && roomClients[i] != null && roomClients[i].playerVoIPQueue != null && roomClients[i].playerVoIPQueue.Count > 0)
{
while (roomClients[i].playerVoIPQueue.Count > 0)
{
roomClients[i].playerVoIPQueue.Dequeue().AddToMessage(outMsg);
}
}
}
BroadcastPacket(outMsg, NetDeliveryMethod.UnreliableSequenced, 2);
}
private void _EndCheckTimerElapsed(object sender, HighResolutionTimerElapsedEventArgs e)
{
// To catch events that may trail after the timer's been disabled
// due to it being a threaded timer and Stop being called between the
// timer message being posted and acted upon.
if (!_endCheckTimer.IsRunning)
{
return;
}
lock (_endCheckTimer)
{
if (_CheckForNaturalEnd() || !IsRunning)
{
_endCheckTimer.Stop(false);
}
}
}
public virtual void RoomLoop(object sender, HighResolutionTimerElapsedEventArgs e)
{
NetOutgoingMessage outMsg = HubListener.ListenerServer.CreateMessage();
switch (roomState)
{
case RoomState.InGame:
{
if ((DateTime.Now.Subtract(_songStartTime).TotalSeconds >= selectedSong.songDuration) ||
(DateTime.Now.Subtract(_songStartTime).TotalSeconds >= 10f && roomClients.All(x => x.playerInfo.updateInfo.playerState != PlayerState.Game)))
{
roomState = RoomState.Results;
_resultsStartTime = DateTime.Now;
outMsg.Write((byte)CommandType.GetRoomInfo);
GetRoomInfo().AddToMessage(outMsg);
BroadcastPacket(outMsg, NetDeliveryMethod.ReliableOrdered, 0);
if (roomClients.Count > 0)
{
BroadcastWebSocket(CommandType.GetRoomInfo, GetRoomInfo());
}
}
}
break;
case RoomState.Results:
{
if (DateTime.Now.Subtract(_resultsStartTime).TotalSeconds >= roomSettings.ResultsShowTime)
{
roomState = RoomState.SelectingSong;
selectedSong = null;
outMsg.Write((byte)CommandType.SetSelectedSong);
outMsg.Write((int)0);
BroadcastPacket(outMsg, NetDeliveryMethod.ReliableOrdered, 0);
BroadcastWebSocket(CommandType.SetSelectedSong, null);
}
}
break;
case RoomState.SelectingSong:
{
switch (roomSettings.SelectionType)
{
case SongSelectionType.Random:
{
if (!requestedRandomSong && roomClients.Count > 0 && roomClients.Any(x => roomHost.Equals(x.playerInfo)))
{
requestedRandomSong = true;
outMsg.Write((byte)CommandType.GetRandomSongInfo);
roomClients.First(x => roomHost.Equals(x.playerInfo)).playerConnection.SendMessage(outMsg, NetDeliveryMethod.ReliableOrdered, 0);
BroadcastWebSocket(CommandType.GetRandomSongInfo, null);
}
}
break;
}
}
break;
}
if (outMsg.LengthBytes > 0)
{
outMsg = HubListener.ListenerServer.CreateMessage();
}
outMsg.Write((byte)CommandType.UpdatePlayerInfo);
switch (roomState)
{
case RoomState.SelectingSong:
{
outMsg.Write((float)0);
outMsg.Write((float)0);
}
break;
case RoomState.Preparing:
{
outMsg.Write((float)0);
outMsg.Write((float)0);
}
break;
case RoomState.InGame:
{
outMsg.Write((float)DateTime.Now.Subtract(_songStartTime).TotalSeconds);
outMsg.Write(selectedSong.songDuration);
}
break;
case RoomState.Results:
{
outMsg.Write((float)DateTime.Now.Subtract(_resultsStartTime).TotalSeconds);
outMsg.Write(roomSettings.ResultsShowTime);
}
break;
}
bool fullUpdate = false;
int i = 0;
for (i = 0; i < roomClients.Count; i++)
{
if (i < roomClients.Count)
{
if (roomClients[i] != null)
{
if (roomClients[i].playerInfo.Equals(roomHost) && roomClients[i].playerInfo.updateInfo.playerNameColor.Equals(Color32.defaultColor))
{
roomClients[i].playerInfo.updateInfo.playerNameColor = Color32.roomHostColor;
}
fullUpdate |= roomClients[i].lastUpdateIsFull;
roomClients[i].lastUpdateIsFull = false;
}
}
}
outMsg.Write(fullUpdate ? (byte)1 : (byte)0);
outMsg.Write(roomClients.Count);
if (fullUpdate)
{
for (i = 0; i < roomClients.Count; i++)
{
if (i < roomClients.Count)
{
if (roomClients[i] != null)
{
outMsg.Write(roomClients[i].playerInfo.playerId);
}
}
roomClients[i].playerInfo.AddToMessage(outMsg);
}
}
else
{
for (i = 0; i < roomClients.Count; i++)
{
if (i < roomClients.Count)
{
if (roomClients[i] != null)
{
outMsg.Write(roomClients[i].playerInfo.playerId);
roomClients[i].playerInfo.updateInfo.AddToMessage(outMsg);
outMsg.Write((byte)roomClients[i].playerInfo.hitsLastUpdate.Count);
foreach (var hit in roomClients[i].playerInfo.hitsLastUpdate)
{
hit.AddToMessage(outMsg);
}
roomClients[i].playerInfo.hitsLastUpdate.Clear();
}
}
}
}
if (roomClients.Count > 0)
{
BroadcastPacket(outMsg, NetDeliveryMethod.UnreliableSequenced, 1);
BroadcastWebSocket(CommandType.UpdatePlayerInfo, roomClients.Select(x => x.playerInfo).ToArray());
spectatorInRoom = roomClients.Any(x => x.playerInfo.updateInfo.playerState == PlayerState.Spectating);
if (spectatorInRoom)
{
outMsg = HubListener.ListenerServer.CreateMessage();
outMsg.Write((byte)CommandType.GetPlayerUpdates);
outMsg.Write(roomClients.Count(x => x.playerInfo.updateInfo.playerState == PlayerState.Game && x.playerUpdateHistory.Count > 0));
for (i = 0; i < roomClients.Count; i++)
{
if (i < roomClients.Count)
{
if (roomClients[i] != null && roomClients[i].playerInfo.updateInfo.playerState == PlayerState.Game && roomClients[i].playerUpdateHistory.Count > 0)
{
outMsg.Write(roomClients[i].playerInfo.playerId);
int historyLength = roomClients[i].playerUpdateHistory.Count;
outMsg.Write((byte)historyLength);
for (int j = 0; j < historyLength; j++)
{
roomClients[i].playerUpdateHistory.Dequeue().AddToMessage(outMsg);
}
roomClients[i].playerUpdateHistory.Clear();
int hitCount = roomClients[i].playerHitsHistory.Count;
outMsg.Write((byte)hitCount);
for (int j = 0; j < hitCount; j++)
{
roomClients[i].playerHitsHistory[i].AddToMessage(outMsg);
}
roomClients[i].playerHitsHistory.Clear();
}
}
}
BroadcastPacket(outMsg, NetDeliveryMethod.UnreliableSequenced, 2, roomClients.Where(x => x.playerInfo.updateInfo.playerState != PlayerState.Spectating).ToList());
}
}
}
public async void RadioLoop(object sender, HighResolutionTimerElapsedEventArgs e)
{
if (randomSongTask != null)
{
return;
}
channelInfo.playerCount = radioClients.Count;
channelInfo.name = Settings.Instance.Radio.RadioChannels[channelId].ChannelName;
channelInfo.iconUrl = Settings.Instance.Radio.RadioChannels[channelId].ChannelIconUrl;
if (radioClients.Count == 0)
{
channelInfo.state = ChannelState.NextSong;
return;
}
NetOutgoingMessage outMsg = HubListener.ListenerServer.CreateMessage();
switch (channelInfo.state)
{
case ChannelState.InGame: //--> Results
{
if (DateTime.Now.Subtract(songStartTime).TotalSeconds >= channelInfo.currentSong.songDuration)
{
channelInfo.state = ChannelState.Results;
resultsStartTime = DateTime.Now;
outMsg.Write((byte)CommandType.GetChannelInfo);
outMsg.Write((byte)0);
channelInfo.AddToMessage(outMsg);
BroadcastPacket(outMsg, NetDeliveryMethod.ReliableOrdered);
if (radioClients.Count > 0)
{
BroadcastWebSocket(CommandType.GetChannelInfo, channelInfo);
}
}
}
break;
case ChannelState.Results: //--> NextSong
{
if (DateTime.Now.Subtract(resultsStartTime).TotalSeconds >= Settings.Instance.Radio.ResultsShowTime)
{
channelInfo.state = ChannelState.NextSong;
if (radioQueue.Count > 0)
{
channelInfo.currentSong = radioQueue.Dequeue();
try
{
File.WriteAllText($"RadioQueue{channelId}.json", JsonConvert.SerializeObject(radioQueue, Formatting.Indented));
}
catch
{
}
}
else
{
if (defaultSongs.Count > 1)
{
channelInfo.currentSong = defaultSongs.Random(lastSong);
}
else
{
randomSongTask = BeatSaver.GetRandomSong();
channelInfo.currentSong = await randomSongTask;
randomSongTask = null;
}
lastSong = channelInfo.currentSong;
}
outMsg.Write((byte)CommandType.SetSelectedSong);
channelInfo.currentSong.AddToMessage(outMsg);
BroadcastPacket(outMsg, NetDeliveryMethod.ReliableOrdered);
nextSongScreenStartTime = DateTime.Now;
if (radioClients.Count > 0)
{
BroadcastWebSocket(CommandType.SetSelectedSong, channelInfo.currentSong);
}
}
}
break;
case ChannelState.NextSong: //--> InGame
{
if (DateTime.Now.Subtract(nextSongScreenStartTime).TotalSeconds >= Settings.Instance.Radio.NextSongPrepareTime)
{
channelInfo.state = ChannelState.InGame;
outMsg.Write((byte)CommandType.StartLevel);
//outMsg.Write((byte)Settings.Instance.Radio.RadioChannels[channelId].PreferredDifficulty);
channelInfo.currentLevelOptions.AddToMessage(outMsg);
channelInfo.currentSong.songDuration = Misc.Math.Median(songDurationResponses.Values.ToArray());
songDurationResponses.Clear();
requestingSongDuration = false;
channelInfo.currentSong.AddToMessage(outMsg);
BroadcastPacket(outMsg, NetDeliveryMethod.ReliableOrdered);
songStartTime = DateTime.Now;
if (radioClients.Count > 0)
{
BroadcastWebSocket(CommandType.StartLevel, new SongWithOptions(channelInfo.currentSong, channelInfo.currentLevelOptions));
}
}
else if (DateTime.Now.Subtract(nextSongScreenStartTime).TotalSeconds >= Settings.Instance.Radio.NextSongPrepareTime * 0.75 && !requestingSongDuration)
{
outMsg.Write((byte)CommandType.GetSongDuration);
channelInfo.currentSong.AddToMessage(outMsg);
songDurationResponses.Clear();
requestingSongDuration = true;
BroadcastPacket(outMsg, NetDeliveryMethod.ReliableOrdered);
if (radioClients.Count > 0)
{
BroadcastWebSocket(CommandType.GetSongDuration, channelInfo.currentSong);
}
}
}
break;
}
if (outMsg.LengthBytes > 0)
{
outMsg = HubListener.ListenerServer.CreateMessage();
}
outMsg.Write((byte)CommandType.UpdatePlayerInfo);
switch (channelInfo.state)
{
case ChannelState.NextSong:
{
outMsg.Write((float)DateTime.Now.Subtract(nextSongScreenStartTime).TotalSeconds);
outMsg.Write(Settings.Instance.Radio.NextSongPrepareTime);
}
break;
case ChannelState.InGame:
{
outMsg.Write((float)DateTime.Now.Subtract(songStartTime).TotalSeconds);
outMsg.Write(channelInfo.currentSong.songDuration);
}
break;
case ChannelState.Results:
{
outMsg.Write((float)DateTime.Now.Subtract(resultsStartTime).TotalSeconds);
outMsg.Write(Settings.Instance.Radio.ResultsShowTime);
}
break;
}
outMsg.Write(radioClients.Count);
radioClients.ForEach(x => x.playerInfo.AddToMessage(outMsg));
BroadcastPacket(outMsg, NetDeliveryMethod.UnreliableSequenced);
if (radioClients.Count > 0)
{
BroadcastWebSocket(CommandType.UpdatePlayerInfo, radioClients.Select(x => x.playerInfo).ToArray());
}
}
private void GameLoop(object sender, HighResolutionTimerElapsedEventArgs e)
{
Console.WriteLine($"Tick #{elapsedTicks}: {elapsedTicks * tickLengthMs}ms / {stopwatch.ElapsedMilliseconds}ms elapsed ({ Math.Abs((elapsedTicks * tickLengthMs) - stopwatch.ElapsedMilliseconds) }ms diff)");
elapsedTicks++;
}
public void DoTick(object s, HighResolutionTimerElapsedEventArgs e)
{
//Console.WriteLine("Tick {0}", e.Delay);
/* Loop over entities. Porbably not needed and also unoptimized
* foreach (Entity entity in world.entities)
* {
*
* }*/
foreach (Entity entity in world.movedEntities)
{
if (entity.movedChunks)
{
List <Game> toUncache = new List <Game>();
foreach (Game cacher in entity.cachedBy)
{
if (!world.InCacheRange(cacher.player, new Position(entity.pos.x >> 3, entity.pos.y >> 3), config))
{
toUncache.Add(cacher);
}
}
foreach (Game game in toUncache)
{
world.Uncache(game, entity);
}
//Entity moved chunks, we gotta update the caches.
for (int x = Math.Max(0, entity.chunk.pos.x - config.entityDistanceX); x <= Math.Min((world.width >> 3) - 1, entity.chunk.pos.x + config.entityDistanceX); x++)
{
for (int y = Math.Max(0, entity.chunk.pos.y - config.entityDistanceY); y <= Math.Min((world.height >> 3) - 1, entity.chunk.pos.y + config.entityDistanceY); y++)
{
// Possible optimization TODO: Chunks keep track of players specifically
foreach (Entity chunkEntity in world.GetChunk(new Position(x, y)).entities)
{
if (chunkEntity is Player && !entity.cachedBy.Contains(((Player)chunkEntity).game))
{
world.Cache(((Player)chunkEntity).game, entity);
}
}
}
}
}
foreach (Game cacher in entity.cachedBy)
{
if (!cacher.justCached)
{
cacher.UpdateEntityPos(entity);
}
else
{
cacher.justCached = false;
}
}
if (entity is Player)
{
Player playerEntity = (Player)entity;
Game playerGame = playerEntity.game;
for (int x = Math.Max(0, entity.chunk.pos.x - config.entityDistanceX); x <= Math.Min((world.width >> 3) - 1, entity.chunk.pos.x + config.entityDistanceX); x++)
{
for (int y = Math.Max(0, entity.chunk.pos.y - config.entityDistanceY); y <= Math.Min((world.height >> 3) - 1, entity.chunk.pos.y + config.entityDistanceY); y++)
{
// Possible optimization TODO: Chunks keep track of players specifically
foreach (Entity chunkEntity in world.GetChunk(new Position(x, y)).entities)
{
if (!playerGame.cachedEntities.Contains(chunkEntity))
{
world.Cache(playerGame, chunkEntity);
}
}
}
}
}
entity.moved = false;
entity.movedChunks = false;
}
world.movedEntities = new List <Entity>();
}
private static void HubLoop(object sender, HighResolutionTimerElapsedEventArgs e)
{
if (_ticksLength.Count > 30)
{
_ticksLength.RemoveAt(0);
}
_ticksLength.Add(DateTime.UtcNow.Subtract(_lastTick).Ticks / (float)TimeSpan.TicksPerMillisecond);
_lastTick = DateTime.UtcNow;
List <RoomInfo> roomsList = RoomsController.GetRoomInfosList();
string titleBuffer = $"ServerHub v{Assembly.GetEntryAssembly().GetName().Version}: {roomsList.Count} rooms, {hubClients.Count} clients in lobby, {roomsList.Select(x => x.players).Sum() + hubClients.Count} clients total {(Settings.Instance.Server.ShowTickrateInTitle ? $", {Tickrate.ToString("0.0")} tickrate" : "")}";
if (_currentTitle != titleBuffer)
{
_currentTitle = titleBuffer;
Console.Title = _currentTitle;
}
List <Client> allClients = hubClients.Concat(RoomsController.GetRoomsList().SelectMany(x => x.roomClients)).Concat(RadioController.radioChannels.SelectMany(x => x.radioClients)).ToList();
NetIncomingMessage msg;
while ((msg = ListenerServer.ReadMessage()) != null)
{
try
{
Program.networkBytesInNow += msg.LengthBytes;
switch (msg.MessageType)
{
case NetIncomingMessageType.ConnectionApproval:
{
byte[] versionBytes = msg.PeekBytes(4);
byte[] version = msg.ReadBytes(4);
if (version[0] == 0 && version[1] == 0)
{
uint versionUint = BitConverter.ToUInt32(version, 0);
uint serverVersionUint = ((uint)Assembly.GetEntryAssembly().GetName().Version.Major).ConcatUInts((uint)Assembly.GetEntryAssembly().GetName().Version.Minor).ConcatUInts((uint)Assembly.GetEntryAssembly().GetName().Version.Build).ConcatUInts((uint)Assembly.GetEntryAssembly().GetName().Version.Revision);
msg.SenderConnection.Deny($"Version mismatch!\nServer:{serverVersionUint}\nClient:{versionUint}");
Logger.Instance.Log($"Client version v{versionUint} tried to connect");
break;
}
byte[] serverVersion = new byte[4] {
(byte)Assembly.GetEntryAssembly().GetName().Version.Major, (byte)Assembly.GetEntryAssembly().GetName().Version.Minor, (byte)Assembly.GetEntryAssembly().GetName().Version.Build, (byte)Assembly.GetEntryAssembly().GetName().Version.Revision
};
if (version[0] != serverVersion[0] || version[1] != serverVersion[1] || version[2] != serverVersion[2])
{
msg.SenderConnection.Deny($"Version mismatch|{string.Join('.', serverVersion)}|{string.Join('.', version)}");
Logger.Instance.Log($"Client version v{string.Join('.', version)} tried to connect");
break;
}
PlayerInfo playerInfo = new PlayerInfo(msg);
if (Settings.Instance.Access.WhitelistEnabled)
{
if (!IsWhitelisted(msg.SenderConnection.RemoteEndPoint, playerInfo))
{
msg.SenderConnection.Deny("You are not whitelisted on this ServerHub!");
Logger.Instance.Warning($"Client {playerInfo.playerName}({playerInfo.playerId})@{msg.SenderConnection.RemoteEndPoint.Address} is not whitelisted!");
break;
}
}
if (IsBlacklisted(msg.SenderConnection.RemoteEndPoint, playerInfo))
{
msg.SenderConnection.Deny("You are banned on this ServerHub!");
Logger.Instance.Warning($"Client {playerInfo.playerName}({playerInfo.playerId})@{msg.SenderConnection.RemoteEndPoint.Address} is banned!");
break;
}
msg.SenderConnection.Approve();
Client client = new Client(msg.SenderConnection, playerInfo);
client.playerInfo.playerState = PlayerState.Lobby;
client.ClientDisconnected += ClientDisconnected;
hubClients.Add(client);
allClients.Add(client);
Logger.Instance.Log($"{playerInfo.playerName} connected!");
};
break;
case NetIncomingMessageType.Data:
{
Client client = allClients.FirstOrDefault(x => x.playerConnection.RemoteEndPoint.Equals(msg.SenderEndPoint));
switch ((CommandType)msg.ReadByte())
{
case CommandType.Disconnect:
{
if (client != null)
{
allClients.Remove(client);
ClientDisconnected(client);
}
}
break;
case CommandType.UpdatePlayerInfo:
{
if (client != null)
{
client.playerInfo = new PlayerInfo(msg);
if (Settings.Instance.Misc.PlayerColors.ContainsKey(client.playerInfo.playerId))
{
client.playerInfo.playerNameColor = Settings.Instance.Misc.PlayerColors[client.playerInfo.playerId];
}
}
}
break;
case CommandType.UpdateVoIPData:
{
if (!Settings.Instance.Server.AllowVoiceChat)
{
return;
}
if (client != null)
{
UnityVOIP.VoipFragment data = new UnityVOIP.VoipFragment(msg);
if (data.playerId == client.playerInfo.playerId)
{
client.playerVoIPQueue.Enqueue(data);
}
}
}
break;
case CommandType.JoinRoom:
{
if (client != null)
{
uint roomId = msg.ReadUInt32();
BaseRoom room = RoomsController.GetRoomsList().FirstOrDefault(x => x.roomId == roomId);
if (room != null)
{
if (room.roomSettings.UsePassword)
{
if (RoomsController.ClientJoined(client, roomId, msg.ReadString()))
{
if (hubClients.Contains(client))
{
hubClients.Remove(client);
}
client.joinedRoomID = roomId;
}
}
else
{
if (RoomsController.ClientJoined(client, roomId, ""))
{
if (hubClients.Contains(client))
{
hubClients.Remove(client);
}
client.joinedRoomID = roomId;
}
}
}
else
{
RoomsController.ClientJoined(client, roomId, "");
}
}
}
break;
case CommandType.LeaveRoom:
{
if (client != null)
{
RoomsController.ClientLeftRoom(client);
client.joinedRoomID = 0;
client.playerInfo.playerState = PlayerState.Lobby;
if (!hubClients.Contains(client))
{
hubClients.Add(client);
}
}
}
break;
case CommandType.GetRooms:
{
NetOutgoingMessage outMsg = ListenerServer.CreateMessage();
outMsg.Write((byte)CommandType.GetRooms);
RoomsController.AddRoomListToMessage(outMsg);
msg.SenderConnection.SendMessage(outMsg, NetDeliveryMethod.ReliableOrdered, 0);
Program.networkBytesOutNow += outMsg.LengthBytes;
}
break;
case CommandType.CreateRoom:
{
if (client != null)
{
uint roomId = RoomsController.CreateRoom(new RoomSettings(msg), client.playerInfo);
NetOutgoingMessage outMsg = ListenerServer.CreateMessage(5);
outMsg.Write((byte)CommandType.CreateRoom);
outMsg.Write(roomId);
msg.SenderConnection.SendMessage(outMsg, NetDeliveryMethod.ReliableOrdered, 0);
Program.networkBytesOutNow += outMsg.LengthBytes;
}
}
break;
case CommandType.GetRoomInfo:
{
if (client != null)
{
#if DEBUG
Logger.Instance.Log("GetRoomInfo: Client room=" + client.joinedRoomID);
#endif
if (client.joinedRoomID != 0)
{
BaseRoom joinedRoom = RoomsController.GetRoomsList().FirstOrDefault(x => x.roomId == client.joinedRoomID);
if (joinedRoom != null)
{
NetOutgoingMessage outMsg = ListenerServer.CreateMessage();
outMsg.Write((byte)CommandType.GetRoomInfo);
joinedRoom.GetRoomInfo().AddToMessage(outMsg);
msg.SenderConnection.SendMessage(outMsg, NetDeliveryMethod.ReliableOrdered, 0);
Program.networkBytesOutNow += outMsg.LengthBytes;
}
}
}
}
break;
case CommandType.SetSelectedSong:
{
if (client != null && client.joinedRoomID != 0)
{
BaseRoom joinedRoom = RoomsController.GetRoomsList().FirstOrDefault(x => x.roomId == client.joinedRoomID);
if (joinedRoom != null)
{
if (msg.LengthBytes < 16)
{
joinedRoom.SetSelectedSong(client.playerInfo, null);
}
else
{
joinedRoom.SetSelectedSong(client.playerInfo, new SongInfo(msg));
}
}
}
}
break;
case CommandType.SetLevelOptions:
{
if (client != null && client.joinedRoomID != 0)
{
BaseRoom joinedRoom = RoomsController.GetRoomsList().FirstOrDefault(x => x.roomId == client.joinedRoomID);
if (joinedRoom != null)
{
joinedRoom.SetLevelOptions(client.playerInfo, new StartLevelInfo(msg));
}
}
}
break;
case CommandType.StartLevel:
{
#if DEBUG
Logger.Instance.Log("Received command StartLevel");
#endif
if (client != null && client.joinedRoomID != 0)
{
BaseRoom joinedRoom = RoomsController.GetRoomsList().FirstOrDefault(x => x.roomId == client.joinedRoomID);
if (joinedRoom != null)
{
StartLevelInfo options = new StartLevelInfo(msg);
SongInfo song = new SongInfo(msg);
song.songDuration += 2.5f;
joinedRoom.StartLevel(client.playerInfo, options, song);
}
}
}
break;
case CommandType.DestroyRoom:
{
if (client != null && client.joinedRoomID != 0)
{
BaseRoom joinedRoom = RoomsController.GetRoomsList().FirstOrDefault(x => x.roomId == client.joinedRoomID);
if (joinedRoom != null)
{
joinedRoom.DestroyRoom(client.playerInfo);
}
}
}
break;
case CommandType.TransferHost:
{
if (client != null && client.joinedRoomID != 0)
{
BaseRoom joinedRoom = RoomsController.GetRoomsList().FirstOrDefault(x => x.roomId == client.joinedRoomID);
if (joinedRoom != null)
{
joinedRoom.TransferHost(client.playerInfo, new PlayerInfo(msg));
}
}
}
break;
case CommandType.PlayerReady:
{
if (client != null && client.joinedRoomID != 0)
{
BaseRoom joinedRoom = RoomsController.GetRoomsList().FirstOrDefault(x => x.roomId == client.joinedRoomID);
if (joinedRoom != null)
{
joinedRoom.ReadyStateChanged(client.playerInfo, msg.ReadBoolean());
}
}
}
break;
case CommandType.SendEventMessage:
{
if (client != null && client.joinedRoomID != 0 && Settings.Instance.Server.AllowEventMessages)
{
BaseRoom joinedRoom = RoomsController.GetRoomsList().FirstOrDefault(x => x.roomId == client.joinedRoomID);
if (joinedRoom != null)
{
string header = msg.ReadString();
string data = msg.ReadString();
joinedRoom.BroadcastEventMessage(header, data, new List <Client>()
{
client
});
joinedRoom.BroadcastWebSocket(CommandType.SendEventMessage, new EventMessage(header, data));
EventMessageReceived?.Invoke(client, header, data);
#if DEBUG
Logger.Instance.Log($"Received event message! Header=\"{header}\", Data=\"{data}\"");
#endif
}
}
}
break;
case CommandType.GetChannelInfo:
{
if (Settings.Instance.Radio.EnableRadio && RadioController.radioStarted)
{
int channelId = msg.ReadInt32();
NetOutgoingMessage outMsg = ListenerServer.CreateMessage();
outMsg.Write((byte)CommandType.GetChannelInfo);
if (RadioController.radioChannels.Count > channelId)
{
RadioController.radioChannels[channelId].channelInfo.AddToMessage(outMsg);
}
else
{
new ChannelInfo()
{
channelId = -1, currentSong = new SongInfo()
{
levelId = "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
}
}.AddToMessage(outMsg);
}
msg.SenderConnection.SendMessage(outMsg, NetDeliveryMethod.ReliableOrdered, 0);
Program.networkBytesOutNow += outMsg.LengthBytes;
}
}
break;
case CommandType.JoinChannel:
{
int channelId = msg.ReadInt32();
NetOutgoingMessage outMsg = ListenerServer.CreateMessage();
outMsg.Write((byte)CommandType.JoinChannel);
if (RadioController.ClientJoinedChannel(client, channelId))
{
outMsg.Write((byte)0);
hubClients.Remove(client);
}
else
{
outMsg.Write((byte)1);
}
msg.SenderConnection.SendMessage(outMsg, NetDeliveryMethod.ReliableOrdered, 0);
Program.networkBytesOutNow += outMsg.LengthBytes;
}
break;
case CommandType.GetSongDuration:
{
foreach (RadioChannel channel in RadioController.radioChannels)
{
if (channel.radioClients.Contains(client) && channel.requestingSongDuration)
{
SongInfo info = new SongInfo(msg);
if (info.levelId == channel.channelInfo.currentSong.levelId)
{
channel.songDurationResponses.TryAdd(client, info.songDuration);
}
}
}
}
break;
case CommandType.LeaveChannel:
{
if (RadioController.radioStarted && client != null)
{
RadioController.ClientLeftChannel(client);
}
}; break;
}
};
break;
case NetIncomingMessageType.WarningMessage:
Logger.Instance.Warning(msg.ReadString());
break;
case NetIncomingMessageType.ErrorMessage:
Logger.Instance.Error(msg.ReadString());
break;
case NetIncomingMessageType.StatusChanged:
{
NetConnectionStatus status = (NetConnectionStatus)msg.ReadByte();
Client client = allClients.FirstOrDefault(x => x.playerConnection.RemoteEndPoint.Equals(msg.SenderEndPoint));
if (client != null)
{
if (status == NetConnectionStatus.Disconnected)
{
allClients.Remove(client);
ClientDisconnected(client);
}
}
}
break;
#if DEBUG
case NetIncomingMessageType.VerboseDebugMessage:
case NetIncomingMessageType.DebugMessage:
Logger.Instance.Log(msg.ReadString());
break;
default:
Logger.Instance.Log("Unhandled message type: " + msg.MessageType);
break;
#endif
}
}catch (Exception ex)
{
Logger.Instance.Log($"Exception on message received: {ex}");
}
ListenerServer.Recycle(msg);
}
}
public virtual async void RoomLoopAsync(object sender, HighResolutionTimerElapsedEventArgs e)
{
if (randomSongTask != null)
{
return;
}
NetOutgoingMessage outMsg = HubListener.ListenerServer.CreateMessage();
switch (roomState)
{
case RoomState.InGame:
{
if (DateTime.Now.Subtract(_songStartTime).TotalSeconds >= selectedSong.songDuration)
{
roomState = RoomState.Results;
_resultsStartTime = DateTime.Now;
outMsg.Write((byte)CommandType.GetRoomInfo);
GetRoomInfo().AddToMessage(outMsg);
BroadcastPacket(outMsg, NetDeliveryMethod.ReliableOrdered);
if (roomClients.Count > 0)
{
BroadcastWebSocket(CommandType.GetRoomInfo, GetRoomInfo());
}
}
}
break;
case RoomState.Results:
{
if (DateTime.Now.Subtract(_resultsStartTime).TotalSeconds >= resultsShowTime)
{
roomState = RoomState.SelectingSong;
selectedSong = null;
outMsg.Write((byte)CommandType.SetSelectedSong);
outMsg.Write((int)0);
BroadcastPacket(outMsg, NetDeliveryMethod.ReliableOrdered);
BroadcastWebSocket(CommandType.SetSelectedSong, null);
}
}
break;
case RoomState.SelectingSong:
{
switch (roomSettings.SelectionType)
{
case SongSelectionType.Random:
{
roomState = RoomState.Preparing;
Random rand = new Random();
randomSongTask = BeatSaver.GetRandomSong();
selectedSong = await randomSongTask;
randomSongTask = null;
outMsg.Write((byte)CommandType.SetSelectedSong);
selectedSong.AddToMessage(outMsg);
BroadcastPacket(outMsg, NetDeliveryMethod.ReliableOrdered);
BroadcastWebSocket(CommandType.SetSelectedSong, selectedSong);
ReadyStateChanged(roomHost, true);
}
break;
}
}
break;
}
if (outMsg.LengthBytes > 0)
{
outMsg = HubListener.ListenerServer.CreateMessage();
}
outMsg.Write((byte)CommandType.UpdatePlayerInfo);
switch (roomState)
{
case RoomState.SelectingSong:
{
outMsg.Write((float)0);
outMsg.Write((float)0);
}
break;
case RoomState.Preparing:
{
outMsg.Write((float)0);
outMsg.Write((float)0);
}
break;
case RoomState.InGame:
{
outMsg.Write((float)DateTime.Now.Subtract(_songStartTime).TotalSeconds);
outMsg.Write(selectedSong.songDuration);
}
break;
case RoomState.Results:
{
outMsg.Write((float)DateTime.Now.Subtract(_resultsStartTime).TotalSeconds);
outMsg.Write(resultsShowTime);
}
break;
}
outMsg.Write(roomClients.Count);
for (int i = 0; i < roomClients.Count; i++)
{
if (i < roomClients.Count)
{
if (roomClients[i] != null)
{
roomClients[i].playerInfo.AddToMessage(outMsg);
}
}
}
BroadcastPacket(outMsg, NetDeliveryMethod.UnreliableSequenced);
if (roomClients.Count > 0)
{
BroadcastWebSocket(CommandType.UpdatePlayerInfo, roomClients.Select(x => x.playerInfo).ToArray());
}
}
protected virtual void OnTick(object sender, HighResolutionTimerElapsedEventArgs e)
{
Tick?.Invoke(ellapsedTicks);
++ellapsedTicks;
}
void displayTimer_Elapsed(object sender, HighResolutionTimerElapsedEventArgs e)
{
PrintVariables();
}
private void Timer_Elapsed(object sender, HighResolutionTimerElapsedEventArgs e)
{
CmdNext_Click(sender, e);
}
public virtual void RoomLoop(object sender, HighResolutionTimerElapsedEventArgs e)
{
NetOutgoingMessage outMsg = HubListener.ListenerServer.CreateMessage();
switch (roomState)
{
case RoomState.InGame:
{
if ((DateTime.Now.Subtract(_songStartTime).TotalSeconds >= selectedSong.songDuration) ||
(DateTime.Now.Subtract(_songStartTime).TotalSeconds >= 10f && roomClients.All(x => x.playerInfo.playerState != PlayerState.Game)))
{
roomState = RoomState.Results;
_resultsStartTime = DateTime.Now;
outMsg.Write((byte)CommandType.GetRoomInfo);
GetRoomInfo().AddToMessage(outMsg);
BroadcastPacket(outMsg, NetDeliveryMethod.ReliableOrdered, 0);
if (roomClients.Count > 0)
{
BroadcastWebSocket(CommandType.GetRoomInfo, GetRoomInfo());
}
}
}
break;
case RoomState.Results:
{
if (DateTime.Now.Subtract(_resultsStartTime).TotalSeconds >= roomSettings.ResultsShowTime)
{
roomState = RoomState.SelectingSong;
selectedSong = null;
outMsg.Write((byte)CommandType.SetSelectedSong);
outMsg.Write((int)0);
BroadcastPacket(outMsg, NetDeliveryMethod.ReliableOrdered, 0);
BroadcastWebSocket(CommandType.SetSelectedSong, null);
}
}
break;
case RoomState.SelectingSong:
{
switch (roomSettings.SelectionType)
{
case SongSelectionType.Random:
{
if (!requestedRandomSong && roomClients.Count > 0 && roomClients.Any(x => roomHost.Equals(x.playerInfo)))
{
requestedRandomSong = true;
outMsg.Write((byte)CommandType.GetRandomSongInfo);
roomClients.First(x => roomHost.Equals(x.playerInfo)).playerConnection.SendMessage(outMsg, NetDeliveryMethod.ReliableOrdered, 0);
BroadcastWebSocket(CommandType.GetRandomSongInfo, null);
}
}
break;
}
}
break;
}
if (outMsg.LengthBytes > 0)
{
outMsg = HubListener.ListenerServer.CreateMessage();
}
outMsg.Write((byte)CommandType.UpdatePlayerInfo);
switch (roomState)
{
case RoomState.SelectingSong:
{
outMsg.Write((float)0);
outMsg.Write((float)0);
}
break;
case RoomState.Preparing:
{
outMsg.Write((float)0);
outMsg.Write((float)0);
}
break;
case RoomState.InGame:
{
outMsg.Write((float)DateTime.Now.Subtract(_songStartTime).TotalSeconds);
outMsg.Write(selectedSong.songDuration);
}
break;
case RoomState.Results:
{
outMsg.Write((float)DateTime.Now.Subtract(_resultsStartTime).TotalSeconds);
outMsg.Write(roomSettings.ResultsShowTime);
}
break;
}
outMsg.Write(roomClients.Count);
for (int i = 0; i < roomClients.Count; i++)
{
if (i < roomClients.Count)
{
if (roomClients[i] != null)
{
if (roomClients[i].playerInfo.Equals(roomHost) && roomClients[i].playerInfo.playerNameColor.Equals(Color32.defaultColor))
{
roomClients[i].playerInfo.playerNameColor = Color32.roomHostColor;
}
roomClients[i].playerInfo.AddToMessage(outMsg);
}
}
}
BroadcastPacket(outMsg, NetDeliveryMethod.UnreliableSequenced, 1);
if (roomClients.Count > 0)
{
BroadcastWebSocket(CommandType.UpdatePlayerInfo, roomClients.Select(x => x.playerInfo).ToArray());
}
}
