private static bool HandleExchangeRedemption(Session Session, Item Item, RoomInstance Instance, ItemEventType Event, int RequestData, uint Opcode)
{
switch (Event)
{
case ItemEventType.Interact:
int ItemValue = 0;
int.TryParse(Item.Flags, out ItemValue);
using (SqlDatabaseClient MySqlClient = SqlDatabaseManager.GetClient())
{
if (ItemValue != 0)
{
Session.CharacterInfo.UpdateCreditsBalance(MySqlClient, ItemValue);
Session.SendData(CreditsBalanceComposer.Compose(Session.CharacterInfo.CreditsBalance));
}
Item.RemovePermanently(MySqlClient);
}
Instance.TakeItem(Item.Id);
Instance.RegenerateRelativeHeightmap();
break;
}
return true;
}
public static bool FinishSendHome(Session Session, System.Timers.Timer Timer)
{
Timer.Dispose();
Timer.Stop();
Session.CharacterInfo.UpdateSentHome(0);
return true;
}
private static void BanUser(Session Session, ClientMessage Message)
{
if (!Session.HasRight("moderation_tool"))
{
return;
}
uint UserId = Message.PopWiredUInt32();
string MessageText = Message.PopString();
double Length = (Message.PopWiredInt32() * 3600);
Session TargetSession = SessionManager.GetSessionByCharacterId(UserId);
if (TargetSession == null || TargetSession.HasRight("moderation_tool"))
{
Session.SendData(NotificationMessageComposer.Compose("This user is not online or you do not have permission to ban them.\nPlease use housekeeping to ban users that are offline."));
return;
}
SessionManager.StopSession(TargetSession.Id);
using (SqlDatabaseClient MySqlClient = SqlDatabaseManager.GetClient())
{
ModerationBanManager.BanUser(MySqlClient, UserId, MessageText, Session.CharacterId, Length);
ModerationLogs.LogModerationAction(MySqlClient, Session, "Banned user",
"User '" + TargetSession.CharacterInfo.Username + "' (ID " + TargetSession.CharacterId + ") for " +
Length + " hours: '" + MessageText + "'");
}
}
private static void ApplyEffect(Session Session, ClientMessage Message)
{
int EffectSpriteId = Message.PopWiredInt32();
if (EffectSpriteId < 0)
{
EffectSpriteId = 0;
}
RoomInstance Instance = RoomManager.GetInstanceByRoomId(Session.CurrentRoomId);
if (Instance == null)
{
return;
}
RoomActor Actor = Instance.GetActorByReferenceId(Session.CharacterId);
if (Actor == null || (EffectSpriteId != 0 && !Session.AvatarEffectCache.HasEffect(EffectSpriteId, true)))
{
return;
}
Actor.ApplyEffect(EffectSpriteId);
Session.CurrentEffect = EffectSpriteId;
}
private static void SubmitAnswer(Session Session, ClientMessage Message)
{
RoomInstance Instance = RoomManager.GetInstanceByRoomId(Session.CurrentRoomId);
if (Instance == null)
{
return;
}
RoomActor Actor = Instance.GetActorByReferenceId(Session.CharacterId);
if (Actor == null)
{
return;
}
int AnswerId = Message.PopWiredInt32();
lock (mInfobusQuestions)
{
if (mInfobusQuestions.ContainsKey(Instance.RoomId))
{
mInfobusQuestions[Instance.RoomId].SubmitAnswer(Actor.Id, AnswerId);
}
}
}
private static bool HandleSwitch(Session Session, Item Item, RoomInstance Instance, ItemEventType Event, int RequestData, uint Opcode)
{
if (Event != ItemEventType.Interact)
{
return true;
}
RoomActor actor = Instance.GetActor(Session.CharacterId);
if (actor == null)
{
return true;
}
foreach (Item item in Instance.GetFloorItems())
{
if (item.Definition.Behavior != ItemBehavior.WiredTrigger || WiredTypesUtil.TriggerFromInt(item.Definition.BehaviorData) != WiredTriggerTypes.state_changed)
{
continue;
}
String[] Selected = item.WiredData.Data1.Split('|');
if (Selected.Contains(Item.Id.ToString()))
{
Instance.WiredManager.ExecuteActions(item, actor);
}
}
return true;
}
public static ServerMessage Compose(Session Session, ReadOnlyCollection<Achievement> Achievements)
{
ServerMessage Message = new ServerMessage(OpcodesOut.ACHIEVEMENTS_LIST);
Message.AppendInt32(Achievements.Count);
foreach (Achievement Achievement in Achievements)
{
UserAchievement UserData = Session.AchievementCache.GetAchievementData(Achievement.GroupName);
int TargetLevel = (UserData != null ? UserData.Level + 1 : 1);
int TotalLevels = Achievement.Levels.Count;
if (TargetLevel > TotalLevels)
{
TargetLevel = TotalLevels;
}
AchievementLevel TargetLevelData = Achievement.Levels[TargetLevel];
Message.AppendUInt32(Achievement.Id); // Unknown (ID?)
Message.AppendInt32(TargetLevel); // Target level
Message.AppendStringWithBreak(Achievement.GroupName + TargetLevel); // Target name/desc/badge
Message.AppendInt32(TargetLevelData.Requirement); // Progress req/target
Message.AppendInt32(TargetLevelData.PixelReward); // Pixel reward
Message.AppendInt32(TargetLevelData.PointsReward); // Unknown(??)
Message.AppendInt32(UserData != null ? UserData.Progress : 0); // Current progress
Message.AppendBoolean(UserData != null ? (UserData.Level >= TotalLevels) : false); // Set 100% completed(??)
Message.AppendStringWithBreak(Achievement.Category); // Category
Message.AppendInt32(TotalLevels); // Total amount of levels
}
return Message;
}
public static ServerMessage Compose(Session Session, Dictionary<int, CatalogPage> Pages)
{
ServerMessage Message = new ServerMessage(OpcodesOut.CATALOG_INDEX);
SerializePage(Message, Pages[-1], CalcTreeSize(Session, Pages, -1));
foreach (CatalogPage Page in Pages.Values)
{
if (Page.ParentId != -1 || (Page.RequiredRight.Length > 0 && !Session.HasRight(Page.RequiredRight)))
{
continue;
}
SerializePage(Message, Page, CalcTreeSize(Session, Pages, Page.Id));
foreach (CatalogPage ChildPage in Pages.Values)
{
if (ChildPage.ParentId != Page.Id || (ChildPage.RequiredRight.Length > 0 && !Session.HasRight(ChildPage.RequiredRight)))
{
continue;
}
SerializePage(Message, ChildPage, 0);
}
}
return Message;
}
private static void DeleteSticky(Session Session, ClientMessage Message)
{
RoomInstance Instance = RoomManager.GetInstanceByRoomId(Session.CurrentRoomId);
if (Instance == null || !Instance.CheckUserRights(Session, true))
{
return;
}
Item Item = Instance.GetItem(Message.PopWiredUInt32());
if (Item == null || Item.Definition.Behavior != ItemBehavior.StickyNote)
{
return;
}
if (Instance.TakeItem(Item.Id))
{
Instance.RegenerateRelativeHeightmap();
using (SqlDatabaseClient MySqlClient = SqlDatabaseManager.GetClient())
{
Item.RemovePermanently(MySqlClient);
}
}
}
private static void AlertRoom(Session Session, ClientMessage Message)
{
if (!Session.HasRight("moderation_tool"))
{
return;
}
RoomInstance Instance = RoomManager.GetInstanceByRoomId(Session.CurrentRoomId);
if (Instance == null)
{
Session.SendData(NotificationMessageComposer.Compose("Could not send room alert."));
return;
}
int Unknown1 = Message.PopWiredInt32();
int AlertMode = Message.PopWiredInt32();
string AlertMessage = Message.PopString();
bool IsCaution = AlertMode != 3;
Instance.SendModerationAlert(AlertMessage, IsCaution);
using (SqlDatabaseClient MySqlClient = SqlDatabaseManager.GetClient())
{
ModerationLogs.LogModerationAction(MySqlClient, Session, "Sent room " + (IsCaution ? "caution" : "message"),
"Room " + Instance.Info.Name + " (ID " + Instance.RoomId + "): '" + AlertMessage + "'");
}
}
public static void HandleData(Session Session, ClientMessage Message)
{
if (Session == null || Session.Stopped || Message == null)
{
return;
}
if (!mCallbacks.ContainsKey(Message.Id))
{
string text = System.IO.File.ReadAllText(Environment.CurrentDirectory + "\\packet-log.txt");
Output.WriteLine("Unhandled packet: " + Message.Id + " (" + Constants.DefaultEncoding.GetString(Base64Encoding.EncodeUint32(Message.Id, 2)) + "), no suitable handler found.", OutputLevel.Warning);
System.IO.StreamWriter file = new System.IO.StreamWriter(Environment.CurrentDirectory + "\\packet-log.txt");
file.WriteLine(text + "Unhandled packet: " + Message.Id + " (" + Constants.DefaultEncoding.GetString(Base64Encoding.EncodeUint32(Message.Id, 2)) + "), no suitable handler found.",
OutputLevel.Notification + "\n\n");
file.Close();
return;
}
if (!Session.Authenticated && !mCallbacksWithoutAuthentication.Contains(Message.Id))
{
return;
}
mCallbacks[Message.Id].Invoke(Session, Message);
}
public static bool TryRedeemVoucher(SqlDatabaseClient MySqlClient, Session Session, string Code)
{
lock (mSyncRoot)
{
VoucherValueData ValueData = GetVoucherValue(Code);
if (ValueData == null)
{
return false;
}
if (ValueData.ValueCredits > 0)
{
Session.CharacterInfo.UpdateCreditsBalance(MySqlClient, ValueData.ValueCredits);
Session.SendData(CreditsBalanceComposer.Compose(Session.CharacterInfo.CreditsBalance));
}
if (ValueData.ValuePixels > 0)
{
Session.CharacterInfo.UpdateActivityPointsBalance(MySqlClient, ValueData.ValuePixels);
Session.SendData(ActivityPointsBalanceComposer.Compose(Session.CharacterInfo.ActivityPointsBalance, ValueData.ValuePixels));
}
if (ValueData.ValueFurni.Count > 0)
{
Dictionary<int, List<uint>> NotifyItems = new Dictionary<int, List<uint>>();
foreach (uint ItemId in ValueData.ValueFurni)
{
Item Item = ItemFactory.CreateItem(MySqlClient, ItemId, Session.CharacterId, string.Empty,
string.Empty, 0, false);
if (Item != null)
{
int NotifyTabId = Item.Definition.Type == ItemType.WallItem ? 2 : 1;
Session.InventoryCache.Add(Item);
Session.NewItemsCache.MarkNewItem(MySqlClient, NotifyTabId, Item.Id);
if (!NotifyItems.ContainsKey(NotifyTabId))
{
NotifyItems.Add(NotifyTabId, new List<uint>());
}
NotifyItems[NotifyTabId].Add(Item.Id);
}
}
if (NotifyItems.Count > 0)
{
Session.SendData(InventoryRefreshComposer.Compose());
Session.SendData(InventoryNewItemsComposer.Compose(new Dictionary<int, List<uint>>(NotifyItems)));
}
}
MarkVoucherUsed(Code);
return true;
}
}
private static void OnClientDisconnectNotification(Session Session, ClientMessage Message)
{
RoomInstance Instance1 = RoomManager.GetInstanceByRoomId(Session.CurrentRoomId);
RoomActor Actor = Instance1.GetActorByReferenceId(Session.CharacterInfo.Id);
Instance1.BroadcastMessage(RoomChatComposer.Compose(Actor.Id, "-- Logging out in 10 seconds! -- [DISCONNECED]", 0, ChatType.Shout));
System.Threading.Thread.Sleep(10000);
SessionManager.StopSession(Session.Id);
}
private static void OnSessionLatencyTest(Session Session, ClientMessage Message)
{
// Sesion timer sends a number to the server and expects it right back.
// Maybe something to do with latency testing... or a keepalive?
// Seems like a waste of bandwith since we're using pinging
Session.SendData(LatencyTestResponseComposer.Compose(Message.PopWiredInt32()));
}
private static void InitCrypto(Session Session, ClientMessage Message)
{
if (Session.Authenticated)
{
return;
}
Session.SendData(SessionParamsComposer.Compose());
}
private static void SsoLogin(Session Session, ClientMessage Message)
{
if (Session.Authenticated)
{
return;
}
string Ticket = UserInputFilter.FilterString(Message.PopString());
Session.TryAuthenticate(Ticket, Session.RemoteAddress.ToString());
}
private static void OnUserAgent(Session Session, ClientMessage Message)
{
string UserAgent = Message.PopString();
if (UserAgent.Length > 2000)
{
UserAgent = UserAgent.Substring(0, 2000);
}
Session.UserAgent = UserAgent;
}
public bool CheckUserRights(Session Session, bool RequireOwnership = false)
{
bool IsOwner = (Session.HasRight("room_rights_owner") || Session.CharacterId == Info.OwnerId);
if (RequireOwnership)
{
return IsOwner;
}
return (IsOwner || Session.HasRight("room_rights") || mUsersWithRights.Contains(Session.CharacterId));
}
private static void TradeComplete(Session Session, ClientMessage Message)
{
RoomInstance Instance = RoomManager.GetInstanceByRoomId(Session.CurrentRoomId);
if (Instance == null)
{
return;
}
Trade Trade = Instance.TradeManager.GetTradeForUser(Session.CharacterId);
if (Trade == null)
{
return;
}
Session TargetSession = SessionManager.GetSessionByCharacterId(Trade.UserOne == Session.CharacterId ?
Trade.UserTwo : Trade.UserOne);
if (TargetSession == null || !Trade.AcceptTrade(Trade.UserOne == Session.CharacterId))
{
return;
}
if (Trade.TradeStage == TradeStage.Finalized)
{
Session User1 = (TargetSession.CharacterId == Trade.UserOne ? TargetSession : Session);
Session User2 = (TargetSession.CharacterId == Trade.UserTwo ? TargetSession : Session);
Trade.DeliverItems(User1, User2);
Session.SendData(TradeFinalizedComposer.Compose());
TargetSession.SendData(TradeFinalizedComposer.Compose());
Instance.TradeManager.StopTradeForUser(Session.CharacterId);
Instance.TradeManager.StopTradeForUser(TargetSession.CharacterId);
RoomActor Actor1 = Instance.GetActorByReferenceId(Session.CharacterId);
RoomActor Actor2 = Instance.GetActorByReferenceId(TargetSession.CharacterId);
if (Actor1 != null)
{
Actor1.RemoveStatus("trd");
Actor1.UpdateNeeded = true;
}
if (Actor2 != null)
{
Actor2.RemoveStatus("trd");
Actor2.UpdateNeeded = true;
}
}
}
public void CheckEffectExpiry(Session Session)
{
lock (mSyncRoot)
{
foreach (AvatarEffect Effect in mInner.Values)
{
if (Effect.HasExpired)
{
Effect.HandleExpiration(Session);
}
}
}
}
public static void InvokeItemEventHandler(Session Session, Item Item, RoomInstance Instance, ItemEventType Type, int RequestData = 0, uint Opcode = 0, bool checkrights = true)
{
if (mEventHandlers.ContainsKey(Item.Definition.Behavior))
{
foreach (ItemEventHandler EventHandler in mEventHandlers[Item.Definition.Behavior])
{
if (!EventHandler.Invoke(Session, Item, Instance, Type, RequestData, Opcode))
{
return;
}
}
}
}
public static bool ExecuteTaxi(Session Session, RoomActor Actor, uint RoomID, System.Timers.Timer Timer)
{
Timer.Dispose();
Timer.Stop();
if (Session.CharacterInfo.Dead != 1 && Session.CharacterInfo.Jailed != 1)
{
using (SqlDatabaseClient MySqlClient = SqlDatabaseManager.GetClient())
{
Session.CharacterInfo.SetHomeRoom(MySqlClient, RoomID);
RoomHandler.PrepareRoom(Session, RoomID, null, true);
}
}
return true;
}
public static ServerMessage Compose(CharacterInfo Info, Session Session)
{
ServerMessage Message = new ServerMessage(OpcodesOut.MODERATION_USER_INFO);
Message.AppendUInt32(Info.Id);
Message.AppendStringWithBreak(Info.Username);
Message.AppendInt32((int)(UnixTimestamp.GetCurrent() - Info.TimestampRegistered) / 60);
Message.AppendInt32((int)(UnixTimestamp.GetCurrent() - Info.TimestampLastOnline) / 60);
Message.AppendBoolean(Session != null);
Message.AppendInt32(Info.ModerationTickets);
Message.AppendInt32(Info.ModerationTicketsAbusive);
Message.AppendInt32(Info.ModerationCautions);
Message.AppendInt32(Info.ModerationBans);
return Message;
}
private static void ActivateEffect(Session Session, ClientMessage Message)
{
AvatarEffect Effect = Session.AvatarEffectCache.GetEffect(Message.PopWiredInt32(), false, true);
// If we do not have an effect that needs activating OR if we already have an effect
// of this sort which IS activated, stop.
if (Effect == null || Session.AvatarEffectCache.HasEffect(Effect.SpriteId, true))
{
return;
}
Effect.Activate();
Session.SendData(UserEffectActivatedComposer.Compose(Effect));
}
public static int GetWardrobeSlotAmountForSession(Session Session)
{
int WardrobeSlots = 0;
if (Session.HasRight("club_regular"))
{
WardrobeSlots += 5;
}
if (Session.HasRight("club_vip"))
{
WardrobeSlots += 5;
}
return WardrobeSlots;
}
private static void GetIgnoredUsers(Session Session, ClientMessage Message)
{
ReadOnlyCollection<uint> IgnoredUsers = Session.IgnoreCache.List;
List<string> Names = new List<string>();
foreach (uint IgnoredUser in IgnoredUsers)
{
string Name = CharacterResolverCache.GetNameFromUid(IgnoredUser);
if (Name != "Unknown User" && !Names.Contains(Name))
{
Names.Add(Name);
}
}
Session.SendData(IgnoredUserListComposer.Compose(Names));
}
private static bool HandleFixedSwitchSwitch(Session Session, Item Item, RoomInstance Instance, ItemEventType Event, int RequestData, uint Opcode)
{
switch (Event)
{
case ItemEventType.Interact:
if (!Instance.CheckUserRights(Session))
{
break;
}
List<Vector2> SwitchTiles = Instance.CalculateAffectedTiles(Item, Item.RoomPosition.GetVector2(), Item.RoomRotation);
RoomActor Actor = Instance.GetActorByReferenceId(Session.CharacterId);
foreach (uint RefId in Item.TemporaryInteractionReferenceIds.Values)
{
RoomActor InteractingActor = Instance.GetActor(RefId);
}
int CurrentState = 0;
int.TryParse(Item.Flags, out CurrentState);
if (CurrentState >= (Item.Definition.BehaviorData - 1))
{
CurrentState = 0;
Item.Flags = CurrentState.ToString();
Item.DisplayFlags = CurrentState.ToString();
}
else
{
int NewState = CurrentState + 1;
Item.Flags = NewState.ToString();
Item.DisplayFlags = NewState.ToString();
}
RoomManager.MarkWriteback(Item, true);
Item.BroadcastStateUpdate(Instance);
Instance.WiredManager.HandleToggleState(Actor, Item);
Instance.RegenerateRelativeHeightmap();
break;
}
return true;
}
private static void OnClientConfig(Session Session, ClientMessage Message)
{
int Volume = Message.PopWiredInt32();
bool Something = Message.PopWiredBoolean();
if (Volume < 0)
{
Volume = 0;
}
if (Volume > 100)
{
Volume = 100;
}
Session.CharacterInfo.ConfigVolume = Volume;
}
public static ServerMessage Compose(Session Session)
{
List<Item> Disks = Session.InventoryCache.GetSongDisks();
ServerMessage Message = new ServerMessage(OpcodesOut.JUKEBOX_DISKS);
Message.AppendInt32(Disks.Count);
foreach (Item SongDisk in Disks)
{
uint SongId = 0;
uint.TryParse(SongDisk.DisplayFlags, out SongId);
Message.AppendUInt32(SongDisk.Id);
Message.AppendUInt32(SongId);
}
return Message;
}
private static void GetMoodlightInfo(Session Session, ClientMessage Message)
{
RoomInstance Instance = RoomManager.GetInstanceByRoomId(Session.CurrentRoomId);
if (Instance == null || !Instance.CheckUserRights(Session, true))
{
return;
}
Item Item = Instance.MoodlightItem;
if (Item == null)
{
return;
}
Session.SendData(MoodlightDataComposer.Compose(MoodlightData.GenerateFromFlags(Item.Flags)));
}
