internal StreamEventsSlice(SliceReadStatus status,
string stream,
int fromEventNumber,
ReadDirection readDirection,
ClientMessage.ResolvedIndexedEvent[] events,
int nextEventNumber,
int lastEventNumber,
bool isEndOfStream)
{
Ensure.NotNullOrEmpty(stream, "stream");
Status = status;
Stream = stream;
FromEventNumber = fromEventNumber;
ReadDirection = readDirection;
if (events == null || events.Length == 0)
Events = Empty.ResolvedEvents;
else
{
Events = new ResolvedEvent[events.Length];
for (int i = 0; i < Events.Length; ++i)
{
Events[i] = new ResolvedEvent(events[i]);
}
}
NextEventNumber = nextEventNumber;
LastEventNumber = lastEventNumber;
IsEndOfStream = isEndOfStream;
}
public static FeedElement ToAllEventsForwardFeed(ClientMessage.ReadAllEventsForwardCompleted msg, Uri requestedUrl, EmbedLevel embedContent)
{
var self = HostName.Combine(requestedUrl, "/streams/{0}", AllEscaped);
var feed = new FeedElement();
feed.SetTitle("All events");
feed.SetId(self);
feed.SetUpdated(msg.Events.Length > 0 ? msg.Events[msg.Events.Length - 1].Event.TimeStamp : DateTime.MinValue.ToUniversalTime());
feed.SetAuthor(AtomSpecs.Author);
feed.AddLink("self", self);
feed.AddLink("first", HostName.Combine(requestedUrl, "/streams/{0}/head/backward/{1}", AllEscaped, msg.MaxCount));
if (msg.CurrentPos.CommitPosition != 0)
{
feed.AddLink("last", HostName.Combine(requestedUrl, "/streams/{0}/{1}/forward/{2}", AllEscaped, new TFPos(0, 0).AsString(), msg.MaxCount));
feed.AddLink("next", HostName.Combine(requestedUrl, "/streams/{0}/{1}/backward/{2}", AllEscaped, msg.PrevPos.AsString(), msg.MaxCount));
}
if (!msg.IsEndOfStream || msg.Events.Length > 0)
feed.AddLink("previous", HostName.Combine(requestedUrl, "/streams/{0}/{1}/forward/{2}", AllEscaped, msg.NextPos.AsString(), msg.MaxCount));
feed.AddLink("metadata", HostName.Combine(requestedUrl, "/streams/{0}/metadata", AllEscaped));
for (int i = msg.Events.Length - 1; i >= 0; --i)
{
feed.AddEntry(
ToEntry(
new ResolvedEvent(msg.Events[i].Event, msg.Events[i].Link, msg.Events[i].ResolveResult),
requestedUrl, embedContent));
}
return feed;
}
public static void Encode(SimpleEntryView<IData, IData> dataEntryView, ClientMessage clientMessage)
{
var key = dataEntryView.GetKey();
var value = dataEntryView.GetValue();
var cost = dataEntryView.GetCost();
var creationTime = dataEntryView.GetCreationTime();
var expirationTime = dataEntryView.GetExpirationTime();
var hits = dataEntryView.GetHits();
var lastAccessTime = dataEntryView.GetLastAccessTime();
var lastStoredTime = dataEntryView.GetLastStoredTime();
var lastUpdateTime = dataEntryView.GetLastUpdateTime();
var version = dataEntryView.GetVersion();
var ttl = dataEntryView.GetTtl();
var evictionCriteriaNumber = dataEntryView.GetEvictionCriteriaNumber();
clientMessage.Set(key)
.Set(value)
.Set(cost)
.Set(creationTime)
.Set(expirationTime)
.Set(hits)
.Set(lastAccessTime)
.Set(lastStoredTime)
.Set(lastUpdateTime)
.Set(version)
.Set(evictionCriteriaNumber)
.Set(ttl);
}
private void OnLoadStateReadRequestCompleted(ClientMessage.ReadStreamEventsBackwardCompleted message)
{
if (message.Events.Length > 0)
{
var checkpoint = message.Events.Where(v => v.Event.EventType == ProjectionEventTypes.ProjectionCheckpoint).Select(x => x.Event).FirstOrDefault();
if (checkpoint != null)
{
var parsed = checkpoint.Metadata.ParseCheckpointTagVersionExtraJson(_projectionVersion);
if (parsed.Version.ProjectionId != _projectionVersion.ProjectionId
|| _projectionVersion.Epoch > parsed.Version.Version)
{
_lastWrittenCheckpointEventNumber = checkpoint.EventNumber;
CheckpointLoaded(null, null);
}
else
{
//TODO: check epoch and correctly set _lastWrittenCheckpointEventNumber
var checkpointData = Helper.UTF8NoBom.GetString(checkpoint.Data);
_lastWrittenCheckpointEventNumber = checkpoint.EventNumber;
var adjustedTag = parsed.Tag; // the same projection and epoch, handle upgrades internally
CheckpointLoaded(adjustedTag, checkpointData);
}
return;
}
}
if (message.NextEventNumber != -1)
{
_nextStateIndexToRequest = message.NextEventNumber;
RequestLoadState();
return;
}
_lastWrittenCheckpointEventNumber = message.LastEventNumber;
CheckpointLoaded(null, null);
}
public static FeedElement ToStreamEventForwardFeed(ClientMessage.ReadStreamEventsForwardCompleted msg, Uri requestedUrl, EmbedLevel embedContent)
{
Ensure.NotNull(msg, "msg");
string escapedStreamId = Uri.EscapeDataString(msg.EventStreamId);
var self = HostName.Combine(requestedUrl, "/streams/{0}", escapedStreamId);
var feed = new FeedElement();
feed.SetTitle(string.Format("Event stream '{0}'", msg.EventStreamId));
feed.StreamId = msg.EventStreamId;
feed.SetId(self);
feed.SetUpdated(msg.Events.Length > 0 && msg.Events[0].Event != null ? msg.Events[0].Event.TimeStamp : DateTime.MinValue.ToUniversalTime());
feed.SetAuthor(AtomSpecs.Author);
feed.SetHeadOfStream(msg.IsEndOfStream);
var prevEventNumber = Math.Min(msg.FromEventNumber + msg.MaxCount - 1, msg.LastEventNumber) + 1;
var nextEventNumber = msg.FromEventNumber - 1;
feed.AddLink("self", self);
feed.AddLink("first", HostName.Combine(requestedUrl, "/streams/{0}/head/backward/{1}", escapedStreamId, msg.MaxCount));
if (nextEventNumber >= 0)
{
feed.AddLink("last", HostName.Combine(requestedUrl, "/streams/{0}/{1}/forward/{2}", escapedStreamId, 0, msg.MaxCount));
feed.AddLink("next", HostName.Combine(requestedUrl, "/streams/{0}/{1}/backward/{2}", escapedStreamId, nextEventNumber, msg.MaxCount));
}
if (!msg.IsEndOfStream || msg.Events.Length > 0)
feed.AddLink("previous", HostName.Combine(requestedUrl, "/streams/{0}/{1}/forward/{2}", escapedStreamId, prevEventNumber, msg.MaxCount));
if (!escapedStreamId.StartsWith("$$"))
feed.AddLink("metadata", HostName.Combine(requestedUrl, "/streams/{0}/metadata", escapedStreamId));
for (int i = msg.Events.Length - 1; i >= 0; --i)
{
feed.AddEntry(ToEntry(msg.Events[i], requestedUrl, embedContent));
}
return feed;
}
public static void HandlePacket(GameClientMessageHandler handler, ClientMessage message)
{
Console.ForegroundColor = ConsoleColor.DarkCyan;
if (Incoming.ContainsKey(message.Id))
{
if (AzureEmulator.DebugMode)
{
Console.WriteLine();
Console.Write("INCOMING ");
Console.ForegroundColor = ConsoleColor.DarkGreen;
Console.Write("HANDLED ");
Console.ForegroundColor = ConsoleColor.DarkGray;
Console.Write(message.Id + Environment.NewLine + message);
if (message.Length > 0)
Console.WriteLine();
Console.WriteLine();
}
StaticRequestHandler staticRequestHandler = Incoming[message.Id];
staticRequestHandler(handler);
}
else if (AzureEmulator.DebugMode)
{
Console.WriteLine();
Console.Write("INCOMING ");
Console.ForegroundColor = ConsoleColor.DarkRed;
Console.Write("REFUSED ");
Console.ForegroundColor = ConsoleColor.DarkGray;
Console.Write(message.Id + Environment.NewLine + message);
if (message.Length > 0)
Console.WriteLine();
Console.WriteLine();
}
}
public static FeedElement ToStreamEventBackwardFeed(ClientMessage.ReadStreamEventsBackwardCompleted msg, Uri requestedUrl, EmbedLevel embedContent, bool headOfStream)
{
Ensure.NotNull(msg, "msg");
string escapedStreamId = Uri.EscapeDataString(msg.EventStreamId);
var self = HostName.Combine(requestedUrl, "/streams/{0}", escapedStreamId);
var feed = new FeedElement();
feed.SetTitle(string.Format("Event stream '{0}'", msg.EventStreamId));
feed.StreamId = msg.EventStreamId;
feed.SetId(self);
feed.SetUpdated(msg.Events.Length > 0 ? msg.Events[0].Event.TimeStamp : DateTime.MinValue.ToUniversalTime());
feed.SetAuthor(AtomSpecs.Author);
var prevEventNumber = Math.Min(msg.FromEventNumber, msg.LastEventNumber) + 1;
var nextEventNumber = msg.FromEventNumber - msg.MaxCount;
feed.AddLink("self", self);
feed.AddLink("first", HostName.Combine(requestedUrl, "/streams/{0}/head/backward/{1}", escapedStreamId, msg.MaxCount));
if (!msg.IsEndOfStream)
{
if (nextEventNumber < 0) throw new Exception(string.Format("nextEventNumber is negative: {0} while IsEndOfStream", nextEventNumber));
feed.AddLink("last", HostName.Combine(requestedUrl, "/streams/{0}/{1}/forward/{2}", escapedStreamId, 0, msg.MaxCount));
feed.AddLink("next", HostName.Combine(requestedUrl, "/streams/{0}/{1}/backward/{2}", escapedStreamId, nextEventNumber, msg.MaxCount));
}
feed.AddLink("previous", HostName.Combine(requestedUrl, "/streams/{0}/{1}/forward/{2}", escapedStreamId, prevEventNumber, msg.MaxCount));
feed.AddLink("metadata", HostName.Combine(requestedUrl, "/streams/{0}/metadata", escapedStreamId));
for (int i = 0; i < msg.Events.Length; ++i)
{
feed.AddEntry(ToEntry(msg.Events[i], requestedUrl, embedContent));
}
return feed;
}
private void ReadUsersForwardCompleted(ClientMessage.ReadStreamEventsForwardCompleted result)
{
if (_aborted)
return;
switch (result.Result)
{
case ReadStreamResult.Success:
if (!result.IsEndOfStream)
BeginReadForward(result.NextEventNumber);
foreach (var loginName in from eventData in result.Events
let @event = eventData.Event
where @event.EventType == UserEventType
let stringData = Helper.UTF8NoBom.GetString(@event.Data)
select stringData)
BeginReadUserDetails(loginName);
break;
case ReadStreamResult.NoStream:
Abort(UserManagementMessage.Error.NotFound);
break;
default:
Abort(UserManagementMessage.Error.Error);
break;
}
_activeRequests--;
TryComplete();
}
public override void process(ClientMessage message, Transceiver connection)
{
if(message.type == "newUser")
{
this.RequestKey(message.Get("username"));
}
}
public static string SmartFormat(ClientMessage.ReadEventCompleted completed, ICodec targetCodec)
{
var dto = new HttpClientMessageDto.ReadEventCompletedText(completed);
if (completed.Record.Event.Flags.HasFlag(PrepareFlags.IsJson))
{
var deserializedData = Codec.Json.From<object>((string) dto.Data);
var deserializedMetadata = Codec.Json.From<object>((string) dto.Metadata);
if (deserializedData != null)
dto.Data = deserializedData;
if (deserializedMetadata != null)
dto.Metadata = deserializedMetadata;
}
switch (targetCodec.ContentType)
{
case ContentType.Xml:
case ContentType.ApplicationXml:
case ContentType.Atom:
{
var serializeObject = JsonConvert.SerializeObject(dto);
var deserializeXmlNode = JsonConvert.DeserializeXmlNode(serializeObject, "read-event-result");
return deserializeXmlNode.InnerXml;
}
default:
return targetCodec.To(dto);
}
}
internal static void ObjectCallback(ClientMessage message)
{
lock (freeObjects.SyncRoot)
{
freeObjects.Enqueue(message);
}
}
public override void Handle(ClientMessage.ReadAllEventsForwardCompleted message)
{
if (_disposed)
return;
if (!_eventsRequested)
throw new InvalidOperationException("Read events has not been requested");
if (_paused)
throw new InvalidOperationException("Paused");
_eventsRequested = false;
if (message.Result.Records.Length == 0)
{
// the end
if (_deliverEndOfTfPosition)
DeliverLastCommitPosition(_from);
// allow joining heading distribution
}
else
{
for (int index = 0; index < message.Result.Records.Length; index++)
{
var @event = message.Result.Records[index];
DeliverEvent(@event, message.Result.TfEofPosition);
}
_from = message.Result.NextPos;
}
if (_pauseRequested)
_paused = true;
else if (message.Result.Records.Length == 0)
RequestEvents(delay: true);
else
_publisher.Publish(CreateTickMessage());
}
internal static void HandlePacket(GameClientMessageHandler handler, ClientMessage message)
{
if (handlers.ContainsKey(message.Id))
{
StaticRequestHandler currentHandler = (StaticRequestHandler)handlers[message.Id];
currentHandler.Invoke(handler);
}
}
public static string GetJsonReadResult(ClientMessage.ReadEventCompleted completed, bool dataJson = true, bool metadataJson = true)
{
return string.Format(JsonReadFormat,
WrapIntoQuotes(completed.Record.Event.EventStreamId),
completed.Record.Event.EventNumber,
WrapIntoQuotes(completed.Record.Event.EventType),
dataJson ? JsonData : WrapIntoQuotes(AsString(completed.Record.Event.Data)),
metadataJson ? JsonMetadata : WrapIntoQuotes(AsString(completed.Record.Event.Metadata)));
}
private void SendConnectionMessage(Controller controller, string username, string password, string servername, string port)
{
ClientMessage message = new ClientMessage("connect");
message.Add("server", servername);
message.Add("port", port);
message.Add("username", username);
message.Add("password", password);
controller.message_pump.process_message(message);
}
public static string GetXmlReadResult(ClientMessage.ReadEventCompleted completed, bool dataJson = true, bool metadataJson = true)
{
return string.Format(XmlReadFormat,
completed.Record.Event.EventStreamId,
completed.Record.Event.EventNumber,
completed.Record.Event.EventType,
dataJson ? XmlData : AsString(completed.Record.Event.Data),
metadataJson ? XmlMetadata : AsString(completed.Record.Event.Metadata));
}
public static bool InvokeHandler(ref TcpClient sender, ClientMessage opcode, byte[] data)
{
if (OpcodeHandlers.ContainsKey(opcode))
{
OpcodeHandlers[opcode].Invoke(ref sender, data);
return true;
}
else
return false;
}
public static bool InvokeHandler(ref PacketReader reader, WorldClass session, ClientMessage opcode)
{
if (OpcodeHandlers.ContainsKey(opcode))
{
OpcodeHandlers[opcode].Invoke(ref reader, ref session);
return true;
}
else
return false;
}
public override void Handle(ClientMessage.ReadStreamEventsForwardCompleted message)
{
if (_disposed)
return;
if (!_eventsRequested)
throw new InvalidOperationException("Read events has not been requested");
if (message.EventStreamId != _streamName)
throw new InvalidOperationException(
string.Format("Invalid stream name: {0}. Expected: {1}", message.EventStreamId, _streamName));
if (_paused)
throw new InvalidOperationException("Paused");
_eventsRequested = false;
switch (message.Result)
{
case ReadStreamResult.NoStream:
DeliverSafeJoinPosition(GetLastCommitPositionFrom(message)); // allow joining heading distribution
if (_pauseRequested)
_paused = true;
else
RequestEvents(delay: true);
SendIdle();
SendEof();
break;
case ReadStreamResult.Success:
if (message.Events.Length == 0)
{
// the end
DeliverSafeJoinPosition(GetLastCommitPositionFrom(message));
SendIdle();
SendEof();
}
else
{
for (int index = 0; index < message.Events.Length; index++)
{
var @event = message.Events[index].Event;
var @link = message.Events[index].Link;
DeliverEvent(@event, @link, 100.0f * (link ?? @event).EventNumber / message.LastEventNumber);
}
}
if (_disposed)
return;
if (_pauseRequested)
_paused = true;
else if (message.Events.Length == 0)
RequestEvents(delay: true);
else
_publisher.Publish(CreateTickMessage());
break;
default:
throw new NotSupportedException(
string.Format("ReadEvents result code was not recognized. Code: {0}", message.Result));
}
}
public void process_message(ClientMessage message)
{
try
{
this._client_event(message, this.connection);
}
catch(Exception e)
{
Logger.log("Error: No plugins loaded to process client message. (Dropping) "+e.Message+" \n"+e.StackTrace, Logger.Verbosity.moderate);
}
}
public static void HandlePacket(GameClientMessageHandler handler, ClientMessage message)
{
if (StaticClientMessageHandler.handlers.ContainsKey(message.Id))
{
// Logging.WriteLine(message.ToString(), ConsoleColor.Green);
StaticClientMessageHandler.StaticRequestHandler staticRequestHandler = StaticClientMessageHandler.handlers[message.Id];
staticRequestHandler(handler);
return;
}
// Logging.WriteLine(message.ToString(), ConsoleColor.Red);
}
internal RecordedEvent(ClientMessage.StreamEventAppeared streamEvent)
{
EventStreamId = streamEvent.EventStreamId;
EventId = new Guid(streamEvent.EventId);
EventNumber = streamEvent.EventNumber;
EventType = streamEvent.EventType;
Data = streamEvent.Data;
Metadata = streamEvent.Metadata;
}
internal EventReadResult(EventReadStatus status,
string stream,
int eventNumber,
ClientMessage.ResolvedIndexedEvent @event)
{
Ensure.NotNullOrEmpty(stream, "stream");
Status = status;
Stream = stream;
EventNumber = eventNumber;
Event = status == EventReadStatus.Success ? new ResolvedEvent(@event) : (ResolvedEvent?)null;
}
internal RecordedEvent(ClientMessage.EventRecord systemRecord)
{
EventStreamId = systemRecord.EventStreamId;
EventId = new Guid(systemRecord.EventId);
EventNumber = systemRecord.EventNumber;
EventType = systemRecord.EventType;
Data = systemRecord.Data;
Metadata = systemRecord.Metadata;
}
public static void HandlePacket(GameClientMessageHandler handler, ClientMessage message)
{
if (StaticClientMessageHandler.handlers.ContainsKey(message.Id))
{
#if DEBUG
Logging.WriteLine("Packet id = " + message.Id, ConsoleColor.Green);
#endif
StaticClientMessageHandler.StaticRequestHandler staticRequestHandler = StaticClientMessageHandler.handlers[message.Id];
staticRequestHandler(handler);
return;
}
}
public static void Encode(StackTraceElement stackTraceElement, ClientMessage clientMessage)
{
clientMessage.Set(stackTraceElement.ClassName);
clientMessage.Set(stackTraceElement.MethodName);
string fileName = stackTraceElement.FileName;
var fileName_NotNull = fileName != null;
clientMessage.Set(fileName_NotNull);
if (fileName_NotNull)
{
clientMessage.Set(fileName);
}
clientMessage.Set(stackTraceElement.LineNumber);
}
internal RecordedEvent(ClientMessage.EventRecord systemRecord)
{
EventStreamId = systemRecord.EventStreamId;
EventId = new Guid(systemRecord.EventId);
EventNumber = systemRecord.EventNumber;
EventType = systemRecord.EventType;
if (systemRecord.Created.HasValue)
Created = DateTime.FromBinary(systemRecord.Created.Value);
Data = systemRecord.Data ?? Empty.ByteArray;
Metadata = systemRecord.Metadata ?? Empty.ByteArray;
}
public static void sendPacket(TcpClient client, ClientMessage clientMessage, byte[] data)
{
// create the packet that will be send
byte[] appendedOpcode = new byte[data.Length + 1];
data.CopyTo(appendedOpcode, 1);
appendedOpcode[0] = (byte)clientMessage;
data = appendedOpcode;
// SEND
NetworkStream clientStream = client.GetStream();
clientStream.Write(data, 0, data.Count());
clientStream.Flush();
}
public static string ConvertOnRead(ClientMessage.ReadEventCompleted completed, ICodec responseCodec)
{
var dto = new ClientMessageDto.ReadEventCompletedText(completed);
if (completed.Record.Flags.HasFlag(PrepareFlags.IsJson))
{
dto.Data = Codec.Json.From<object>((string) dto.Data);
dto.Metadata = Codec.Json.From<object>((string) dto.Metadata);
}
var type = responseCodec.GetType();
type = type == typeof (CustomCodec) ? ((CustomCodec) responseCodec).BaseCodec.GetType() : type;
return type == typeof(XmlCodec) ? Codec.Json.ToXmlUsingJson(dto) : responseCodec.To(dto);
}
public void LoadStateCompleted(ClientMessage.ReadStreamEventsBackwardCompleted msg)
{
if (msg.Events.Length > 0)
{
var checkpoint = msg.Events.Where(v => v.Event.EventType == "SubscriptionCheckpoint").Select(x => x.Event).FirstOrDefault();
if (checkpoint != null)
{
var lastEvent = checkpoint.Data.ParseJson<int>();
_onStateLoaded(lastEvent);
return;
}
}
_onStateLoaded(null);
}
public void Handle(GameClient Session, ClientMessage Event)
{
Session.SendMessage(GoldTree.GetGame().GetCatalog().method_18(Session.GetHabbo().Rank));
}
public static void TurbineChatReceived(ClientMessage clientMessage, Session session)
{
if (!PropertyManager.GetBool("use_turbine_chat").Item)
{
return;
}
clientMessage.Payload.ReadUInt32(); // Bytes to follow
var chatBlobType = (ChatNetworkBlobType)clientMessage.Payload.ReadUInt32();
clientMessage.Payload.ReadUInt32(); // Always 2
clientMessage.Payload.ReadUInt32(); // Always 1
clientMessage.Payload.ReadUInt32(); // Always 0
clientMessage.Payload.ReadUInt32(); // Always 0
clientMessage.Payload.ReadUInt32(); // Always 0
clientMessage.Payload.ReadUInt32(); // Always 0
clientMessage.Payload.ReadUInt32(); // Bytes to follow
if (session.Player.IsGagged)
{
session.Player.SendGagError();
return;
}
if (chatBlobType == ChatNetworkBlobType.NETBLOB_REQUEST_BINARY)
{
var contextId = clientMessage.Payload.ReadUInt32(); // 0x01 - 0x71 (maybe higher), typically though 0x01 - 0x0F
clientMessage.Payload.ReadUInt32(); // Always 2
clientMessage.Payload.ReadUInt32(); // Always 2
var channelID = clientMessage.Payload.ReadUInt32();
int messageLen = clientMessage.Payload.ReadByte();
if ((messageLen & 0x80) > 0) // PackedByte
{
byte lowbyte = clientMessage.Payload.ReadByte();
messageLen = ((messageLen & 0x7F) << 8) | lowbyte;
}
var messageBytes = clientMessage.Payload.ReadBytes(messageLen * 2);
var message = Encoding.Unicode.GetString(messageBytes);
clientMessage.Payload.ReadUInt32(); // Always 0x0C
var senderID = clientMessage.Payload.ReadUInt32();
clientMessage.Payload.ReadUInt32(); // Always 0
var chatType = (ChatType)clientMessage.Payload.ReadUInt32();
if (channelID == TurbineChatChannel.Society) // shouldn't ever be hit
{
ChatPacket.SendServerMessage(session, "You do not belong to a society.", ChatMessageType.Broadcast); // I don't know if this is how it was done on the live servers
return;
}
var gameMessageTurbineChat = new GameMessageTurbineChat(ChatNetworkBlobType.NETBLOB_EVENT_BINARY, channelID, session.Player.Name, message, senderID, chatType);
if (channelID > TurbineChatChannel.SocietyRadiantBlood) // Channel must be an allegiance channel
{
var allegiance = AllegianceManager.FindAllegiance(channelID);
if (allegiance != null)
{
// is sender booted / gagged?
if (!allegiance.IsMember(session.Player.Guid))
{
return;
}
if (allegiance.IsFiltered(session.Player.Guid))
{
return;
}
// iterate through all allegiance members
foreach (var member in allegiance.Members.Keys)
{
// is this allegiance member online?
var online = PlayerManager.GetOnlinePlayer(member);
if (online == null)
{
continue;
}
// is this member booted / gagged?
if (allegiance.IsFiltered(member) || online.SquelchManager.Squelches.Contains(session.Player, ChatMessageType.Allegiance))
{
continue;
}
// does this player have allegiance chat filtered?
if (!online.GetCharacterOption(CharacterOption.ListenToAllegianceChat))
{
continue;
}
online.Session.Network.EnqueueSend(gameMessageTurbineChat);
}
session.Network.EnqueueSend(new GameMessageTurbineChat(ChatNetworkBlobType.NETBLOB_RESPONSE_BINARY, contextId, null, null, 0, chatType));
}
}
else if (channelID > TurbineChatChannel.Society) // Channel must be a society restricted channel
{
var senderSociety = session.Player.Society;
//var adjustedChatType = senderSociety switch
//{
// FactionBits.CelestialHand => ChatType.SocietyCelHan,
// FactionBits.EldrytchWeb => ChatType.SocietyEldWeb,
// FactionBits.RadiantBlood => ChatType.SocietyRadBlo,
// _ => ChatType.Society
//};
//gameMessageTurbineChat = new GameMessageTurbineChat(ChatNetworkBlobType.NETBLOB_EVENT_BINARY, channelID, session.Player.Name, message, senderID, adjustedChatType);
if (senderSociety == FactionBits.None)
{
ChatPacket.SendServerMessage(session, "You do not belong to a society.", ChatMessageType.Broadcast); // I don't know if this is how it was done on the live servers
return;
}
foreach (var recipient in PlayerManager.GetAllOnline())
{
// handle filters
if (senderSociety != recipient.Society && !recipient.IsAdmin)
{
continue;
}
if (!recipient.GetCharacterOption(CharacterOption.ListenToSocietyChat))
{
continue;
}
if (recipient.SquelchManager.Squelches.Contains(session.Player, ChatMessageType.AllChannels))
{
continue;
}
recipient.Session.Network.EnqueueSend(gameMessageTurbineChat);
}
session.Network.EnqueueSend(new GameMessageTurbineChat(ChatNetworkBlobType.NETBLOB_RESPONSE_BINARY, contextId, null, null, 0, chatType));
}
else if (channelID == TurbineChatChannel.Olthoi) // Channel must is the Olthoi play channel
{
// todo: olthoi play chat (ha! yeah right...)
}
else // Channel must be one of the channels available to all players
{
if (PropertyManager.GetBool("chat_echo_only").Item)
{
session.Network.EnqueueSend(gameMessageTurbineChat);
session.Network.EnqueueSend(new GameMessageTurbineChat(ChatNetworkBlobType.NETBLOB_RESPONSE_BINARY, contextId, null, null, 0, chatType));
return;
}
if (PropertyManager.GetBool("chat_requires_account_15days").Item&& !session.Player.Account15Days)
{
if (PropertyManager.GetBool("chat_echo_reject").Item)
{
session.Network.EnqueueSend(gameMessageTurbineChat);
}
session.Network.EnqueueSend(new GameMessageTurbineChat(ChatNetworkBlobType.NETBLOB_RESPONSE_BINARY, contextId, null, null, 0, chatType));
return;
}
var chat_requires_account_time_seconds = PropertyManager.GetLong("chat_requires_account_time_seconds").Item;
if (chat_requires_account_time_seconds > 0 && (DateTime.UtcNow - session.Player.Account.CreateTime).TotalSeconds < chat_requires_account_time_seconds)
{
if (PropertyManager.GetBool("chat_echo_reject").Item)
{
session.Network.EnqueueSend(gameMessageTurbineChat);
}
session.Network.EnqueueSend(new GameMessageTurbineChat(ChatNetworkBlobType.NETBLOB_RESPONSE_BINARY, contextId, null, null, 0, chatType));
return;
}
var chat_requires_player_age = PropertyManager.GetLong("chat_requires_player_age").Item;
if (chat_requires_player_age > 0 && session.Player.Age < chat_requires_player_age)
{
if (PropertyManager.GetBool("chat_echo_reject").Item)
{
session.Network.EnqueueSend(gameMessageTurbineChat);
}
session.Network.EnqueueSend(new GameMessageTurbineChat(ChatNetworkBlobType.NETBLOB_RESPONSE_BINARY, contextId, null, null, 0, chatType));
return;
}
var chat_requires_player_level = PropertyManager.GetLong("chat_requires_player_level").Item;
if (chat_requires_player_level > 0 && session.Player.Level < chat_requires_player_level)
{
if (PropertyManager.GetBool("chat_echo_reject").Item)
{
session.Network.EnqueueSend(gameMessageTurbineChat);
}
session.Network.EnqueueSend(new GameMessageTurbineChat(ChatNetworkBlobType.NETBLOB_RESPONSE_BINARY, contextId, null, null, 0, chatType));
return;
}
foreach (var recipient in PlayerManager.GetAllOnline())
{
// handle filters
if (channelID == TurbineChatChannel.General && !recipient.GetCharacterOption(CharacterOption.ListenToGeneralChat) ||
channelID == TurbineChatChannel.Trade && !recipient.GetCharacterOption(CharacterOption.ListenToTradeChat) ||
channelID == TurbineChatChannel.LFG && !recipient.GetCharacterOption(CharacterOption.ListenToLFGChat) ||
channelID == TurbineChatChannel.Roleplay && !recipient.GetCharacterOption(CharacterOption.ListenToRoleplayChat))
{
continue;
}
if ((channelID == TurbineChatChannel.General && PropertyManager.GetBool("chat_disable_general").Item) ||
(channelID == TurbineChatChannel.Trade && PropertyManager.GetBool("chat_disable_trade").Item) ||
(channelID == TurbineChatChannel.LFG && PropertyManager.GetBool("chat_disable_lfg").Item) ||
(channelID == TurbineChatChannel.Roleplay && PropertyManager.GetBool("chat_disable_roleplay").Item))
{
if (PropertyManager.GetBool("chat_echo_reject").Item)
{
session.Network.EnqueueSend(gameMessageTurbineChat);
}
session.Network.EnqueueSend(new GameMessageTurbineChat(ChatNetworkBlobType.NETBLOB_RESPONSE_BINARY, contextId, null, null, 0, chatType));
return;
}
if (recipient.SquelchManager.Squelches.Contains(session.Player, ChatMessageType.AllChannels))
{
continue;
}
recipient.Session.Network.EnqueueSend(gameMessageTurbineChat);
}
session.Network.EnqueueSend(new GameMessageTurbineChat(ChatNetworkBlobType.NETBLOB_RESPONSE_BINARY, contextId, null, null, 0, chatType));
}
LogTurbineChat(channelID, session.Player.Name, message, senderID, chatType);
}
else
{
Console.WriteLine($"Unhandled TurbineChatHandler ChatNetworkBlobType: 0x{(uint)chatBlobType:X4}");
}
}
public void Handle(GameClient Session, ClientMessage Event)
{
Session.SendMessage(Essential.GetGame().GetNavigator().SerializePopularRoomTags());
}
public static void Handle(ClientMessage message, Session session)
{
//Console.WriteLine("Received 0x24C - House - RemoveAllStoragePermission");
session.Player.HandleActionRemoveAllStorage();
}
protected override Guid ReadSubscribeResponse(ClientMessage responseMessage, SubscriptionState <CollectionItemEventHandlers <T> > state) => ListAddListenerCodec.DecodeResponse(responseMessage).Response;
public void HandleActionFinishBarber(ClientMessage message)
{
// Read the payload sent from the client...
PaletteBaseId = message.Payload.ReadUInt32();
HeadObjectDID = message.Payload.ReadUInt32();
Character.HairTexture = message.Payload.ReadUInt32();
Character.DefaultHairTexture = message.Payload.ReadUInt32();
CharacterChangesDetected = true;
EyesTextureDID = message.Payload.ReadUInt32();
DefaultEyesTextureDID = message.Payload.ReadUInt32();
NoseTextureDID = message.Payload.ReadUInt32();
DefaultNoseTextureDID = message.Payload.ReadUInt32();
MouthTextureDID = message.Payload.ReadUInt32();
DefaultMouthTextureDID = message.Payload.ReadUInt32();
SkinPaletteDID = message.Payload.ReadUInt32();
HairPaletteDID = message.Payload.ReadUInt32();
EyesPaletteDID = message.Payload.ReadUInt32();
SetupTableId = message.Payload.ReadUInt32();
uint option_bound = message.Payload.ReadUInt32(); // Supress Levitation - Empyrean Only
uint option_unk = message.Payload.ReadUInt32(); // Unknown - Possibly set aside for future use?
// Check if Character is Empyrean, and if we need to set/change/send new motion table
if (Heritage == 9)
{
// These are the motion tables for Empyrean float and not-float (one for each gender). They are hard-coded into the client.
const uint EmpyreanMaleFloatMotionDID = 0x0900020Bu;
const uint EmpyreanFemaleFloatMotionDID = 0x0900020Au;
const uint EmpyreanMaleMotionDID = 0x0900020Eu;
const uint EmpyreanFemaleMotionDID = 0x0900020Du;
// Check for the Levitation option for Empyrean. Shadow crown and Undead flames are handled by client.
if (Gender == 1) // Male
{
if (option_bound == 1 && MotionTableId != EmpyreanMaleMotionDID)
{
MotionTableId = EmpyreanMaleMotionDID;
Session.Network.EnqueueSend(new GameMessagePrivateUpdateDataID(this, PropertyDataId.MotionTable, (uint)MotionTableId));
}
else if (option_bound == 0 && MotionTableId != EmpyreanMaleFloatMotionDID)
{
MotionTableId = EmpyreanMaleFloatMotionDID;
Session.Network.EnqueueSend(new GameMessagePrivateUpdateDataID(this, PropertyDataId.MotionTable, (uint)MotionTableId));
}
}
else // Female
{
if (option_bound == 1 && MotionTableId != EmpyreanFemaleMotionDID)
{
MotionTableId = EmpyreanFemaleMotionDID;
Session.Network.EnqueueSend(new GameMessagePrivateUpdateDataID(this, PropertyDataId.MotionTable, (uint)MotionTableId));
}
else if (option_bound == 0 && MotionTableId != EmpyreanFemaleFloatMotionDID)
{
MotionTableId = EmpyreanFemaleFloatMotionDID;
Session.Network.EnqueueSend(new GameMessagePrivateUpdateDataID(this, PropertyDataId.MotionTable, (uint)MotionTableId));
}
}
}
// Broadcast updated character appearance
EnqueueBroadcast(new GameMessageObjDescEvent(this));
}
public void Handle(GameClient Session, ClientMessage Event)
{
Session.SendMessage(GoldTree.GetGame().GetNavigator().method_12(Session, -3));
}
private static void smethod_6(Session session_0, ClientMessage clientMessage_0)
{
session_0.SendData(SpaceLatencyTestComposer.Compose(), false);
}
/// <summary>
/// Handles the request.
/// </summary>
/// <param name="request">The request.</param>
internal void HandleRequest(ClientMessage request)
{
Request = request;
LibraryParser.HandlePacket(this, request);
}
private static void smethod_25(Session session_0, ClientMessage clientMessage_0)
{
}
private static void smethod_18(Session session_0, ClientMessage clientMessage_0)
{
if (!session_0.CharacterInfo.IsMuted)
{
SpaceInstance instanceBySpaceId = SpaceManager.GetInstanceBySpaceId(session_0.CurrentSpaceId);
if (instanceBySpaceId != null)
{
SpaceActor actorByReferenceId = instanceBySpaceId.GetActorByReferenceId(session_0.CharacterId, SpaceActorType.UserCharacter);
if (actorByReferenceId != null)
{
CharacterInfo referenceObject = (CharacterInfo)actorByReferenceId.ReferenceObject;
clientMessage_0.ReadUnsignedInteger();
string input = InputFilter.FilterString(clientMessage_0.ReadString().Trim(), false);
int messageColor = clientMessage_0.ReadInteger();
if (input.Length != 0)
{
if (input.Length > 100)
{
input = input.Substring(0, 100);
}
if (referenceObject.Staff == 0)
{
messageColor = 1;
}
if (referenceObject.Staff == 1)
{
messageColor = 2;
}
if (referenceObject.Staff == 2)
{
messageColor = 7;
}
if (referenceObject.Staff == 3)
{
messageColor = 1;
}
if (referenceObject.Staff == 4)
{
messageColor = 9;
}
if (referenceObject.Staff == 5)
{
messageColor = 10;
}
if (referenceObject.Staff == 6)
{
messageColor = 8;
}
if (!input.StartsWith("@") || !ChatCommands.HandleCommand(session_0, input))
{
actorByReferenceId.Chat(input, messageColor, referenceObject.Staff == 1);
}
//1 white, 2 gold, 6 pink, 7 red, 8 blue, 9 orange, 10 green
/*
*
* White = Normal
* Gold = RetroMods
* Green = Designer
* Blue = Translators
* Pink = VIP
* Red = Admin
* Orange = XAT Staff
*
*/
}
}
}
}
}
private static void smethod_12(Session session_0, ClientMessage clientMessage_0)
{
uint actionId = clientMessage_0.ReadUnsignedInteger();
uint actorId = clientMessage_0.ReadUnsignedInteger();
SpaceInstance instanceBySpaceId = SpaceManager.GetInstanceBySpaceId(session_0.CurrentSpaceId);
if (instanceBySpaceId == null)
{
return;
}
SpaceActor actorByReferenceId = instanceBySpaceId.GetActorByReferenceId(session_0.CharacterId, SpaceActorType.UserCharacter);
SpaceActor actor = instanceBySpaceId.GetActor(actorId);
if ((actor == null) || (actorByReferenceId == null))
{
return;
}
CharacterInfo referenceObject = (CharacterInfo)actorByReferenceId.ReferenceObject;
CharacterInfo info2 = (CharacterInfo)actor.ReferenceObject;
if (actorByReferenceId.IsLocked || actor.IsLocked)
{
return;
}
actorByReferenceId.StopMoving();
actor.StopMoving();
if (SessionManager.GetSessionByCharacterId(actor.ReferenceId) == null)
{
return;
}
using (SqlDatabaseClient client = SqlDatabaseManager.GetClient())
{
switch (actionId)
{
case 1:
referenceObject.UpdateKisses(client, false);
info2.UpdateKisses(client, true);
actor.Lock(3, false, false);
actorByReferenceId.Lock(3, false, false);
goto Label_0165;
case 2:
referenceObject.UpdateCocktails(client, false);
info2.UpdateCocktails(client, true);
actor.Lock(9, false, false);
actorByReferenceId.Lock(9, false, false);
goto Label_0165;
case 3:
referenceObject.UpdateRoses(client, false);
info2.UpdateRoses(client, true);
actor.Lock(4, false, false);
actorByReferenceId.Lock(4, false, false);
goto Label_0165;
}
referenceObject.UpdateKisses(client, false);
info2.UpdateKisses(client, true);
actor.Lock(3, false, false);
actorByReferenceId.Lock(3, false, false);
}
Label_0165:
instanceBySpaceId.BroadcastMessage(SpaceUpdateUserStatistics.Compose(actorByReferenceId, actionId), 0, false);
instanceBySpaceId.BroadcastMessage(SpaceUpdateUserStatistics.Compose(actor, actionId), 0, false);
instanceBySpaceId.BroadcastMessage(SpaceUserAcceptInteract.Compose(actor, actorByReferenceId, actionId), 0, false);
}
internal static void HandleMessage(ClientObject client, ClientMessage message)
{
//Prevent plugins from dodging SPLIT_MESSAGE. If they are modified, every split message will be broken.
if (message.type != ClientMessageType.SPLIT_MESSAGE)
{
DMPPluginHandler.FireOnMessageReceived(client, message);
if (message.handled)
{
//a plugin has handled this message and requested suppression of the default DMP behavior
return;
}
}
//Clients can only send HEARTBEATS, HANDSHAKE_REQUEST or CONNECTION_END's until they are authenticated.
if (!client.authenticated && !(message.type == ClientMessageType.HEARTBEAT || message.type == ClientMessageType.HANDSHAKE_RESPONSE || message.type == ClientMessageType.CONNECTION_END))
{
Messages.ConnectionEnd.SendConnectionEnd(client, "You must authenticate before attempting to send a " + message.type.ToString() + " message");
return;
}
#if !DEBUG
try
{
#endif
switch (message.type)
{
case ClientMessageType.HEARTBEAT:
//Don't do anything for heartbeats, they just keep the connection alive
break;
case ClientMessageType.HANDSHAKE_RESPONSE:
Messages.Handshake.HandleHandshakeResponse(client, message.data);
break;
case ClientMessageType.CHAT_MESSAGE:
Messages.Chat.HandleChatMessage(client, message.data);
break;
case ClientMessageType.PLAYER_STATUS:
Messages.PlayerStatus.HandlePlayerStatus(client, message.data);
break;
case ClientMessageType.PLAYER_COLOR:
Messages.PlayerColor.HandlePlayerColor(client, message.data);
break;
case ClientMessageType.GROUP:
Messages.GroupMessage.HandleMessage(client, message.data);
break;
case ClientMessageType.SCENARIO_DATA:
Messages.ScenarioData.HandleScenarioModuleData(client, message.data);
break;
case ClientMessageType.SYNC_TIME_REQUEST:
Messages.SyncTimeRequest.HandleSyncTimeRequest(client, message.data);
break;
case ClientMessageType.KERBALS_REQUEST:
Messages.KerbalsRequest.HandleKerbalsRequest(client);
break;
case ClientMessageType.KERBAL_PROTO:
Messages.KerbalProto.HandleKerbalProto(client, message.data);
break;
case ClientMessageType.VESSELS_REQUEST:
Messages.VesselRequest.HandleVesselsRequest(client, message.data);
break;
case ClientMessageType.VESSEL_PROTO:
Messages.VesselProto.HandleVesselProto(client, message.data);
break;
case ClientMessageType.VESSEL_UPDATE:
Messages.VesselUpdate.HandleVesselUpdate(client, message.data);
break;
case ClientMessageType.VESSEL_REMOVE:
Messages.VesselRemove.HandleVesselRemoval(client, message.data);
break;
case ClientMessageType.PERMISSION:
Messages.PermissionMessage.HandleMessage(client, message.data);
break;
case ClientMessageType.CRAFT_LIBRARY:
Messages.CraftLibrary.HandleCraftLibrary(client, message.data);
break;
case ClientMessageType.SCREENSHOT_LIBRARY:
Messages.ScreenshotLibrary.HandleScreenshotLibrary(client, message.data);
break;
case ClientMessageType.FLAG_SYNC:
Messages.FlagSync.HandleFlagSync(client, message.data);
break;
case ClientMessageType.PING_REQUEST:
Messages.PingRequest.HandlePingRequest(client, message.data);
break;
case ClientMessageType.MOTD_REQUEST:
Messages.MotdRequest.HandleMotdRequest(client);
break;
case ClientMessageType.WARP_CONTROL:
Messages.WarpControl.HandleWarpControl(client, message.data);
break;
case ClientMessageType.LOCK_SYSTEM:
Messages.LockSystem.HandleLockSystemMessage(client, message.data);
break;
case ClientMessageType.MOD_DATA:
Messages.ModData.HandleModDataMessage(client, message.data);
break;
case ClientMessageType.KERBAL_REMOVE:
Messages.VesselRemove.HandleKerbalRemoval(client, message.data);
break;
case ClientMessageType.SPLIT_MESSAGE:
Messages.SplitMessage.HandleSplitMessage(client, message.data);
break;
case ClientMessageType.CONNECTION_END:
Messages.ConnectionEnd.HandleConnectionEnd(client, message.data);
break;
case ClientMessageType.MODPACK_DATA:
Messages.Modpack.HandleModpackMessage(client, message.data);
break;
default:
DarkLog.Debug("Unhandled message type " + message.type);
Messages.ConnectionEnd.SendConnectionEnd(client, "Unhandled message type " + message.type);
#if DEBUG
throw new NotImplementedException("Message type not implemented");
#else
break;
#endif
}
#if !DEBUG
}
catch (Exception e)
{
DarkLog.Debug("Error handling " + message.type + " from " + client.playerName + ", exception: " + e);
Messages.ConnectionEnd.SendConnectionEnd(client, "Server failed to process " + message.type + " message");
}
#endif
}
public override void Handle(GameClient session, ClientMessage message)
{
this.Username = message.PopFixedString();
base.Handle(session, message);
}
public static void Handle(ClientMessage message, Session session)
{
session.Network.EnqueueSend(new GameEventHouseStatus(session));
}
public void DumpMessage()
{
Assert.Throws <ArgumentNullException>(() => _ = ((ClientMessage)null).Dump());
// exception
var m = new ClientMessage(new Frame(new byte[64]));
m.MessageType = 0;
var s = m.Dump();
#if DEBUG
Assert.That(s.ToLf(), Is.EqualTo(@"EXCEPTION
FRAME {Frame: 70 bytes, Final (0x00002000)}".ToLf()));
#else
// works, but produces an empty string
Assert.That(s.ToLf(), Is.EqualTo(""));
#endif
// message
m = new ClientMessage(new Frame(new byte[64]));
m.Append(new Frame(new byte[64]));
m.Append(new Frame(new byte[64]));
m.MessageType = MapAddEntryListenerCodec.RequestMessageType;
m.Flags |= ClientMessageFlags.Unfragmented;
m.PartitionId = 55;
m.OperationName = "operation";
s = m.Dump();
#if DEBUG
Assert.That(s.ToLf(), Is.EqualTo(@"REQUEST [0]
TYPE 0x11900 operation
PARTID 55
FRAME {Frame: 70 bytes, Unfragmented (0x0000C000)}
FRAME {Frame: 70 bytes, Default (0x00000000)}
FRAME {Frame: 70 bytes, Final (0x00002000)}".ToLf()));
#else
// works, but produces an empty string
Assert.That(s.ToLf(), Is.EqualTo(""));
#endif
m = new ClientMessage(new Frame(new byte[64]));
m.Append(new Frame(new byte[64]));
m.Append(new Frame(new byte[64]));
m.MessageType = MapAddEntryListenerCodec.ResponseMessageType;
m.Flags |= ClientMessageFlags.Unfragmented;
s = m.Dump();
#if DEBUG
Assert.That(s.ToLf(), Is.EqualTo(@"RESPONSE [0]
TYPE 0x11901 MapAddEntryListener.Response
FRAME {Frame: 70 bytes, Unfragmented (0x0000C000)}
FRAME {Frame: 70 bytes, Default (0x00000000)}
FRAME {Frame: 70 bytes, Final (0x00002000)}".ToLf()));
#else
// works, but produces an empty string
Assert.That(s.ToLf(), Is.EqualTo(""));
#endif
// event
m = new ClientMessage(new Frame(new byte[64]));
m.MessageType = 0x011902; // MapAddEntryListenerCodec.EventEntryMessageType;
m.Flags |= ClientMessageFlags.Event;
s = m.Dump();
#if DEBUG
Assert.That(s.ToLf(), Is.EqualTo(@"EVENT [0]
TYPE 0x11902 MapAddEntryListener.Entry
FRAME {Frame: 70 bytes, Final, Event (0x00002200)}".ToLf()));
#else
// works, but produces an empty string
Assert.That(s.ToLf(), Is.EqualTo(""));
#endif
}
public override void Handle(GameClient session, ClientMessage message)
{
base.Handle(session, message);
}
public void parse(GameClient Session, ClientMessage Event)
{
}
protected override bool ReadUnsubscribeResponse(ClientMessage unsubscribeResponseMessage, SubscriptionState <CollectionItemEventHandlers <T> > state) => ListRemoveListenerCodec.DecodeResponse(unsubscribeResponseMessage).Response;
public void QueueWrite(ClientMessage message)
{
queue.Enqueue(message);
reset.Set();
}
public void ParsePacket(ref byte[] bytes)
{
if (bytes[0] == 64)
{
int i = 0;
while (i < bytes.Length)
{
try
{
int num = Base64Encoding.DecodeInt32(new byte[]
{
bytes[i++],
bytes[i++],
bytes[i++]
});
uint uint_ = Base64Encoding.DecodeUInt32(new byte[]
{
bytes[i++],
bytes[i++]
});
byte[] array = new byte[num - 2];
for (int j = 0; j < array.Length; j++)
{
array[j] = bytes[i++];
}
if (this.ClientMessageHandler == null)
{
this.CreateClientMessageHandler();
}
ClientMessage @class = new ClientMessage(uint_, array);
if (@class != null)
{
try
{
if (int.Parse(HabboIM.GetConfig().data["debug"]) == 1)
{
Logging.WriteLine(string.Concat(new object[]
{
"[",
this.ID,
"] --> [",
@class.Id,
"] ",
@class.Header,
@class.GetBody()
}));
}
}
catch
{
}
Interface @interface;
if (HabboIM.GetPacketManager().Handle(@class.Id, out @interface))
{
try
{
@interface.Handle(this, @class);
}
catch (Exception ex)
{
Logging.LogException("Error: " + ex.ToString());
this.method_12();
}
}
}
}
catch (Exception ex)
{
if (ex.GetType() == typeof(IndexOutOfRangeException))
{
return;
}
Logging.LogException("Error: " + ex.ToString());
this.method_12();
}
}
}
else
{
if (true)
{
this.Connection.SendMessage(CrossdomainPolicy.GetXmlPolicy());
this.Message1_0.SendData(HabboIM.GetDefaultEncoding().GetBytes(CrossdomainPolicy.GetXmlPolicy()));
this.Connection.Close();
}
}
}
public void parse(GameClient Session, ClientMessage Event)
{
Room room = PhoenixEnvironment.GetGame().GetRoomManager().GetRoom(Session.GetHabbo().CurrentRoomId);
if (room != null && Session != null)
{
if (Session.GetHabbo().Muted)
{
Session.SendNotif(TextManager.GetText("error_muted"));
}
else
{
if (Session.GetHabbo().HasRole("ignore_roommute") || !room.RoomMuted)
{
string str = PhoenixEnvironment.FilterInjectionChars(Event.PopFixedString());
string name = str.Split(new char[]
{
' '
})[0];
string s = str.Substring(name.Length + 1);
s = ChatCommandHandler.ApplyWordFilter(s);
RoomUser roomUserByHabbo = room.GetRoomUserByHabbo(Session.GetHabbo().Id);
RoomUser user2 = room.GetRoomUserByHabbo(name);
if (Session.GetHabbo().MaxFloodTime() > 0)
{
TimeSpan timeSpan = DateTime.Now - Session.GetHabbo().FloodTime;
if (timeSpan.Seconds > 4)
{
Session.GetHabbo().FloodCount = 0;
}
if (timeSpan.Seconds < 4 && Session.GetHabbo().FloodCount > 5 && !roomUserByHabbo.IsBot)
{
ServerMessage Message = new ServerMessage(27);
Message.AppendInt32(Session.GetHabbo().MaxFloodTime());
Session.SendMessage(Message);
Session.GetHabbo().Muted = true;
Session.GetHabbo().MuteLength = Session.GetHabbo().MaxFloodTime();
return;
}
Session.GetHabbo().FloodTime = DateTime.Now;
Session.GetHabbo().FloodCount++;
}
ServerMessage Message2 = new ServerMessage(25);
Message2.AppendInt32(roomUserByHabbo.VirtualId);
Message2.AppendStringWithBreak(s);
Message2.AppendBoolean(false);
if (roomUserByHabbo != null && !roomUserByHabbo.IsBot)
{
roomUserByHabbo.GetClient().SendMessage(Message2);
}
roomUserByHabbo.Unidle();
if (user2 != null && !user2.IsBot && (user2.GetClient().GetHabbo().MutedUsers.Count <= 0 || !user2.GetClient().GetHabbo().MutedUsers.Contains(Session.GetHabbo().Id)))
{
user2.GetClient().SendMessage(Message2);
if (GlobalClass.RecordChatlogs && !Session.GetHabbo().isAaron)
{
using (DatabaseClient client = PhoenixEnvironment.GetDatabase().GetClient())
{
client.AddParamWithValue("message", "<Whisper to " + user2.GetClient().GetHabbo().Username + ">: " + s);
client.ExecuteQuery(string.Concat(new object[]
{
"INSERT INTO chatlogs (user_id,room_id,hour,minute,timestamp,message,user_name,full_date) VALUES ('",
Session.GetHabbo().Id,
"','",
room.RoomId,
"','",
DateTime.Now.Hour,
"','",
DateTime.Now.Minute,
"',UNIX_TIMESTAMP(),@message,'",
Session.GetHabbo().Username,
"','",
DateTime.Now.ToLongDateString(),
"')"
}));
}
}
}
}
}
}
}
public void Handle(GameClient session, ClientMessage message)
{
int searchType = int.Parse(message.PopFixedString());
session.SendMessage(Skylight.GetGame().GetNavigatorManager().GetEvents(searchType));
}
public static void Encode(Guid uuid, ClientMessage clientMessage)
{
var bytes = uuid.ToByteArray();
clientMessage.Set(bytes);
}
public void Handle(GameClient session, ClientMessage message)
{
int request = message.PopWiredInt32();
DataTable friendStream = null;
using (DatabaseClient dbClient = Skylight.GetDatabaseManager().GetClient())
{
friendStream = dbClient.ReadDataTable("SELECT * FROM user_friend_stream ORDER BY timestamp DESC LIMIT 15"); //check if the user is my friend xo xo
}
ServerMessage message_ = BasicUtilies.GetRevisionServerMessage(Revision.RELEASE63_35255_34886_201108111108);
message_.Init(r63aOutgoing.FriendStream);
message_.AppendInt32(friendStream.Rows.Count); //count
foreach (DataRow dataRow in friendStream.Rows)
{
int type = (int)dataRow["type"];
uint userId = (uint)dataRow["user_id"];
string[] extraData = ((string)dataRow["extra_data"]).Split((char)9);
message_.AppendInt32((int)dataRow["id"]);
message_.AppendInt32(type);
message_.AppendString(userId.ToString());
if (type != 2) //0 = friend made, 1 = room liked, 3 = motto changed, 4 = room decorated
{
string username = "******";
string gender = "m";
string look = "";
GameClient target = Skylight.GetGame().GetGameClientManager().GetGameClientById(userId);
if (target != null)
{
username = target.GetHabbo().Username;
gender = target.GetHabbo().Gender;
look = target.GetHabbo().Look;
}
else
{
DataRow userData = null;
using (DatabaseClient dbClient = Skylight.GetDatabaseManager().GetClient())
{
dbClient.AddParamWithValue("userId", userId);
userData = dbClient.ReadDataRow("SELECT username, gender, look FROM users WHERE id = @userId LIMIT 1");
}
if (userData != null)
{
username = (string)userData["username"];
gender = (string)userData["gender"];
look = (string)userData["look"];
}
}
message_.AppendString(username); //user name
message_.AppendString(gender.ToLower()); //gender
message_.AppendString("http://localhost:7977/habbo-imaging/head.gif?figure=" + look); //user head
}
else //2 = achievement earned
{
message_.AppendString(Skylight.GetGame().GetGameClientManager().GetUsernameByID(userId)); //user name
message_.AppendString(""); //gender
message_.AppendString("http://25.76.128.47/habway/c_images/album1584/" + extraData[0] + ".gif"); //image
}
message_.AppendInt32((int)Math.Ceiling((TimeUtilies.GetUnixTimestamp() - (double)dataRow["timestamp"]) / 60.0)); //time as minutes
if (type != 0) //1 = room liked, 2 = achievement earned, 3 = motto changed, 4 = room decorated
{
if (type == 4)
{
message_.AppendInt32(2); //link action
}
else
{
message_.AppendInt32(1 + type); //link action
}
}
else //0 = friend made
{
if (session.GetHabbo().GetMessenger().IsFriendWith(uint.Parse(extraData[0])))
{
message_.AppendInt32(1); //link action
}
else
{
message_.AppendInt32(5); //link action
}
}
message_.AppendInt32(0); //likes
message_.AppendBoolean(false); //can like?
if (type == 0) //friend made
{
message_.AppendString(extraData[0]); //friend id
message_.AppendString(Skylight.GetGame().GetGameClientManager().GetUsernameByID(uint.Parse(extraData[0]))); //friend name
}
else if (type == 1) //room liked
{
RoomData roomData = Skylight.GetGame().GetRoomManager().TryGetRoomData(uint.Parse(extraData[0]));
if (roomData != null)
{
message_.AppendString(roomData.ID.ToString()); //room id
message_.AppendString(roomData.Name); //room name
}
else
{
message_.AppendString(extraData[0]); //room id
message_.AppendString("Room not found"); //room name
}
}
else if (type == 2) //achievement earned
{
message_.AppendString(extraData[0]); //badge code
}
else if (type == 3) //motto changed
{
message_.AppendString(extraData[0]); //new motto
}
else if (type == 4) //room decorated
{
RoomData roomData = Skylight.GetGame().GetRoomManager().TryGetRoomData(uint.Parse(extraData[0]));
if (roomData != null)
{
message_.AppendString(roomData.ID.ToString()); //room id
message_.AppendString(roomData.Name); //room name
}
else
{
message_.AppendString(extraData[0]); //room id
message_.AppendString("Room not found"); //room name
}
}
}
session.SendMessage(message_);
}
public void Handle(GameClient Session, ClientMessage Event)
{
Room @class = HabboIM.GetGame().GetRoomManager().GetRoom(Session.GetHabbo().CurrentRoomId);
if (@class != null && [email protected] && (@class.AllowPet || @class.CheckRights(Session, true)))
{
uint uint_ = Event.PopWiredUInt();
RoomUser class2 = @class.method_48(uint_);
if (class2 != null && class2.PetData != null && class2.PetData.OwnerId == Session.GetHabbo().Id)
{
using (DatabaseClient class3 = HabboIM.GetDatabase().GetClient())
{
if (class2.PetData.DBState == DatabaseUpdateState.NeedsInsert)
{
class3.AddParamWithValue("petname" + class2.PetData.PetId, class2.PetData.Name);
class3.AddParamWithValue("petcolor" + class2.PetData.PetId, class2.PetData.Color);
class3.AddParamWithValue("petrace" + class2.PetData.PetId, class2.PetData.Race);
class3.ExecuteQuery(string.Concat(new object[]
{
"INSERT INTO `user_pets` VALUES ('",
class2.PetData.PetId,
"', '",
class2.PetData.OwnerId,
"', '0', @petname",
class2.PetData.PetId,
", @petrace",
class2.PetData.PetId,
", @petcolor",
class2.PetData.PetId,
", '",
class2.PetData.Type,
"', '",
class2.PetData.Expirience,
"', '",
class2.PetData.Energy,
"', '",
class2.PetData.Nutrition,
"', '",
class2.PetData.Respect,
"', '",
class2.PetData.CreationStamp,
"', '",
class2.PetData.X,
"', '",
class2.PetData.Y,
"', '",
class2.PetData.Z,
"');"
}));
}
else
{
class3.ExecuteQuery(string.Concat(new object[]
{
"UPDATE user_pets SET room_id = '0', expirience = '",
class2.PetData.Expirience,
"', energy = '",
class2.PetData.Energy,
"', nutrition = '",
class2.PetData.Nutrition,
"', respect = '",
class2.PetData.Respect,
"' WHERE Id = '",
class2.PetData.PetId,
"' LIMIT 1; "
}));
}
class2.PetData.DBState = DatabaseUpdateState.Updated;
}
Session.GetHabbo().GetInventoryComponent().AddPet(class2.PetData);
@class.method_6(class2.VirtualId, false);
class2.RoomId = 0u;
}
}
}
protected override ValueTask CodecHandleEventAsync(ClientMessage eventMessage, Func <IData, Guid, int, ValueTask> f, ILoggerFactory loggerFactory)
=> ListAddListenerCodec.HandleEventAsync(
eventMessage,
(itemData, memberId, eventTypeData) => f(itemData, memberId, eventTypeData),
loggerFactory);
public void Handle(ClientMessage.TransactionStart message)
{
if (!_explicitTransactionsSupported)
{
var reply = new ClientMessage.TransactionStartCompleted(
message.CorrelationId,
private static void CharacterCreateEx(ClientMessage message, Session session)
{
var characterCreateInfo = new CharacterCreateInfo();
characterCreateInfo.Unpack(message.Payload);
// TODO: Check for Banned Name Here
//DatabaseManager.Shard.IsCharacterNameBanned(characterCreateInfo.Name, isBanned =>
//{
// if (!isBanned)
// {
// SendCharacterCreateResponse(session, CharacterGenerationVerificationResponse.NameBanned);
// return;
// }
//});
// Disable OlthoiPlay characters for now. They're not implemented yet.
// FIXME: Restore OlthoiPlay characters when properly handled.
if (characterCreateInfo.Heritage == (int)HeritageGroup.Olthoi || characterCreateInfo.Heritage == (int)HeritageGroup.OlthoiAcid)
{
SendCharacterCreateResponse(session, CharacterGenerationVerificationResponse.Pending);
return;
}
Weenie weenie;
if (ConfigManager.Config.Server.Accounts.OverrideCharacterPermissions)
{
if (session.AccessLevel >= AccessLevel.Developer && session.AccessLevel <= AccessLevel.Admin)
{
weenie = DatabaseManager.World.GetCachedWeenie("admin");
}
else if (session.AccessLevel >= AccessLevel.Sentinel && session.AccessLevel <= AccessLevel.Envoy)
{
weenie = DatabaseManager.World.GetCachedWeenie("sentinel");
}
else
{
weenie = DatabaseManager.World.GetCachedWeenie("human");
}
if (characterCreateInfo.Heritage == (int)HeritageGroup.Olthoi && weenie.Type == (int)WeenieType.Admin)
{
weenie = DatabaseManager.World.GetCachedWeenie("olthoiadmin");
}
if (characterCreateInfo.Heritage == (int)HeritageGroup.OlthoiAcid && weenie.Type == (int)WeenieType.Admin)
{
weenie = DatabaseManager.World.GetCachedWeenie("olthoiacidadmin");
}
}
else
{
weenie = DatabaseManager.World.GetCachedWeenie("human");
}
if (characterCreateInfo.Heritage == (int)HeritageGroup.Olthoi && weenie.Type == (int)WeenieType.Creature)
{
weenie = DatabaseManager.World.GetCachedWeenie("olthoiplayer");
}
if (characterCreateInfo.Heritage == (int)HeritageGroup.OlthoiAcid && weenie.Type == (int)WeenieType.Creature)
{
weenie = DatabaseManager.World.GetCachedWeenie("olthoiacidplayer");
}
if (characterCreateInfo.IsSentinel && session.AccessLevel >= AccessLevel.Sentinel)
{
weenie = DatabaseManager.World.GetCachedWeenie("sentinel");
}
if (characterCreateInfo.IsAdmin && session.AccessLevel >= AccessLevel.Developer)
{
weenie = DatabaseManager.World.GetCachedWeenie("admin");
}
if (weenie == null)
{
weenie = DatabaseManager.World.GetCachedWeenie("human"); // Default catch-all
}
if (weenie == null) // If it is STILL null after the above catchall, the database is missing critical data and cannot continue with character creation.
{
SendCharacterCreateResponse(session, CharacterGenerationVerificationResponse.DatabaseDown);
log.Error("Database does not contain the weenie for human (1). Characters cannot be created until the missing weenie is restored.");
return;
}
// Removes the generic knife and buckler, hidden Javelin, 30 stack of arrows, and 5 stack of coins that are given to all characters
// Starter Gear from the JSON file are added to the character later in the CharacterCreateEx() process
weenie.WeeniePropertiesCreateList.Clear();
var guid = GuidManager.NewPlayerGuid();
var weenieType = (WeenieType)weenie.Type;
// If Database didn't have Sentinel/Admin weenies, alter the weenietype coming in.
if (ConfigManager.Config.Server.Accounts.OverrideCharacterPermissions)
{
if (session.AccessLevel >= AccessLevel.Developer && session.AccessLevel <= AccessLevel.Admin && weenieType != WeenieType.Admin)
{
weenieType = WeenieType.Admin;
}
else if (session.AccessLevel >= AccessLevel.Sentinel && session.AccessLevel <= AccessLevel.Envoy && weenieType != WeenieType.Sentinel)
{
weenieType = WeenieType.Sentinel;
}
}
var result = PlayerFactory.Create(characterCreateInfo, weenie, guid, session.AccountId, weenieType, out var player);
if (result != PlayerFactory.CreateResult.Success || player == null)
{
SendCharacterCreateResponse(session, CharacterGenerationVerificationResponse.Corrupt);
return;
}
DatabaseManager.Shard.IsCharacterNameAvailable(characterCreateInfo.Name, isAvailable =>
{
if (!isAvailable)
{
SendCharacterCreateResponse(session, CharacterGenerationVerificationResponse.NameInUse);
return;
}
var possessions = player.GetAllPossessions();
var possessedBiotas = new Collection <(Biota biota, ReaderWriterLockSlim rwLock)>();
foreach (var possession in possessions)
{
possessedBiotas.Add((possession.Biota, possession.BiotaDatabaseLock));
}
// Token: 0x060025FC RID: 9724 RVA: 0x000BB5C8 File Offset: 0x000B99C8
private void OnEcho_Done(Hub hub, ClientMessage originalMessage, ResultMessage result)
{
this.typedEchoResult = "TypedDemoHub.Echo(string message) invoked!";
}
