public void OnPlayerQuit(PlayerQuitEvent ev)
{
if (ev.Player != null)
{
Log.Info($"Player {ev.Player.Login} Disconnected", ConsoleColor.Yellow);
}
else
{
Log.Info($"Connection {ev.Client.ConnectionId} Disconnected", ConsoleColor.Yellow);
}
try
{
if (ev.Player != null)
{
var chunk = ev.Player.GetChunk();
chunk.PlayersInChunk.Remove(ev.Player);
Server.Players.Remove(ev.Player);
}
ev.Player = null;
ev.Client.Stop();
}
catch (Exception e)
{
Log.Error("ERROR FINISHING SOCKET");
}
}
internal void PlayerQuit(PlayerQuitEvent playerQuitEvent)
{
if (Game != null)
{
Game.LeaveGame(Player);
}
}
public void DisconnectClient(Identity ident, bool sendKicked = true)
{
PlayerQuitEvent @event = new PlayerQuitEvent(ident.Owner.Player);
var user = ident.GetUser();
@event.QuitMessage = "<b>" + user.Name + "</b> disconnected.";
byte index = GetUserIndex(ident);
RemovePlayer(index);
byte[] packet = ObjectSerializer.GetBytes(0, index);
AnnounceToAll(EPacket.DISCONNECTED, packet, 0);
if (sendKicked)
{
Send(ident, EPacket.KICKED, new byte[0], 0);
}
((ServerMultiplayerProvider)Provider).RemoveClient(ident);
EventManager.Instance.CallEvent(@event);
if (string.IsNullOrEmpty(@event.QuitMessage))
{
return;
}
Chat.Instance.SendServerMessage(@event.QuitMessage);
}
public void OnPlayerQuit(PlayerQuitEvent e)
{
var attribute = e.Player.GetAttribute <PlayerGameAttribute>();
if (attribute == null)
{
return;
}
attribute.PlayerQuit(e);
}
private OTAPI.HookResult PreResetHandler(Terraria.RemoteClient remoteClient)
{
Debug.Assert(remoteClient != null);
Debug.Assert(remoteClient.Id >= 0 && remoteClient.Id < Count);
// Check if the client was active since this gets called when setting up `RemoteClient` as well.
if (!remoteClient.IsActive)
{
return(OTAPI.HookResult.Continue);
}
var player = this[remoteClient.Id];
var evt = new PlayerQuitEvent(player);
_events.Raise(evt, _log);
return(OTAPI.HookResult.Continue);
}
public void OnPlayerQuit(PlayerQuitEvent ev)
{
if (!Server.Players.Contains(ev.Player))
{
return;
}
if (ev.Player != null)
{
Log.Info($"Player {ev.Player.Name} Disconnected", ConsoleColor.Yellow);
}
else
{
Log.Info($"Connection {ev.Client.ConnectionId} Disconnected", ConsoleColor.Yellow);
}
if (ev.Player != null) // will be null if havent downloaded assets, need to fix this
{
ev.Player.Target = null;
foreach (var targetingPlayer in ev.Player.BeingTargetedBy)
{
targetingPlayer.Target = null;
}
ev.Player.BeingTargetedBy.Clear();
Server.Map.UpdateEntityPosition(ev.Player, ev.Player.Position, null);
Server.Players.Remove(ev.Player);
}
ev.Player = null;
try
{
ev.Client.Stop();
}
catch (Exception e)
{
Log.Error("ERROR FINISHING SOCKET");
}
}
private void OnPlayerQuit(PlayerQuitEvent e)
{
logger.Info("{0} quit", e.Player);
PlayersAtTable.Remove(e.Player);
PlayersInCurrentPlay.Remove(e.Player);
}
public override void Deserialize(NetworkReader reader)
{
int seed = reader.ReadInt32();
BackgroundSelector.RoomType background =
(BackgroundSelector.RoomType)reader.ReadInt32();
DateTime time = Convert.ToDateTime(reader.ReadString());
Game = new GameRecord(seed, background, time);
Dictionary <int, PlayerProfile> players =
new Dictionary <int, PlayerProfile> ();
int count = reader.ReadInt32();
for (int i = 0; i < count; i++)
{
PlayerProfile profile = reader.ReadMessage <PlayerProfileMessage>().Profile;
players.Add(i, profile);
Game.AddPlayer(profile);
}
for (int i = 0; i < count; i++)
{
int number = reader.ReadInt32();
int score = reader.ReadInt32();
Game.UpdateScore(players[number], score);
}
count = reader.ReadInt32();
for (int i = 0; i < count; i++)
{
PlayerEvent playerEvent = null;
PlayerProfile profile = players[reader.ReadInt32()];
int frame = reader.ReadInt32();
short eventType = reader.ReadInt16();
switch (eventType)
{
case _movementEvent:
Vector3 position = reader.ReadVector3();
playerEvent = new PlayerMovementEvent(profile, frame, position);
break;
case _droppedItemEvent:
playerEvent = new PlayerDroppedItemEvent(profile, frame);
break;
case _dashStartedEvent:
playerEvent = new PlayerDashStartedEvent(profile, frame);
break;
case _dashStoppedEvent:
playerEvent = new PlayerDashStoppedEvent(profile, frame);
break;
case _quitEvent:
playerEvent = new PlayerQuitEvent(profile, frame);
break;
}
Game.AddEvent(playerEvent);
}
}
internal override void Receive(Identity id, byte[] packet, int size, int channel)
{
base.Receive(id, packet, size, channel);
EPacket parsedPacket = (EPacket)packet[0];
StripPacketByte(ref packet, ref size);
if (parsedPacket.IsUpdate())
{
foreach (Channel ch in Receivers.Where(ch => ch.ID == channel))
{
ch.Receive(id, packet, 0, size);
}
return;
}
if (id != ServerID)
{
return;
}
switch (parsedPacket)
{
case EPacket.WORKSHOP:
//todo
break;
case EPacket.TICK:
{
var data = ObjectSerializer.GetBytes(0, Time.realtimeSinceStartup);
Send(ServerID, EPacket.TIME, data, 0);
break;
}
case EPacket.TIME:
{
object[] args = ObjectSerializer.GetObjects(0, 0, packet, typeof(float));
LastNet = Time.realtimeSinceStartup;
OffsetNet = ((float)args[0]) + ((Time.realtimeSinceStartup - LastPing) / 2f);
Lag(Time.realtimeSinceStartup - LastPing);
break;
}
case EPacket.SHUTDOWN:
Disconnect();
break;
case EPacket.CONNECTED:
{
{
Type[] argTypes =
{
//[0] id, [1] name, [2] group, [3] position, [4], angle, [5] channel
typeof(Identity), typeof(string), typeof(ulong), typeof(Vector3), typeof(Vector3),
typeof(int), typeof(bool)
};
object[] args = ObjectSerializer.GetObjects(0, 0, packet, argTypes);
if (IsSinglePlayer)
{
return;
}
if (World.Loaded)
{
AddPlayer(Provider.Deserialilze((Identity)args[0]), (string)args[1], (ulong)args[2],
(Vector3)args[3], (Vector3)args[4], (int)args[5], (bool)args[6]);
}
else
{
QueuePlayer(Provider.Deserialilze((Identity)args[0]), (string)args[1], (ulong)args[2],
(Vector3)args[3], (Vector3)args[4], (int)args[5], (bool)args[6]);
}
break;
}
}
case EPacket.VERIFY:
LogUtils.Debug("Opening ticket");
byte[] ticket = ((ClientMultiplayerProvider)Provider).OpenTicket();
if (ticket == null)
{
LogUtils.Debug("ticket equals null");
Disconnect();
break;
}
Send(ServerID, EPacket.AUTHENTICATE, ticket, ticket.Length, 0);
break;
case EPacket.DISCONNECTED:
{
//If singleplayer (local server) we will already do this at ServerConnection
if (IsSinglePlayer)
{
return;
}
object[] args = ObjectSerializer.GetObjects(0, 0, packet, typeof(byte));
var index = (byte)args[0];
var user = GetUser(index);
PlayerQuitEvent @event = new PlayerQuitEvent(user.Player);
EventManager.Instance.CallEvent(@event);
RemovePlayer(index);
break;
}
case EPacket.REJECTED:
case EPacket.KICKED:
Disconnect();
break;
case EPacket.ACCEPTED:
{
object[] args = ObjectSerializer.GetObjects(0, 0, packet, typeof(ulong), typeof(int));
LogUtils.Debug("Setting MainPlayer channel to: " + (int)args[1]);
((ClientMultiplayerProvider)Provider).SetIdentity((ulong)args[0]);
((ClientMultiplayerProvider)Provider).AdvertiseGame(ServerID, _currentIp, _currentPort);
((ClientMultiplayerProvider)Provider).SetConnectInfo(_currentIp, _currentPort);
IsFavoritedServer = ((ClientMultiplayerProvider)Provider).IsFavoritedServer(_currentIp, _currentPort);
((ClientMultiplayerProvider)Provider).FavoriteServer(_currentIp, _currentPort);
break;
}
case EPacket.UPDATE_CHANNELS:
{
object[] args = ObjectSerializer.GetObjects(0, 0, packet, ChannelCount.GetType());
ChannelCount = (int)args[0];
break;
}
default:
LogUtils.LogWarning("Couldn't handle packet: " + parsedPacket);
break;
}
}
protected virtual void OnPlayerQuit(PlayerQuitEvent e, GameState state)
{
}
public void RemovePlayer(PlayerQuitEvent e)
{
if (Players.TryRemove(e.Player.ClientUuid, out OpenPlayer p))
{
}
}
public void OnPlayerQuit(PlayerQuitEvent e)
{
e.Player.SetAttribute <ChatCompanion>(null);
}
private void ExecuteEvent(PlayerQuitEvent playerQuitEvent)
{
eventEmitter.EmitPlayerQuitEvent(
playerObjects[playerQuitEvent.Profile]
);
}
