/// <summary>
/// Encrypt am outgoing message with this algorithm; no writing can be done to the message after encryption, or message will be corrupted
/// </summary>
public bool Encrypt(NetOutgoingMessage msg)
{
int payloadBitLength = msg.LengthBits;
int numBytes = msg.LengthBytes;
int blockSize = BlockSize;
int numBlocks = (int)Math.Ceiling((double)numBytes / (double)blockSize);
int dstSize = numBlocks * blockSize;
msg.EnsureBufferSize(dstSize * 8 + (4 * 8)); // add 4 bytes for payload length at end
msg.LengthBits = dstSize * 8; // length will automatically adjust +4 bytes when payload length is written
for (int i = 0; i < numBlocks; i++)
{
EncryptBlock(msg.m_data, (i * blockSize), m_tmp);
Buffer.BlockCopy(m_tmp, 0, msg.m_data, (i * blockSize), m_tmp.Length);
}
// add true payload length last
msg.Write((UInt32)payloadBitLength);
return true;
}
public override void WriteToBuffer(NetOutgoingMessage buffer)
{
buffer.Write(RequestId);
buffer.Write(SessionId);
}
/// <summary>
/// The encode.
/// </summary>
/// <param name="om">
/// The om.
/// </param>
public void Encode(NetOutgoingMessage om)
{
om.Write(this.EntityID);
om.Write(this.InfoID);
om.Write(this.SenderColor);
}
public void WriteMessage(NetOutgoingMessage message)
{
message.Write(Position.X);
message.Write(Position.Y);
message.Write(Rotation);
}
/// <summary>
/// Does collision detection between the shooter and the player
/// </summary>
/// <param name="shooter"></param>
static void BulletToPlayer(ServerPlayer shooter)
{
// Get the distance between the player and the shooter
foreach (ServerPlayer player in players)
{
// The shooter can't shoot themself, obviously.
if (player != shooter)
{
// If friendly fire is disabled and the player is
// on the same team, don't do collision detection
if (!friendlyFire && player.CurrentTeam == shooter.CurrentTeam)
{
continue;
}
// Get distance between the player and the enemy
Vector2 delta = player.Position - shooter.Position;
// Get -2Pi - 2Pi version of the shooter's angle
float angle = shooter.Rotation < 0 ? (float)(shooter.Rotation + (2 * Math.PI)) : shooter.Rotation;
// Get angle between shooter and player
float shooterToPlayerAngle = (float)Math.Atan2(delta.Y, delta.X);
// If the angle between the shooter and player is less than 0 radians
// add 2 Pi to convert it from -Pi - Pi domain to -2Pi - 2Pi domain
shooterToPlayerAngle = shooterToPlayerAngle < 0
? (float)(shooterToPlayerAngle + (2 * Math.PI))
: shooterToPlayerAngle;
// If the angle of the shooter is within 0.2 radians of the
// angle between the shooter and the player, it means they are
// not aiming in the opposite direction of the player which would
// result in the collision detection returning true
if (angle > shooterToPlayerAngle - 0.2f &&
angle < shooterToPlayerAngle + 0.2f)
{
// Get the direction of the shooter
Vector2 direction = new Vector2((float)Math.Cos(angle), (float)Math.Sin(angle));
// Get distance between the player and any possible obstacles in between the
// player and the enemy
RayCastResult result = raycaster.RayCastMethod(shooter.Position, direction, 1280,
MapData.TileMap, MapData.MapArea, angle);
// Get the delta between the collision point and the shooter
Vector2 raycastDistance = result.CollisionPos - shooter.Position;
// If the raycast had collided with an object in between two players
// the distance of the raycast would be shorter, therefore, the player
// has no direct line of sight with the other player
if (raycastDistance.Length() > delta.Length())
{
// If the shot passes through the player and they are alive
if (Collision.NonAACollision(shooter.Position,
shooter.Rotation, new Rectangle(
(int)player.Position.X - 16, (int)player.Position.Y + 16,
32, 32), player.Rotation) && player.State == ServerClientInterface.PlayerState.Alive)
{
// Deal the correct amount of damage depending on the weapon
switch (shooter.CurrentWeapon.Weapon)
{
case WeaponData.Weapon.Knife:
break;
case WeaponData.Weapon.Ak47:
player.Damage(12, 0);
break;
case WeaponData.Weapon.Glock:
break;
case WeaponData.Weapon.Awp:
break;
case WeaponData.Weapon.Usp:
break;
case WeaponData.Weapon.M4A1:
player.Damage(12, 0);
break;
}
Console.WriteLine("\"" + shooter.UserName + "\" shot \"" + player.UserName + " with " +
shooter.CurrentWeapon.Weapon);
// If the player's health is less than zero, they died. Let everyone know.
if (player.Health <= 0)
{
player.SetHealth(0);
player.SetArmor(0);
player.SetState(ServerClientInterface.PlayerState.Dead);
Console.WriteLine(shooter.UserName + " killed " + player.UserName +
" with " + shooter.CurrentWeapon.Weapon);
}
// Send data to all players
outMsg = server.CreateMessage();
outMsg.Write(ServerClientInterface.DAMAGE);
outMsg.Write(player.Identifier);
outMsg.Write(player.Health);
outMsg.Write(player.Armor);
server.SendToAll(outMsg, NetDeliveryMethod.UnreliableSequenced);
}
}
}
}
}
}
/// <summary>
/// Updates and processes requests by users
/// </summary>
public static void UpdateNetwork()
{
// TODO : Updates the network, recieves input.
while ((msg = server.ReadMessage()) != null)
{
outMsg = server.CreateMessage();
ServerPlayer player;
byte code;
switch (msg.MessageType)
{
case NetIncomingMessageType.StatusChanged:
switch ((NetConnectionStatus)msg.ReadByte())
{
case NetConnectionStatus.Connected:
// If someone has successfully connected to the server, check
// if there are too many connected clients and prevent entry from
// the client if the number of users exceed the max number of players
if (numPlayers > maxPlayers)
{
msg.SenderConnection.Deny("Server Is Full");
}
// initialize handshake with the client. Give them a unique identifier
// which allows the server to differ between multiple clients
outMsg.Write(ServerClientInterface.HANDSHAKE);
// Send the message
server.SendMessage(outMsg, msg.SenderConnection, NetDeliveryMethod.ReliableSequenced);
break;
case NetConnectionStatus.Disconnected:
// Get the player that just disconnected
player =
players.Find(
ply => ply.ConnectionIdentifier == msg.SenderConnection.RemoteUniqueIdentifier);
// Tell everyone that the user disconnected
outMsg.Write(ServerClientInterface.PLAYER_DISCONNECTED);
outMsg.Write(player.Identifier);
server.SendToAll(outMsg, NetDeliveryMethod.ReliableSequenced);
// Subtract number of players of the associated team
switch (player.CurrentTeam)
{
case ServerClientInterface.Team.CounterTerrorist:
numCts--;
break;
case ServerClientInterface.Team.Terrorist:
numTs--;
break;
}
// Subtract one less player on the server
numPlayers--;
Console.WriteLine("\"" + player.UserName + "\" has left the server");
// Remove the player from the server
players.Remove(player);
break;
}
break;
case NetIncomingMessageType.Data:
// Get identifier byte used to determine message type
code = msg.ReadByte();
switch (code)
{
// A user requested to retrieve information of all players on server
case ServerClientInterface.REQUEST_SYNC:
string username = msg.ReadString();
// Set up a new player in the server
player = new ServerPlayer(username, playerIdentifier, msg.SenderConnection.RemoteUniqueIdentifier);
players.Add(player);
playerIdentifier++;
numPlayers++;
// Let the client know their information was recieved and processed
outMsg.Write(ServerClientInterface.HANDSHAKE_COMPLETE);
outMsg.Write(player.Identifier);
server.SendMessage(outMsg, msg.SenderConnection, NetDeliveryMethod.ReliableSequenced);
// Resend data about players to everyone in order to stay in sync
SyncCurrentPlayers();
Console.WriteLine("\"" + username + "\" has joined the server");
break;
case ServerClientInterface.CHANGE_TEAM:
// Find the player with the matching unique identifier
player = players.Find(
ply => ply.ConnectionIdentifier == msg.SenderConnection.RemoteUniqueIdentifier);
// Change their team
player.SetTeam(msg.ReadByte());
// Increase the number of players currently on the
// associated team
switch (player.CurrentTeam)
{
case ServerClientInterface.Team.CounterTerrorist:
numCts++;
break;
case ServerClientInterface.Team.Terrorist:
numTs++;
break;
}
// Tell everyone else that the player had switched teams and
// what team they switched to
outMsg.Write(ServerClientInterface.CHANGE_TEAM);
outMsg.Write(player.Identifier);
outMsg.Write(ServerClientInterface.TeamToByte(player.CurrentTeam));
server.SendToAll(outMsg, NetDeliveryMethod.ReliableSequenced);
Console.WriteLine("\"" + player.UserName + "\" joined the " + player.CurrentTeam);
break;
// Movement Processing for 8 directions
case ServerClientInterface.MOVE_UP:
case ServerClientInterface.MOVE_DOWN:
case ServerClientInterface.MOVE_LEFT:
case ServerClientInterface.MOVE_RIGHT:
case ServerClientInterface.MOVE_UPLEFT:
case ServerClientInterface.MOVE_UPRIGHT:
case ServerClientInterface.MOVE_DOWNRIGHT:
case ServerClientInterface.MOVE_DOWNLEFT:
Move(code, msg.SenderConnection.RemoteUniqueIdentifier);
break;
// Rotation processing
case ServerClientInterface.ROTATE_PLAYER:
Rotate(msg.ReadFloat(), msg.SenderConnection.RemoteUniqueIdentifier);
break;
// Weapon buying processing
case ServerClientInterface.BUY_WEAPON:
byte wep = msg.ReadByte();
SpawnWeapon(msg.SenderConnection.RemoteUniqueIdentifier, wep);
break;
// Weapon firing processing
case ServerClientInterface.FIRE_WEAPON:
FireWeapon(msg.SenderConnection.RemoteUniqueIdentifier);
break;
// Flashbang exploding processing
case ServerClientInterface.EXPLODE_FLASHBANG:
outMsg.Write(ServerClientInterface.EXPLODE_FLASHBANG);
server.SendToAll(outMsg, NetDeliveryMethod.UnreliableSequenced);
break;
// User requested respawn
case ServerClientInterface.REQUEST_RESPAWN:
// Client requested respawn
player =
players.Find(
ply => ply.ConnectionIdentifier == msg.SenderConnection.RemoteUniqueIdentifier);
// If they are dead, respawn the player
if (player.State == ServerClientInterface.PlayerState.Dead)
{
RespawnPlayer(player);
}
break;
}
break;
}
}
}
static void Main(string[] args)
{
Dictionary <long, IPEndPoint[]> registeredHosts = new Dictionary <long, IPEndPoint[]>();
NetPeerConfiguration config = new NetPeerConfiguration("master");
config.SetMessageTypeEnabled(NetIncomingMessageType.UnconnectedData, true);
config.EnableMessageType(NetIncomingMessageType.DiscoveryRequest);
config.Port = 15002;
NetPeer peer = new NetPeer(config);
peer.Start();
// keep going until ESCAPE is pressed
Console.WriteLine("Press ESC to quit");
while (!Console.KeyAvailable || Console.ReadKey().Key != ConsoleKey.Escape)
{
NetIncomingMessage msg;
while ((msg = peer.ReadMessage()) != null)
{
switch (msg.MessageType)
{
case NetIncomingMessageType.DiscoveryRequest:
Console.WriteLine("Discover message from: " + msg.SenderEndPoint);
// Create a response and write some example data to it
NetOutgoingMessage response = peer.CreateMessage();
response.Write("master");
// Send the response to the sender of the request
peer.SendDiscoveryResponse(response, msg.SenderEndPoint);
break;
case NetIncomingMessageType.UnconnectedData:
//
// We've received a message from a client or a host
//
// by design, the first byte always indicates action
switch ((MasterServerMessageType)msg.ReadByte())
{
case MasterServerMessageType.RegisterHost:
// It's a host wanting to register its presence
var id = msg.ReadInt64(); // server unique identifier
Console.WriteLine("Got registration for host " + id);
registeredHosts[id] = new IPEndPoint[]
{
msg.ReadIPEndPoint(), // internal
msg.SenderEndPoint // external
};
break;
case MasterServerMessageType.RequestHostList:
// It's a client wanting a list of registered hosts
Console.WriteLine("Sending list of " + registeredHosts.Count + " hosts to client " + msg.SenderEndPoint);
// Clear original list.
NetOutgoingMessage outMsg = peer.CreateMessage();
outMsg.Write(true);
peer.SendUnconnectedMessage(outMsg, msg.SenderEndPoint);
foreach (var kvp in registeredHosts)
{
// send registered host to client
NetOutgoingMessage om = peer.CreateMessage();
om.Write(false);
om.Write(kvp.Key);
om.Write(kvp.Value[0]);
om.Write(kvp.Value[1]);
peer.SendUnconnectedMessage(om, msg.SenderEndPoint);
}
break;
case MasterServerMessageType.RequestIntroduction:
// It's a client wanting to connect to a specific (external) host
IPEndPoint clientInternal = msg.ReadIPEndPoint();
long hostId = msg.ReadInt64();
string token = msg.ReadString();
Console.WriteLine(msg.SenderEndPoint + " requesting introduction to " + hostId + " (token " + token + ")");
// find in list
IPEndPoint[] elist;
if (registeredHosts.TryGetValue(hostId, out elist))
{
// found in list - introduce client and host to eachother
Console.WriteLine("Sending introduction...");
peer.Introduce(
elist[0], // host internal
elist[1], // host external
clientInternal, // client internal
msg.SenderEndPoint, // client external
token // request token
);
}
else
{
Console.WriteLine("Client requested introduction to nonlisted host!");
}
break;
case MasterServerMessageType.RemoveHost:
long idRemove = msg.ReadInt64();
Console.WriteLine("De-register host " + idRemove);
registeredHosts.Remove(idRemove);
break;
case MasterServerMessageType.HostConnected:
long host = msg.ReadInt64();
Console.WriteLine("host: " + host + " is connected.");
registeredHosts.Remove(host); // Remove this host.
break;
}
break;
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.VerboseDebugMessage:
case NetIncomingMessageType.WarningMessage:
case NetIncomingMessageType.ErrorMessage:
// print diagnostics message
Console.WriteLine(msg.ReadString());
break;
}
}
}
peer.Shutdown("shutting down");
}
/// <summary>
/// Puts data into message
/// </summary>
/// <param name="message">desination</param>
protected override void Puts(NetOutgoingMessage message)
{
Byte[] bytes = this.B.ToByteArray();
message.Write(bytes.Length);
message.Write(bytes);
message.Write(this.Salt.Length);
message.Write(this.Salt);
}
internal override void InternalSerialize(NetOutgoingMessage lidgrenMsg)
{
lidgrenMsg.Write(ObjectId);
}
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);
outMsg.Write((byte)0);
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());
}
}
public static void TestEncryption(NetEncryption algo, bool printName = true)
{
NetOutgoingMessage om = algo.Peer.CreateMessage();
om.Write("Hallon");
om.Write(42);
om.Write(5, 5);
om.Write(true);
om.Write("kokos");
int unencLen = om.BitLength;
if (!om.Encrypt(algo))
{
throw new LidgrenException("failed to encrypt");
}
// convert to incoming message
NetIncomingMessage im = Program.CreateIncomingMessage(
om.GetBuffer().AsSpan(0, om.ByteLength).ToArray(), om.BitLength);
if (im.GetBuffer().Length == 0)
{
throw new LidgrenException("bad im!");
}
if (!im.Decrypt(algo))
{
throw new LidgrenException("failed to decrypt");
}
if (im.GetBuffer().Length == 0 || im.BitLength != unencLen)
{
throw new LidgrenException("Length fail");
}
var str = im.ReadString();
if (str != "Hallon")
{
throw new LidgrenException("fail");
}
if (im.ReadInt32() != 42)
{
throw new LidgrenException("fail");
}
if (im.ReadInt32(5) != 5)
{
throw new LidgrenException("fail");
}
if (im.ReadBool() != true)
{
throw new LidgrenException("fail");
}
if (im.ReadString() != "kokos")
{
throw new LidgrenException("fail");
}
if (printName)
{
Console.WriteLine(" - " + algo.GetType().Name + " OK");
}
}
public override void PacketToNetOutgoingMessage(NetOutgoingMessage message)
{
message.Write((byte)PacketTypes.QueueForGame);
}
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 (ListenerServer.ReadMessage(out msg))
{
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.updateInfo.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)
{
if (msg.PeekByte() == 1 || !client.lastUpdateIsFull)
{
client.UpdatePlayerInfo(msg);
}
if (Settings.Instance.Misc.PlayerColors.ContainsKey(client.playerInfo.playerId))
{
client.playerInfo.updateInfo.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.updateInfo.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 LevelOptionsInfo(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)
{
LevelOptionsInfo options = new LevelOptionsInfo(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);
}
}
private static void WriteNetworkValue(ref NetOutgoingMessage outgoingMessage, object networkValue)
{
if (networkValue == null)
{
throw new CoreException("NetworkValue is null");
}
else
{
if (networkValue is bool)
{
outgoingMessage.Write((bool)networkValue);
}
else if (networkValue is byte)
{
outgoingMessage.Write((byte)networkValue);
}
else if (networkValue is byte[])
{
var tempByteArray = (byte[])networkValue;
outgoingMessage.Write(tempByteArray.Length);
outgoingMessage.Write(tempByteArray);
}
else if (networkValue is char)
{
outgoingMessage.Write(BitConverter.GetBytes((char)networkValue));
}
else if (networkValue is char[])
{
var tempCharArray = (char[])networkValue;
outgoingMessage.Write(tempCharArray.Length);
for (int i = 0; i < tempCharArray.Length; i++)
{
outgoingMessage.Write(BitConverter.GetBytes(tempCharArray[i]));
}
}
else if (networkValue is Color)
{
outgoingMessage.Write(((Color)networkValue).ToVector4());
}
else if (networkValue is double)
{
outgoingMessage.Write((double)networkValue);
}
else if (networkValue is float)
{
outgoingMessage.Write((float)networkValue);
}
else if (networkValue is int)
{
outgoingMessage.Write((int)networkValue);
}
else if (networkValue is long)
{
outgoingMessage.Write((long)networkValue);
}
else if (networkValue is Matrix)
{
outgoingMessage.WriteMatrix((Matrix)networkValue);
}
else if (networkValue is Quaternion)
{
outgoingMessage.WriteRotation((Quaternion)networkValue, 24);
}
else if (networkValue is sbyte)
{
outgoingMessage.Write((sbyte)networkValue);
}
else if (networkValue is short)
{
outgoingMessage.Write((short)networkValue);
}
else if (networkValue is string)
{
outgoingMessage.Write((string)networkValue);
}
else if (networkValue is uint)
{
outgoingMessage.Write((uint)networkValue);
}
else if (networkValue is ulong)
{
outgoingMessage.Write((ulong)networkValue);
}
else if (networkValue is ushort)
{
outgoingMessage.Write((ushort)networkValue);
}
else if (networkValue is Vector2)
{
outgoingMessage.Write((Vector2)networkValue);
}
else if (networkValue is Vector3)
{
outgoingMessage.Write((Vector3)networkValue);
}
else if (networkValue is Vector4)
{
outgoingMessage.Write((Vector4)networkValue);
}
else
{
throw new CoreException("NetworkValue type isn't supported");
}
}
}
public override void WritePayload(NetOutgoingMessage message)
{
base.WritePayload(message);
message.Write((byte)ResponseResult);
message.Write((byte)DenyReason);
}
/// <summary>
/// Puts data into message
/// </summary>
/// <param name="message">desination</param>
protected override void Puts(NetOutgoingMessage message)
{
message.Write(this.Username);
message.Write(this.OtherData.Length);
if (this.OtherData.Length > 0)
message.Write(this.OtherData);
Byte[] bytes = this.A.ToByteArray();
message.Write(bytes.Length);
message.Write(bytes);
}
public override void EncodeMessage(NetOutgoingMessage msg)
{
msg.Write((byte)MessageType);
msg.Write(ID);
}
public override void WriteToBuffer(NetOutgoingMessage buffer)
{
buffer.Write((byte)PlaceType);
switch (PlaceType)
{
case PlacementManagerMessage.RequestPlacement:
buffer.Write(Align);
buffer.Write(IsTile);
if (IsTile)
{
buffer.Write(TileType);
}
else
{
buffer.Write(EntityTemplateName);
}
buffer.Write(XValue);
buffer.Write(YValue);
buffer.Write((byte)DirRcv);
break;
case PlacementManagerMessage.StartPlacement:
buffer.Write(Range);
buffer.Write(IsTile);
buffer.Write(ObjType);
buffer.Write(AlignOption);
break;
case PlacementManagerMessage.CancelPlacement:
case PlacementManagerMessage.PlacementFailed:
throw new NotImplementedException();
case PlacementManagerMessage.RequestEntRemove:
buffer.Write((int)EntityUid);
break;
}
}
/// <summary>
/// Encodes this state parameter to a network message
/// </summary>
/// <param name="msg">The message to encode to</param>
public void Encode(NetOutgoingMessage msg)
{
if (isSynced)
{
// Write the name and type
msg.Write(Name);
msg.Write((byte)myType);
// Write the value
switch (myType)
{
case Type.Byte:
msg.Write((byte)myValue);
break;
case Type.Char:
msg.Write((char)myValue);
break;
case Type.Short:
msg.Write((short)myValue);
break;
case Type.Int:
msg.Write((int)myValue);
break;
case Type.Bool:
msg.Write((bool)myValue);
break;
case Type.CardSuit:
msg.Write((byte)((CardSuit)myValue));
break;
case Type.CardRank:
msg.Write((byte)((CardSuit)myValue));
break;
case Type.String:
msg.Write((string)myValue);
break;
case Type.PlayingCard:
msg.Write(myValue != null);
if (myValue != null)
{
msg.Write((byte)(myValue as PlayingCard).Rank);
msg.Write((byte)(myValue as PlayingCard).Suit);
}
break;
case Type.CardCollection:
msg.Write((myValue as CardCollection).Count);
foreach (PlayingCard card in (myValue as CardCollection))
{
msg.Write(card != null);
if (card != null)
{
msg.Write((byte)card.Rank);
msg.Write((byte)card.Suit);
}
}
break;
}
// Write padding bits
msg.WritePadBits();
}
}
/// <summary>
/// Simulates world logic
/// </summary>
public static void Simulate()
{
// TODO: Runs all server based logic
switch (state)
{
case RoundState.Empty:
// If someone joined a team, begin a new game
if (numCts > 0 || numTs > 0)
{
// If the timer has not started yet
if (!timer.IsRunning)
{
// start the timer
timer.Start();
Console.WriteLine("A game has begun");
}
// Give users a few seconds to join teams
// before reseting the round
if (timer.Elapsed.TotalSeconds >= AFTER_ROUND_TIME)
{
StartRound();
timer.Reset();
}
}
break;
case RoundState.Buytime:
if (!timer.IsRunning)
{
timer.Start();
Console.WriteLine("Buytime...");
}
// If someone joins a team during buytime and they're dead, respawn them
foreach (ServerPlayer player in players)
{
if (player.State == ServerClientInterface.PlayerState.Dead &&
player.CurrentTeam != ServerClientInterface.Team.Spectator)
{
RespawnPlayer(player);
}
}
// If buytime is over, start the round
if (timer.Elapsed.TotalSeconds >= FREEZE_TIME)
{
// Let everyone know the round started
outMsg = server.CreateMessage();
outMsg.Write(ServerClientInterface.BEGIN_ROUND);
server.SendToAll(outMsg, NetDeliveryMethod.UnreliableSequenced);
state = RoundState.Play;
}
break;
case RoundState.Play:
break;
case RoundState.AfterRound:
break;
}
}
public override void WriteTo(NetOutgoingMessage msg)
{
base.WriteTo(msg);
msg.Write(HP);
}
/// <summary>
/// Respwans a player at their spawn point
/// </summary>
/// <param name="player"></param>
static void RespawnPlayer(ServerPlayer player)
{
// Default location
Vector2 location = Vector2.Zero;
// Randomly determine a spawn point depending on their team and
// respawns them there
int spawnPoint;
switch (player.CurrentTeam)
{
case ServerClientInterface.Team.CounterTerrorist:
while (true)
{
// Get a random index in the CT spawn points
spawnPoint = rand.Next(0, MapData.CTTile.Count);
bool empty = true;
// Check if nobody is currently on that spawn point
foreach (ServerPlayer ply in players)
{
if (ply.Identifier != player.Identifier)
{
if (MapData.CTTile[spawnPoint].TileRect.Contains((int)ply.Position.X,
(int)ply.Position.Y))
{
empty = false;
break;
}
}
}
if (empty)
{
location = new Vector2(MapData.CTTile[spawnPoint].TileRect.X + 16,
MapData.CTTile[spawnPoint].TileRect.Y + 16);
break;
}
}
break;
case ServerClientInterface.Team.Terrorist:
while (true)
{
// Get a random index in the T spawn points
spawnPoint = rand.Next(0, MapData.TTile.Count);
bool empty = true;
// Check if nobody is currently on that spawn point
foreach (ServerPlayer ply in players)
{
if (ply.Identifier != player.Identifier)
{
if (MapData.CTTile[spawnPoint].TileRect.Contains((int)ply.Position.X,
(int)ply.Position.Y))
{
empty = false;
break;
}
}
}
// If the spawn point is empty, allow the player to spawn there
if (empty)
{
location = new Vector2(MapData.TTile[spawnPoint].TileRect.X + 16,
MapData.TTile[spawnPoint].TileRect.Y + 16);
break;
}
}
break;
}
// Tell everyone the player respawned and their position
outMsg = server.CreateMessage();
player.Respawn(location);
outMsg.Write(ServerClientInterface.RESPAWN_PLAYER);
outMsg.Write(player.Identifier);
outMsg.Write(player.Position.X);
outMsg.Write(player.Position.Y);
server.SendToAll(outMsg, NetDeliveryMethod.ReliableSequenced);
}
public void Update()
{
if (NetworkClient != null && NetworkClient.Status == NetPeerStatus.Running)
{
NetIncomingMessage msg;
while ((msg = NetworkClient.ReadMessage()) != null)
{
switch (msg.MessageType)
{
case NetIncomingMessageType.StatusChanged:
{
NetConnectionStatus status = (NetConnectionStatus)msg.ReadByte();
if (status == NetConnectionStatus.Connected)
{
NetOutgoingMessage outMsg = NetworkClient.CreateMessage();
outMsg.Write((byte)CommandType.GetChannelInfo);
outMsg.Write(channelInfos[currentChannel].channelId);
NetworkClient.SendMessage(outMsg, NetDeliveryMethod.ReliableOrdered, 0);
}
else if (status == NetConnectionStatus.Disconnected)
{
ChannelException?.Invoke(this, new Exception("Channel refused connection!"));
Abort();
}
};
break;
case NetIncomingMessageType.Data:
{
if ((CommandType)msg.ReadByte() == CommandType.GetChannelInfo)
{
ChannelInfo received = new ChannelInfo(msg);
if (received.channelId == -1)
{
ChannelException?.Invoke(this, new Exception($"Channel with ID {channelInfos[currentChannel].channelId} not found!"));
Abort();
return;
}
received.ip = channelInfos[currentChannel].ip;
received.port = channelInfos[currentChannel].port;
ReceivedResponse?.Invoke(this, received);
if (channelInfos.Count - 1 > currentChannel)
{
currentChannel++;
NetOutgoingMessage outMsg = NetworkClient.CreateMessage();
outMsg.Write((byte)CommandType.GetChannelInfo);
outMsg.Write(channelInfos[currentChannel].channelId);
NetworkClient.SendMessage(outMsg, NetDeliveryMethod.ReliableOrdered, 0);
}
else
{
Abort();
}
}
};
break;
case NetIncomingMessageType.WarningMessage:
Misc.Logger.Warning(msg.ReadString());
break;
case NetIncomingMessageType.ErrorMessage:
Misc.Logger.Error(msg.ReadString());
break;
case NetIncomingMessageType.VerboseDebugMessage:
case NetIncomingMessageType.DebugMessage:
Misc.Logger.Info(msg.ReadString());
break;
default:
Console.WriteLine("Unhandled type: " + msg.MessageType);
break;
}
}
}
}
public override void WriteToBuffer(NetOutgoingMessage buffer)
{
buffer.Write(CanCall);
}
/// <summary>
/// Write a Point
/// </summary>
public static void Write(this NetOutgoingMessage message, Point value)
{
message.Write(value.X);
message.Write(value.Y);
}
public void PackInto(NetOutgoingMessage inMsg)
{
inMsg.WriteVariableUInt32((uint)textureID);
inMsg.Write(moveSpeed);
}
/// <summary>
/// Write a Single with half precision (16 bits)
/// </summary>
public static void WriteHalfPrecision(this NetOutgoingMessage message, float value)
{
message.Write(new HalfSingle(value).PackedValue);
}
internal override void InternalSerialize(NetOutgoingMessage lidgrenMsg)
{
base.InternalSerialize(lidgrenMsg);
GuidUtil.Serialize(VesselId, lidgrenMsg);
lidgrenMsg.Write(BodyIndex);
for (var i = 0; i < 3; i++)
{
lidgrenMsg.Write(LatLonAlt[i]);
}
for (var i = 0; i < 3; i++)
{
lidgrenMsg.Write(NormalVector[i]);
}
for (var i = 0; i < 3; i++)
{
lidgrenMsg.Write(Com[i]);
}
for (var i = 0; i < 3; i++)
{
lidgrenMsg.Write(TransformPosition[i]);
}
for (var i = 0; i < 3; i++)
{
lidgrenMsg.Write(Velocity[i]);
}
for (var i = 0; i < 8; i++)
{
lidgrenMsg.Write(Orbit[i]);
}
for (var i = 0; i < 4; i++)
{
lidgrenMsg.Write(SrfRelRotation[i]);
}
lidgrenMsg.Write(HeightFromTerrain);
lidgrenMsg.Write(TimeStamp);
lidgrenMsg.Write(GameTime);
}
/// <summary>
/// Writes a Vector3
/// </summary>
public static void Write(this NetOutgoingMessage message, Vector3 vector)
{
message.Write(vector.X);
message.Write(vector.Y);
message.Write(vector.Z);
}
public void AddToMessage(NetOutgoingMessage outMsg)
{
outMsg.Write(difficulty == BeatmapDifficulty.Normal || difficulty == BeatmapDifficulty.Expert);
outMsg.Write(difficulty == BeatmapDifficulty.Hard || difficulty == BeatmapDifficulty.Expert);
outMsg.Write(difficulty == BeatmapDifficulty.ExpertPlus);
outMsg.Write(modifiers.songSpeed == GameplayModifiers.SongSpeed.Faster);
outMsg.Write(modifiers.songSpeed == GameplayModifiers.SongSpeed.Slower);
outMsg.Write(modifiers.noFail);
outMsg.Write(modifiers.noObstacles);
outMsg.Write(modifiers.noBombs);
outMsg.Write(modifiers.noArrows);
outMsg.Write(modifiers.instaFail);
outMsg.Write(modifiers.batteryEnergy);
outMsg.Write(modifiers.disappearingArrows);
outMsg.Write(modifiers.ghostNotes);
bool writeCharName = false;
switch (characteristicName)
{
case "Standard":
outMsg.Write(false);
outMsg.Write(false);
break;
case "NoArrows":
outMsg.Write(false);
outMsg.Write(true);
break;
case "OneSaber":
outMsg.Write(true);
outMsg.Write(false);
break;
default:
outMsg.Write(true);
outMsg.Write(true);
writeCharName = true;
break;
}
outMsg.Write(false);
if (writeCharName)
{
outMsg.Write(characteristicName);
}
}
/// <summary>
/// Writes a Vector3 at half precision
/// </summary>
public static void WriteHalfPrecision(this NetOutgoingMessage message, Vector3 vector)
{
message.Write(new HalfSingle(vector.X).PackedValue);
message.Write(new HalfSingle(vector.Y).PackedValue);
message.Write(new HalfSingle(vector.Z).PackedValue);
}
/// <summary>
/// Write the events to the outgoing message. The recipient parameter is only needed for ServerEntityEventManager
/// </summary>
protected void Write(NetOutgoingMessage msg, List <NetEntityEvent> eventsToSync, Client recipient = null)
{
//write into a temporary buffer so we can write the number of events before the actual data
NetBuffer tempBuffer = new NetBuffer();
int eventCount = 0;
foreach (NetEntityEvent e in eventsToSync)
{
//write into a temporary buffer so we can write the length before the actual data
NetBuffer tempEventBuffer = new NetBuffer();
try
{
WriteEvent(tempEventBuffer, e, recipient);
}
catch (Exception exception)
{
DebugConsole.ThrowError("Failed to write an event for the entity \"" + e.Entity + "\"", exception);
GameAnalyticsManager.AddErrorEventOnce("NetEntityEventManager.Write:WriteFailed" + e.Entity.ToString(),
GameAnalyticsSDK.Net.EGAErrorSeverity.Error,
"Failed to write an event for the entity \"" + e.Entity + "\"\n" + exception.StackTrace);
//write an empty event to avoid messing up IDs
//(otherwise the clients might read the next event in the message and think its ID
//is consecutive to the previous one, even though we skipped over this broken event)
tempBuffer.Write((UInt16)0);
tempBuffer.WritePadBits();
eventCount++;
continue;
}
if (msg.LengthBytes + tempBuffer.LengthBytes + tempEventBuffer.LengthBytes > NetPeerConfiguration.kDefaultMTU - 20)
{
//no more room in this packet
break;
}
if (tempEventBuffer.LengthBytes > 255)
{
DebugConsole.ThrowError("Too much data in network event for entity \"" + e.Entity.ToString() + "\" (" + tempEventBuffer.LengthBytes + " bytes");
GameAnalyticsManager.AddErrorEventOnce("NetEntityEventManager.Write:TooLong" + e.Entity.ToString(),
GameAnalyticsSDK.Net.EGAErrorSeverity.Error,
"Too much data in network event for entity \"" + e.Entity.ToString() + "\" (" + tempEventBuffer.LengthBytes + " bytes");
}
//the ID has been taken by another entity (the original entity has been removed) -> write an empty event
else if (Entity.FindEntityByID(e.Entity.ID) != e.Entity || e.Entity.IdFreed)
{
//technically the clients don't have any use for these, but removing events and shifting the IDs of all
//consecutive ones is so error-prone that I think this is a safer option
tempBuffer.Write((UInt16)0);
tempBuffer.WritePadBits();
}
else
{
tempBuffer.Write((UInt16)e.Entity.ID);
tempBuffer.Write((byte)tempEventBuffer.LengthBytes);
tempBuffer.Write(tempEventBuffer);
tempBuffer.WritePadBits();
}
eventCount++;
}
if (eventCount > 0)
{
msg.Write(eventsToSync[0].ID);
msg.Write((byte)eventCount);
msg.Write(tempBuffer);
}
}
internal override void InternalSerialize(NetOutgoingMessage lidgrenMsg)
{
base.InternalSerialize(lidgrenMsg);
GuidUtil.Serialize(VesselId, lidgrenMsg);
lidgrenMsg.Write(MainThrottle);
lidgrenMsg.Write(WheelThrottle);
lidgrenMsg.Write(WheelThrottleTrim);
lidgrenMsg.Write(X);
lidgrenMsg.Write(Y);
lidgrenMsg.Write(Z);
lidgrenMsg.Write(KillRot);
lidgrenMsg.Write(GearUp);
lidgrenMsg.Write(GearDown);
lidgrenMsg.Write(Headlight);
lidgrenMsg.Write(Pitch);
lidgrenMsg.Write(Roll);
lidgrenMsg.Write(Yaw);
lidgrenMsg.Write(PitchTrim);
lidgrenMsg.Write(RollTrim);
lidgrenMsg.Write(YawTrim);
lidgrenMsg.Write(WheelSteer);
lidgrenMsg.Write(WheelSteerTrim);
lidgrenMsg.Write(TimeStamp);
lidgrenMsg.Write(TimeStamp);
}
/// <summary>
/// Puts data in message
/// </summary>
/// <param name="message"></param>
protected override void Puts(NetOutgoingMessage message)
{
message.Write(this.M.Length);
message.Write(this.M);
}
private void WriteLocalHail(NetOutgoingMessage om)
{
if (m_localHailMessage != null)
{
byte[] hi = m_localHailMessage.Data;
if (hi != null && hi.Length >= m_localHailMessage.LengthBytes)
{
if (om.LengthBytes + m_localHailMessage.LengthBytes > m_peerConfiguration.m_maximumTransmissionUnit - 10)
throw new NetException("Hail message too large; can maximally be " + (m_peerConfiguration.m_maximumTransmissionUnit - 10 - om.LengthBytes));
om.Write(m_localHailMessage.Data, 0, m_localHailMessage.LengthBytes);
}
}
}
