public override void OnUserChat(RoomInstance Instance, RoomActor Actor, string MessageText, bool Shout)
{
if (mSelfActor == null || Actor.Type == RoomActorType.AiBot || mServingItemId > 0 ||
(Distance.Calculate(Actor.Position.GetVector2(), mSelfActor.Position.GetVector2()) > mSelfBot.ResponseDistance))
{
return;
}
BotResponse Response = mSelfBot.GetResponseForMessage(MessageText);
if (Response != null)
{
mSelfActor.Chat(Response.GetResponse(), false);
if (Response.ResponseServeId > 0)
{
mMovingToServePos = true;
mServingItemId = Response.ResponseServeId;
mServingActorId = Actor.Id;
mActorServePos = new Vector2(mSelfActor.Position.X, mSelfActor.Position.Y);
mSelfActor.MoveTo(mSelfBot.ServePosition);
if (mNextMovementAttempt < 50)
{
mNextMovementAttempt = 50;
}
}
if (mNextSpeechAttempt < 50)
{
mNextSpeechAttempt += 10;
}
}
}
private static void IgnoreUser(Session Session, ClientMessage Message)
{
RoomInstance Instance = RoomManager.GetInstanceByRoomId(Session.CurrentRoomId);
if (Instance == null)
{
return;
}
uint UserId = CharacterResolverCache.GetUidFromName(Message.PopString());
if (UserId == 0)
{
return;
}
Session TargetSession = SessionManager.GetSessionByCharacterId(UserId);
if (TargetSession != null)
{
if (TargetSession.HasRight("cannot_ignore"))
{
Session.SendData(NotificationMessageComposer.Compose("You can not ignore this user."));
return;
}
Session.IgnoreCache.MarkUserIgnored(TargetSession.CharacterId);
Session.SendData(RoomIgnoreResultComposer.Compose(1));
}
}
public InfobusQuestion(RoomInstance Instance, string Question, List<string> Answers)
{
mInstance = Instance;
mQuestionText = Question;
mAnswers = new Dictionary<int, string>();
mResponses = new Dictionary<uint, int>();
mTimestampStarted = UnixTimestamp.GetCurrent();
mCompleted = false;
mSyncRoot = new object();
int i = 1;
foreach (string Answer in Answers)
{
mAnswers.Add(i++, Answer);
}
foreach (RoomActor Actor in Instance.Actors)
{
if (Actor.Type != RoomActorType.UserCharacter)
{
continue;
}
mResponses.Add(Actor.Id, -1);
}
mWorkerThread = new Thread(new ThreadStart(ExecuteWorkerThread));
mWorkerThread.Name = "TempInfobusWorker" + Instance.RoomId;
mWorkerThread.Priority = ThreadPriority.Lowest;
mWorkerThread.Start();
BroadcastDataToParticipants(InfobusQuestionStartComposer.Compose(mQuestionText, mAnswers));
}
public override void SetRoomInstance(RoomInstance Room, uint ActorId)
{
mCurrentInstance = Room;
mActorId = ActorId;
mPath = new List<Vector2>();
mTarget = null;
}
private static void AddToStaffPicked(Session Session, ClientMessage Message)
{
RoomInstance Instance = RoomManager.GetInstanceByRoomId(Session.CurrentRoomId);
if (Instance == null || !Session.HasRight("hotel_admin"))
{
return;
}
if (!Navigator.StaffPickedContainsRoom(Instance.RoomId))
{
Navigator.AddRoomToStaffPicked(Instance.RoomId);
Session.SendData(NotificationMessageComposer.Compose("This room has been added to the staff picked rooms successfully."));
using (SqlDatabaseClient MySqlClient = SqlDatabaseManager.GetClient())
{
Session TargetSession = SessionManager.GetSessionByCharacterId(Instance.Info.OwnerId);
if (TargetSession != null)
{
AchievementManager.ProgressUserAchievement(MySqlClient, TargetSession, "ACH_Spr", 1);
}
// todo: need a way to save achievement progress in the database so it can be applied on user login
// right now it's impossible to progress an user's achievement if they're not logged in
}
}
else
{
Navigator.RemoveRoomFromStaffPicked(Instance.RoomId);
Session.SendData(NotificationMessageComposer.Compose("This room has been removed from the staff picked rooms successfully."));
}
}
private static void ActivateGeneric(Session Session, ClientMessage Message)
{
RoomInstance Instance = RoomManager.GetInstanceByRoomId(Session.CurrentRoomId);
if (Instance == null) // warning: rights need to be checked in the event handler; we do not check here
{
return;
}
Item Item = Instance.GetItem(Message.PopWiredUInt32());
if (Item == null || Item.Definition.Behavior == ItemBehavior.StaticItem)
{
return;
}
int RequestData = Message.PopWiredInt32();
ItemEventDispatcher.InvokeItemEventHandler(Session, Item, Instance, ItemEventType.Interact, RequestData, Message.Id);
QuestManager.ProgressUserQuest(Session, QuestType.EXPLORE_FIND_ITEM, Item.DefinitionId);
if (Item.Definition.Behavior == ItemBehavior.Switchable)
{
QuestManager.ProgressUserQuest(Session, QuestType.FURNI_SWITCH);
}
}
private static void AnswerDoorbell(Session Session, ClientMessage Message)
{
RoomInstance Instance = RoomManager.GetInstanceByRoomId(Session.CurrentRoomId);
if (Instance == null || !Instance.CheckUserRights(Session))
{
return;
}
string Name = Message.PopString();
bool Accept = (Message.ReadBytes(1)[0] == 65);
Session TargetSession = SessionManager.GetSessionByCharacterId(CharacterResolverCache.GetUidFromName(Name));
if (TargetSession == null || TargetSession.AbsoluteRoomId != Instance.RoomId || TargetSession.RoomAuthed)
{
return;
}
if (Accept)
{
TargetSession.RoomAuthed = true;
TargetSession.SendData(RoomDoorbellAcceptedComposer.Compose());
return;
}
TargetSession.SendData(RoomDoorbellNoResponseComposer.Compose());
RoomManager.RemoveUserFromRoom(TargetSession, false);
}
private static bool HandleExchangeRedemption(Session Session, Item Item, RoomInstance Instance, ItemEventType Event, int RequestData)
{
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 override void OnSelfLeaveRoom(RoomInstance Instance)
{
if (mSelfActor == null)
{
return;
}
mSelfActor = null;
}
private static void SaveSticky(Session Session, ClientMessage Message)
{
RoomInstance Instance = RoomManager.GetInstanceByRoomId(Session.CurrentRoomId);
if (Instance == null)
{
return;
}
Item Item = Instance.GetItem(Message.PopWiredUInt32());
if (Item == null || Item.Definition.Behavior != ItemBehavior.StickyNote)
{
return;
}
StickieEditingRights Rights = Instance.GetStickieEditingRights(Session, Item);
if (Rights == StickieEditingRights.ReadOnly)
{
return;
}
string RawData = Message.PopString();
string[] Bits = RawData.Split(' ');
if (Bits.Length < 2)
{
return;
}
string Color = Bits[0].ToUpper().Trim();
string Text = UserInputFilter.FilterString(RawData.Substring(Color.Length + 1, RawData.Length - (Color.Length + 1))).Trim();
if (Color != "FFFF33" && Color != "FF9CFF" && Color != "9CCEFF" && Color != "9CFF9C" || Text.Length > 391)
{
return;
}
Item.Flags = RawData;
Item.DisplayFlags = Color;
if (Rights == StickieEditingRights.GuestEdit)
{
Item.Flags += "\n-----\n" + Session.CharacterInfo.Username + "\n" + DateTime.Now.ToShortDateString() + " " + DateTime.Now.ToShortTimeString();
}
Instance.RevokeTemporaryStickieRights(Item.Id);
using (SqlDatabaseClient MySqlClient = SqlDatabaseManager.GetClient())
{
Item.SynchronizeDatabase(MySqlClient, true);
}
Instance.BroadcastMessage(RoomWallItemMovedComposer.Compose(Item));
}
public static ServerMessage Compose(Item Item, RoomInstance Instance)
{
// com.sulake.habbo.communication.messages.incoming.userdefinedroomevents.WiredFurniActionEvent;
ServerMessage Message = new ServerMessage(OpcodesOut.WIRED_FURNI_ACTION);
Message.AppendInt32(0);
Message.AppendInt32(5); // Furni limit
if (Item.WiredData.Data1.Contains ("|")) {
String[] Selected = Item.WiredData.Data1.Split('|');
Message.AppendInt32(Selected.Length-1); // Selected Furni Count
foreach(String selected in Selected) {
if(selected == "") {
continue;
}
int result;
Int32.TryParse(selected, out result);
Message.AppendInt32(result);
}
} else {
Message.AppendUInt32(0);
}
Message.AppendUInt32(Item.Definition.SpriteId);
Message.AppendUInt32(Item.Id);
Message.AppendStringWithBreak(Item.WiredData.Data1);
WiredEffectTypes Type = WiredTypesUtil.EffectFromInt(Item.Definition.BehaviorData);
if(WiredEffectTypes.match_to_sshot == Type || WiredEffectTypes.move_rotate == Type) {
Message.AppendUInt32(3); // Data Count
}
Message.AppendInt32(Item.WiredData.Data2);
Message.AppendInt32(Item.WiredData.Data3);
if(WiredEffectTypes.match_to_sshot == Type || WiredEffectTypes.move_rotate == Type) {
Message.AppendInt32(Item.WiredData.Data4);
Message.AppendUInt32(0);
}
Message.AppendInt32(Item.Definition.BehaviorData);
Message.AppendInt32(Item.WiredData.Time); // TIME
List<Item> Items = Instance.WiredManager.ActionRequiresActor(Item.Definition.BehaviorData, Item.RoomPosition.GetVector2());
Message.AppendInt32(Items.Count);
foreach (Item Blocked in Items) {
Message.AppendUInt32(Blocked.Definition.SpriteId);
}
return Message;
}
private static void WiredSave(Session Session, ClientMessage Message)
{
RoomInstance Instance = RoomManager.GetInstanceByRoomId(Session.CurrentRoomId);
if (Instance == null)
{
return;
}
Instance.WiredManager.HandleSave(Session, Message);
}
private static void UserChat(Session Session, ClientMessage Message)
{
if (Session.CharacterInfo.IsMuted)
{
return;
}
RoomInstance Instance = RoomManager.GetInstanceByRoomId(Session.CurrentRoomId);
if (Instance == null)
{
return;
}
RoomActor Actor = Instance.GetActorByReferenceId(Session.CharacterId);
if (Actor == null)
{
return;
}
bool Shout = (Message.Id == OpcodesIn.ROOM_CHAT_SHOUT);
string MessageText = UserInputFilter.FilterString(Message.PopString());
if (MessageText.Length == 0)
{
return;
}
if (MessageText.Length > 100)
{
MessageText = MessageText.Substring(0, 100);
}
MessageText = Wordfilter.Filter(MessageText);
if (MessageText.StartsWith(":") && (ChatCommands.HandleCommand(Session, MessageText) ||
Session.HasRight("moderation_tool")))
{
return;
}
if (Instance.WiredManager.HandleChat(MessageText, Actor))
{
Actor.Whisper(MessageText, 0);
return;
}
Actor.Chat(MessageText, Shout, Session.HasRight("mute"));
if (Instance.HumanActorCount > 1)
{
QuestManager.ProgressUserQuest(Session, QuestType.SOCIAL_CHAT);
}
}
private static void KickBot(Session Session, ClientMessage Message)
{
RoomInstance Instance = RoomManager.GetInstanceByRoomId(Session.CurrentRoomId);
if (Instance == null || !Instance.CheckUserRights(Session, true))
{
return;
}
Instance.KickBot(Message.PopWiredUInt32());
}
private static void ContinueLoadingAfterDoorbell(Session Session, ClientMessage Message)
{
RoomInstance Instance = RoomManager.GetInstanceByRoomId(Message.PopWiredUInt32());
if (Instance == null)
{
return;
}
EnterRoom(Session, Instance);
}
private static void ApplyDecoration(Session Session, ClientMessage Message)
{
RoomInstance Instance = RoomManager.GetInstanceByRoomId(Session.CurrentRoomId);
if (Instance == null || !Instance.CheckUserRights(Session, true))
{
return;
}
Item Item = Session.InventoryCache.GetItem(Message.PopWiredUInt32());
if (Item == null)
{
return;
}
string DecorationKey = string.Empty;
switch (Item.Definition.Behavior)
{
case ItemBehavior.Floor:
QuestManager.ProgressUserQuest(Session, QuestType.FURNI_DECORATION_FLOOR);
DecorationKey = "floor";
break;
case ItemBehavior.Wallpaper:
QuestManager.ProgressUserQuest(Session, QuestType.FURNI_DECORATION_WALL);
DecorationKey = "wallpaper";
break;
case ItemBehavior.Landscape:
DecorationKey = "landscape";
break;
}
if (DecorationKey.Length == 0)
{
return;
}
Session.InventoryCache.RemoveItem(Item.Id);
using (SqlDatabaseClient MySqlClient = SqlDatabaseManager.GetClient())
{
Item.RemovePermanently(MySqlClient);
Instance.Info.ApplyDecoration(MySqlClient, DecorationKey, Item.Flags);
}
Instance.BroadcastMessage(RoomDecorationComposer.Compose(DecorationKey, Item.Flags));
Session.SendData(InventoryItemRemovedComposer.Compose(Item.Id));
}
private static void StopEvent(Session Session, ClientMessage Message)
{
RoomInstance Instance = RoomManager.GetInstanceByRoomId(Session.CurrentRoomId);
if (Instance == null || !Instance.CheckUserRights(Session, true))
{
return;
}
Instance.StopEvent();
}
private static void GetEditInfo(Session Session, ClientMessage Message)
{
RoomInstance Instance = RoomManager.GetInstanceByRoomId(Session.CurrentRoomId);
if (Instance == null || !Instance.CheckUserRights(Session, true))
{
return;
}
Session.SendData(RoomEditInfoComposer.Compose(Instance));
}
private static void DeleteRoom(Session Session, ClientMessage Message)
{
RoomInstance Instance = RoomManager.GetInstanceByRoomId(Session.CurrentRoomId);
if (Instance == null || !Instance.CheckUserRights(Session, true))
{
return;
}
Instance.DeleteRoom(Session);
//Navigator.GetUserRooms(Session, null); todo: fix. do not uncomment, shit will break in this implementation.
}
private static void RateRoom(Session Session, ClientMessage Message)
{
RoomInstance Instance = RoomManager.GetInstanceByRoomId(Session.CurrentRoomId);
if (Instance == null || Instance.CheckUserRights(Session, true) || Session.RatedRoomsCache.HasRatedRoom(Instance.RoomId))
{
return;
}
Instance.Info.IncreaseScore();
Session.SendData(RoomRatingInfoComposer.Compose(Instance.Info.Score));
}
private static void GetRoomObjects(Session Session, ClientMessage Message)
{
RoomInstance Instance = RoomManager.GetInstanceByRoomId(Session.AbsoluteRoomId);
if (Instance == null || Session.RoomJoined || !Session.RoomAuthed) // if instance not found, or user already joined us, OR if the user isn't authed in the first place, let's gtfo
{
return;
}
Instance.SendObjects(Session);
if (!Instance.AddUserToRoom(Session))
{
RoomManager.RemoveUserFromRoom(Session);
return;
}
Session.RoomAuthed = true;
Session.RoomJoined = true;
ModerationLogs.LogRoomEntry(Session.CharacterId, Instance.RoomId);
MessengerHandler.MarkUpdateNeeded(Session, 0, false);
Session.SendData(RoomWallsStatusComposer.Compose(Instance.Info.HideWalls, Instance.Info.WallThickness, Instance.Info.FloorThickness));
Session.SendData(RoomInfoRightsComposer.Compose(Instance.Info.Type == RoomType.Flat, Instance.RoomId,
(Instance.Info.Type == RoomType.Flat && Instance.CheckUserRights(Session, true)), Instance.Info.PubInternalName));
/*if (Instance.Info.Type == RoomType.Flat)
* {
* Session.SendData(RoomInfoComposer.Compose(Instance.Info, true));
* }*/
if (Session.CharacterInfo.IsMuted)
{
Session.SendData(RoomMutedComposer.Compose((int)Session.CharacterInfo.MutedSecondsLeft));
}
if (Instance.Info.OwnerId != Session.CharacterId)
{
QuestManager.ProgressUserQuest(Session, QuestType.SOCIAL_VISIT);
}
if (Session.QuestCache.CurrentQuestId > 0)
{
Quest Quest = QuestManager.GetQuest(Session.QuestCache.CurrentQuestId);
if (Quest != null)
{
Session.SendData(QuestStartedComposer.Compose(Session, Quest));
}
}
}
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;
}
}
}
}
private static void UserWhisper(Session Session, ClientMessage Message)
{
if (Session.CharacterInfo.IsMuted)
{
return;
}
RoomInstance Instance = RoomManager.GetInstanceByRoomId(Session.CurrentRoomId);
if (Instance == null)
{
return;
}
RoomActor Actor = Instance.GetActorByReferenceId(Session.CharacterId);
if (Actor == null)
{
return;
}
string MessageText = UserInputFilter.FilterString(Message.PopString().Trim());
if (MessageText.Length == 0)
{
return;
}
if (MessageText.Length > 100)
{
MessageText = MessageText.Substring(0, 100);
}
string[] Bits = MessageText.Split(' ');
if (Bits.Length < 2)
{
return;
}
string UserBit = Bits[0];
MessageText = MessageText.Substring(UserBit.Length + 1);
uint UserId = CharacterResolverCache.GetUidFromName(UserBit);
if (UserId > 0)
{
Actor.Whisper(MessageText, UserId);
}
}
private static void UpdateMoodlight(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;
}
MoodlightData Data = MoodlightData.GenerateFromFlags(Item.Flags);
int PresetId = Message.PopWiredInt32();
MoodlightPreset Preset = null;
if (Data.Presets.ContainsKey(PresetId))
{
Preset = Data.Presets[PresetId];
}
if (Preset == null)
{
return;
}
Preset.BackgroundOnly = !Message.PopWiredBoolean();
Preset.ColorCode = UserInputFilter.FilterString(Message.PopString().Trim());
Preset.ColorIntensity = Message.PopWiredInt32();
if (!MoodlightData.IsValidColor(Preset.ColorCode))
{
return;
}
Item.Flags = Data.ToItemFlagData();
Item.DisplayFlags = Data.ToDisplayData();
using (SqlDatabaseClient MySqlClient = SqlDatabaseManager.GetClient())
{
Item.SynchronizeDatabase(MySqlClient, true);
}
Item.BroadcastStateUpdate(Instance);
}
private static void PlacePet(Session Session, ClientMessage Message)
{
RoomInstance Instance = RoomManager.GetInstanceByRoomId(Session.CurrentRoomId);
if (Instance == null || (!Instance.CheckUserRights(Session, true) && !Instance.Info.AllowPets))
{
return;
}
Pet Pet = Session.PetInventoryCache.GetPet(Message.PopWiredUInt32());
if (Pet == null)
{
return;
}
Vector2 DesiredPosition = new Vector2(Message.PopWiredInt32(), Message.PopWiredInt32());
if (!Instance.IsValidPosition(DesiredPosition))
{
return;
}
Bot BotDefinition = BotManager.GetHandlerDefinitionForPetType(Pet.Type);
if (BotDefinition == null)
{
Session.SendData(NotificationMessageComposer.Compose("This pet cannot be placed right now. Please try again later."));
return;
}
if (!Instance.CanPlacePet(Instance.CheckUserRights(Session, true)))
{
Session.SendData(RoomItemPlacementErrorComposer.Compose(RoomItemPlacementErrorCode.PetLimitReached));
return;
}
Vector3 Position = new Vector3(DesiredPosition.X, DesiredPosition.Y, Instance.GetUserStepHeight(DesiredPosition));
Pet.MoveToRoom(Instance.RoomId, Position);
Instance.AddBotToRoom(BotManager.CreateNewInstance(BotDefinition, Instance.RoomId, Position, Pet));
using (SqlDatabaseClient MySqlClient = SqlDatabaseManager.GetClient())
{
Pet.SynchronizeDatabase(MySqlClient);
}
Session.SendData(InventoryPetRemovedComposer.Compose(Pet.Id));
}
private static void SyncSoundManager(Session Session, ClientMessage Message)
{
RoomInstance Instance = RoomManager.GetInstanceByRoomId(Session.CurrentRoomId);
if (Instance == null)
{
return;
}
if (Instance != null && Instance.MusicController.IsPlaying)
{
Session.SendData(MusicPlayingComposer.Compose(Instance.MusicController.CurrentSong.SongData.Id,
Instance.MusicController.SongQueuePosition, Instance.MusicController.SongSyncTimestamp));
}
}
private static void GiveRights(Session Session, ClientMessage Message)
{
RoomInstance Instance = RoomManager.GetInstanceByRoomId(Session.CurrentRoomId);
if (Instance == null || !Instance.CheckUserRights(Session, true))
{
return;
}
uint UserId = Message.PopWiredUInt32();
if (Instance.GiveUserRights(UserId))
{
Session.SendData(RoomRightsGivenConfirmationComposer.Compose(Instance.RoomId, UserId, CharacterResolverCache.GetNameFromUid(UserId)));
}
}
public static void InvokeItemEventHandler(Session Session, Item Item, RoomInstance Instance, ItemEventType Type, int RequestData = 0)
{
lock (mSyncRoot)
{
if (mEventHandlers.ContainsKey(Item.Definition.Behavior))
{
foreach (ItemEventHandler EventHandler in mEventHandlers[Item.Definition.Behavior])
{
if (!EventHandler.Invoke(Session, Item, Instance, Type, RequestData))
{
return;
}
}
}
}
}
private static void SetHome(Session Session, ClientMessage Message)
{
RoomInstance Instance = RoomManager.GetInstanceByRoomId(Session.CurrentRoomId);
if (Instance == null || !Instance.CheckUserRights(Session, true))
{
return;
}
using (SqlDatabaseClient MySqlClient = SqlDatabaseManager.GetClient())
{
Session.CharacterInfo.SetHomeRoom(MySqlClient, Instance.RoomId);
}
Session.SendData(UserHomeRoomComposer.Compose(Session.CharacterInfo.HomeRoom));
}
private static void TakeAllRights(Session Session, ClientMessage Message)
{
RoomInstance Instance = RoomManager.GetInstanceByRoomId(Session.CurrentRoomId);
if (Instance == null || !Instance.CheckUserRights(Session, true))
{
return;
}
foreach (uint UserId in Instance.UsersWithRights)
{
if (Instance.TakeUserRights(UserId))
{
Session.SendData(RoomRightsRemovedConfirmationComposer.Compose(Instance.RoomId, UserId));
}
}
}
private static void GetGroupBadges(Session Session, ClientMessage Message)
{
RoomInstance Instance = RoomManager.GetInstanceByRoomId(Session.AbsoluteRoomId);
if (Instance == null)
{
return;
}
ServerMessage xMessage = new ServerMessage(OpcodesOut.ROOM_GROUP_BADGES);
// count
// foreach => group id
// => string/wb badge code
xMessage.AppendStringWithBreak("Ib[ZCs58116s04078s04072s52074889902cf4440630470f222ad5c6489d7");
Session.SendData(xMessage);
}
private static void UnignoreUser(Session Session, ClientMessage Message)
{
RoomInstance Instance = RoomManager.GetInstanceByRoomId(Session.CurrentRoomId);
if (Instance == null)
{
return;
}
uint UserId = CharacterResolverCache.GetUidFromName(Message.PopString());
if (UserId > 0)
{
Session.IgnoreCache.MarkUserUnignored(UserId);
Session.SendData(RoomIgnoreResultComposer.Compose(3));
}
}
private static void SetIcon(Session Session, ClientMessage Message)
{
RoomInstance Instance = RoomManager.GetInstanceByRoomId(Session.CurrentRoomId);
if (Instance == null || !Instance.CheckUserRights(Session, true))
{
return;
}
int Junk = Message.PopWiredInt32();
int Background = Message.PopWiredInt32();
if (Background < 1 || Background > 24)
{
Background = 1;
}
int Foreground = Message.PopWiredInt32();
if (Foreground < 0 || Foreground > 11)
{
Foreground = 0;
}
int ObjectCount = Message.PopWiredInt32();
Dictionary <int, int> Objects = new Dictionary <int, int>();
for (int i = 0; (i < ObjectCount && i < 10); i++)
{
int Position = Message.PopWiredInt32();
int Item = Message.PopWiredInt32();
if (Position < 0 || Position > 10 || Item < 1 || Item > 27 || Objects.ContainsKey(Position))
{
continue;
}
Objects.Add(Position, Item);
}
Instance.Info.UpdateIcon(Background, Foreground, Objects);
Session.SendData(RoomUpdatedNotification3Composer.Compose(Instance.RoomId));
Instance.BroadcastMessage(RoomUpdatedNotification2Composer.Compose(Instance.RoomId));
}
private static void OpenSticky(Session Session, ClientMessage Message)
{
RoomInstance Instance = RoomManager.GetInstanceByRoomId(Session.CurrentRoomId);
if (Instance == null)
{
return;
}
Item Item = Instance.GetItem(Message.PopWiredUInt32());
if (Item == null || Item.Definition.Behavior != ItemBehavior.StickyNote)
{
return;
}
Session.SendData(StickyDataComposer.Compose(Item));
}
public RoomActor(uint Id, RoomActorType Type, uint ReferenceId, object ReferenceObject, Vector3 Position, int Rotation, RoomInstance Instance)
{
mId = Id;
mType = Type;
mReferenceId = ReferenceId;
mReferenceObject = ReferenceObject;
mPosition = Position;
mBodyRotation = Rotation;
mHeadRotation = Rotation;
mUpdateNeeded = true;
mStatusses = new Dictionary <string, string>();
mInstance = Instance;
mEnableClipping = true;
mMovementSyncRoot = new object();
mPathfinder = PathfinderManager.CreatePathfinderInstance();
mPathfinder.SetRoomInstance(mInstance, Id);
}
public RoomActor(uint Id, RoomActorType Type, uint ReferenceId, object ReferenceObject, Vector3 Position, int Rotation, RoomInstance Instance)
{
mId = Id;
mType = Type;
mReferenceId = ReferenceId;
mReferenceObject = ReferenceObject;
mPosition = Position;
mBodyRotation = Rotation;
mHeadRotation = Rotation;
mUpdateNeeded = true;
mStatusses = new Dictionary<string, string>();
mInstance = Instance;
mEnableClipping = true;
mMovementSyncRoot = new object();
mPathfinder = PathfinderManager.CreatePathfinderInstance();
mPathfinder.SetRoomInstance(mInstance, Id);
}
private static void UserExit(Session Session, ClientMessage Message)
{
RoomInstance Instance = RoomManager.GetInstanceByRoomId(Session.CurrentRoomId);
if (Instance == null)
{
return;
}
RoomActor Actor = Instance.GetActorByReferenceId(Session.CharacterId);
if (Actor == null)
{
return;
}
Actor.LeaveRoom();
}
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)));
}
private static void TypingStateChanged(Session Session, ClientMessage Message)
{
RoomInstance Instance = RoomManager.GetInstanceByRoomId(Session.CurrentRoomId);
if (Instance == null)
{
return;
}
RoomActor Actor = Instance.GetActorByReferenceId(Session.CharacterId);
if (Actor == null)
{
return;
}
Actor.SetTypingState((Message.Id == OpcodesIn.ROOM_CHAT_START_TYPING));
}
private static bool HandleBottle(Session Session, Item Item, RoomInstance Instance, ItemEventType Event, int RequestData)
{
switch (Event)
{
case ItemEventType.Placed:
case ItemEventType.Removing:
if (Item.Flags != "0")
{
Item.Flags = "0";
Item.DisplayFlags = "0";
RoomManager.MarkWriteback(Item, true);
}
break;
case ItemEventType.Interact:
if (Item.Flags != "-1")
{
Item.Flags = "-1";
Item.DisplayFlags = "-1";
Item.BroadcastStateUpdate(Instance);
Item.RequestUpdate(4);
}
break;
case ItemEventType.UpdateTick:
Item.Flags = RandomGenerator.GetNext(0, 7).ToString();
Item.DisplayFlags = Item.Flags;
Item.BroadcastStateUpdate(Instance);
RoomManager.MarkWriteback(Item, true);
break;
}
return true;
}
private static bool HandleWired(Session Session, Item Item, RoomInstance Instance, ItemEventType Event, int RequestData, uint Opcode)
{
switch (Event) {
case ItemEventType.Interact:
switch (Item.Definition.Behavior) {
case ItemBehavior.WiredTrigger:
Session.SendData (WiredFurniTriggerComposer.Compose (Item, Instance));
break;
case ItemBehavior.WiredEffect:
Session.SendData (WiredFurniActionComposer.Compose (Item, Instance));
break;
}
break;
case ItemEventType.Placed:
Item.WiredData = Instance.WiredManager.LoadWired (Item.Id, Item.Definition.BehaviorData);
break;
case ItemEventType.Removing:
using (SqlDatabaseClient MySqlClient = SqlDatabaseManager.GetClient()) {
Instance.WiredManager.RemoveWired (Item.Id, MySqlClient);
}
Instance.WiredManager.DeRegisterWalkItem(Item.Id);
break;
case ItemEventType.UpdateTick:
if (Item.Definition.Behavior == ItemBehavior.WiredTrigger) {
switch (WiredTypesUtil.TriggerFromInt (Item.Definition.BehaviorData)) {
case WiredTriggerTypes.periodically:
Instance.WiredManager.ExecuteActions (Item, null);
Item.RequestUpdate (Item.WiredData.Data2);
break;
case WiredTriggerTypes.at_given_time:
Instance.WiredManager.ExecuteActions (Item, null);
break;
}
return true;
}
Item.BroadcastStateUpdate (Instance);
break;
}
return true;
}
private static bool HandleAlert(Session Session, Item Item, RoomInstance Instance, ItemEventType Event, int RequestData)
{
switch (Event)
{
case ItemEventType.InstanceLoaded:
case ItemEventType.Placed:
case ItemEventType.Removing:
Item.Flags = "0";
Item.DisplayFlags = "0";
break;
case ItemEventType.Interact:
if (!Instance.CheckUserRights(Session) || Item.Flags == "1")
{
break;
}
Item.Flags = "1";
Item.DisplayFlags = "1";
Item.RequestUpdate(4);
Item.BroadcastStateUpdate(Instance);
break;
case ItemEventType.UpdateTick:
if (Item.Flags != "1")
{
break;
}
Item.Flags = "0";
Item.DisplayFlags = "0";
Item.BroadcastStateUpdate(Instance);
break;
}
return true;
}
private static bool HandleRental(Session Session, Item Item, RoomInstance Instance, ItemEventType Event, int RequestData)
{
switch (Event)
{
case ItemEventType.Placed:
case ItemEventType.InstanceLoaded:
if (Item.PendingExpiration)
{
int DesiredTicks = (int)((double)(Math.Ceiling(Item.ExpireTimeLeft * 2)));
if (DesiredTicks <= 0)
{
goto case ItemEventType.UpdateTick;
}
Item.RequestUpdate(DesiredTicks);
return true;
}
break;
case ItemEventType.UpdateTick:
if (Item.PendingExpiration)
{
using (SqlDatabaseClient MySqlClient = SqlDatabaseManager.GetClient())
{
Item.RemovePermanently(MySqlClient);
Instance.TakeItem(Item.Id);
Instance.RegenerateRelativeHeightmap();
}
return true;
}
break;
}
return HandleGenericSwitch(Session, Item, Instance, Event, RequestData);
}
private static bool HandleRoller(Session Session, Item Item, RoomInstance Instance, ItemEventType Event, int RequestData, uint Opcode)
{
switch (Event)
{
case ItemEventType.UpdateTick:
List<RoomActor> ActorsToMove = Instance.GetActorsOnPosition(Item.RoomPosition.GetVector2());
List<Item> ItemsToMove = new List<Item>();
if (ActorsToMove != null)
{
foreach (RoomActor Actor in ActorsToMove)
{
if (Actor.IsMoving)
{
continue;
}
if (Instance.IsValidStep(Actor.Position.GetVector2(), Item.SquareInFront, true))
{
Actor.PositionToSet = Item.SquareInFront;
Instance.BroadcastMessage(RollerEventComposer.Compose(Actor.Position, new Vector3(
Actor.PositionToSet.X, Actor.PositionToSet.Y,
Instance.GetUserStepHeight(Actor.PositionToSet)), Item.Id, Actor.Id, 0));
}
}
}
goto case ItemEventType.InstanceLoaded;
case ItemEventType.InstanceLoaded:
case ItemEventType.Placed:
Item.RequestUpdate(4);
break;
}
return true;
}
public static ServerMessage Compose(RoomInfo Info, RoomInstance Instance)
{
ReadOnlyCollection<string> Tags = Info.Tags;
RoomEvent Event = (Instance == null ? null : Instance.Event);
ServerMessage Message = new ServerMessage(OpcodesOut.MODERATION_ROOM_INFO);
Message.AppendUInt32(Info.Id);
Message.AppendInt32(Info.CurrentUsers);
Message.AppendBoolean(Instance == null ? false : (Instance.GetActorByReferenceId(Info.OwnerId) != null));
Message.AppendUInt32(Info.OwnerId);
Message.AppendStringWithBreak(Info.OwnerName);
Message.AppendUInt32(Info.Id);
Message.AppendStringWithBreak(Info.Name);
Message.AppendStringWithBreak(Info.Description);
Message.AppendInt32(Tags.Count);
foreach (string Tag in Tags)
{
Message.AppendStringWithBreak(Tag);
}
Message.AppendBoolean(Event != null);
if (Event != null)
{
List<string> EventTags = Event.Tags;
Message.AppendStringWithBreak(Event.Name);
Message.AppendStringWithBreak(Event.Description);
Message.AppendInt32(EventTags.Count);
foreach (string Tag in EventTags)
{
Message.AppendStringWithBreak(Tag);
}
}
return Message;
}
public override void OnSelfEnterRoom(RoomInstance Instance)
{
mSelfActor = Instance.GetActorByReferenceId(mSelfBot.Id, RoomActorType.AiBot);
if (mSelfActor == null)
{
return;
}
mNeedsRotation = false;
mNextSpeechAttempt = RandomGenerator.GetNext(20, 255);
mNextMovementAttempt = RandomGenerator.GetNext(20, 255);
mServingItemId = 0;
mServingActorId = 0;
mMovingToServePos = false;
mActorServePos = null;
if (mSelfBot.Rotation >= 0)
{
mSelfActor.BodyRotation = mSelfBot.Rotation;
mSelfActor.HeadRotation = mSelfBot.Rotation;
}
}
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 void EnterRoom(Session Session, RoomInstance Instance)
{
if (!Session.RoomAuthed || Session.RoomJoined || Session.AbsoluteRoomId != Instance.RoomId)
{
return;
}
Session.SendData(RoomUrlComposer.Compose("http://www.meth0d.org/snowlight"));
Session.SendData(RoomEntryModelComposer.Compose(Instance.Model.Id, Instance.Info.Id));
if (Instance.Info.Type == RoomType.Flat)
{
Dictionary<string, string> Decorations = Instance.Info.Decorations;
foreach (KeyValuePair<string, string> Decoration in Decorations)
{
Session.SendData(RoomDecorationComposer.Compose(Decoration.Key, Decoration.Value));
}
Session.SendData(RoomRatingInfoComposer.Compose((Session.RatedRoomsCache.HasRatedRoom(Instance.RoomId) || Instance.CheckUserRights(Session, true)) ? Instance.Info.Score : -1));
Session.SendData(RoomEventInfoComposer.Compose(Instance.Event));
}
}
public static ServerMessage Compose(Item Item, RoomInstance Instance)
{
// com.sulake.habbo.communication.messages.incoming.userdefinedroomevents.WiredFurniTriggerEvent;
ServerMessage Message = new ServerMessage (650);
Message.AppendInt32 (0);
Message.AppendInt32 (5);
if (Item.WiredData.Data1.Contains ("|")) {
String[] Selected = Item.WiredData.Data1.Split ('|');
Message.AppendInt32 (Selected.Length-1);
foreach (String selected in Selected) {
if(selected == "") {
continue;
}
int result;
Int32.TryParse (selected, out result);
Message.AppendInt32 (result);
}
} else {
Message.AppendInt32 (0);
}
Message.AppendUInt32 (Item.Definition.SpriteId);
Message.AppendInt32 ((int)Item.Id);
Message.AppendStringWithBreak (Item.WiredData.Data1);
Message.AppendInt32 (1);
Message.AppendInt32 (Item.WiredData.Data2);
Message.AppendInt32 (0);
Message.AppendInt32 (Item.Definition.BehaviorData);
List<Item> Items = Instance.WiredManager.TriggerRequiresActor (Item.Definition.BehaviorData, Item.RoomPosition.GetVector2 ());
Message.AppendInt32 (Items.Count); // Contains Event that needs a User, but there is a trigger, that isn't triggered by a User
foreach (Item Blocked in Items) {
Message.AppendUInt32 (Blocked.Definition.SpriteId);
}
return Message;
}
private static bool HandleGenericSwitch(Session Session, Item Item, RoomInstance Instance, ItemEventType Event, int RequestData)
{
switch (Event)
{
case ItemEventType.Interact:
if (!Instance.CheckUserRights(Session))
{
return true;
}
int CurrentState = 0;
int.TryParse(Item.Flags, out CurrentState);
int NewState = CurrentState + 1;
if (CurrentState < 0 || CurrentState >= (Item.Definition.BehaviorData - 1))
{
NewState = 0;
}
if (CurrentState != NewState)
{
Item.Flags = NewState.ToString();
Item.DisplayFlags = Item.Flags;
RoomManager.MarkWriteback(Item, true);
Item.BroadcastStateUpdate(Instance);
}
break;
}
return true;
}
private static bool HandleFixedGateSwitch(Session Session, Item Item, RoomInstance Instance, ItemEventType Event, int RequestData, uint Opcode)
{
switch (Event)
{
case ItemEventType.Interact:
if (!Instance.CheckUserRights(Session))
{
return true;
}
List<Vector2> GateTiles = Instance.CalculateAffectedTiles(Item, Item.RoomPosition.GetVector2(), Item.RoomRotation);
foreach (Vector2 Tile in GateTiles)
{
if (Instance.GetActorsOnPosition(Tile).Count > 0)
{
return true;
}
}
int CurrentState = 0;
int.TryParse(Item.Flags, out CurrentState);
Item.Flags = (CurrentState == 0 ? 1 : 0).ToString();
Item.DisplayFlags = Item.Flags;
RoomManager.MarkWriteback(Item, true);
Item.BroadcastStateUpdate(Instance);
Instance.RegenerateRelativeHeightmap();
break;
}
return true;
}
public static ServerMessage Compose(RoomInstance Instance)
{
ServerMessage Message = new ServerMessage(OpcodesOut.ROOM_EDIT_INFO);
Message.AppendUInt32(Instance.Info.Id);
Message.AppendStringWithBreak(Instance.Info.Name);
Message.AppendStringWithBreak(Instance.Info.Description);
Message.AppendInt32((int)Instance.Info.AccessType);
Message.AppendInt32(Instance.Info.CategoryId);
Message.AppendInt32(Instance.Info.MaxUsers);
Message.AppendInt32(Instance.Model.MaxUsers);
Message.AppendInt32(Instance.Info.Tags.Count);
foreach (string Tag in Instance.Info.Tags)
{
Message.AppendStringWithBreak(Tag);
}
Message.AppendInt32(Instance.UsersWithRights.Count);
foreach (uint User in Instance.UsersWithRights)
{
Message.AppendUInt32(User);
Message.AppendStringWithBreak(CharacterResolverCache.GetNameFromUid(User));
}
// GQjl~rkfasfs!qwHHQFQFHHHIHIHHH
Message.AppendInt32(Instance.UsersWithRights.Count);
Message.AppendBoolean(Instance.Info.AllowPets);
Message.AppendBoolean(Instance.Info.AllowPetEating);
Message.AppendBoolean(Instance.Info.DisableRoomBlocking);
Message.AppendBoolean(Instance.Info.HideWalls);
Message.AppendInt32(Instance.Info.WallThickness);
Message.AppendInt32(Instance.Info.FloorThickness);
return Message;
}
private static bool HandleStepSwitch(Session Session, Item Item, RoomInstance Instance, ItemEventType Event, int RequestData)
{
switch (Event)
{
case ItemEventType.InstanceLoaded:
case ItemEventType.Moved:
case ItemEventType.Placed:
Item.RequestUpdate(1);
break;
case ItemEventType.UpdateTick:
string Flags = "0";
if (Instance.GetActorsOnPosition(Item.RoomPosition.GetVector2()).Count > 0)
{
Flags = "1";
}
if (Item.DisplayFlags != Flags)
{
Item.DisplayFlags = Flags;
Item.BroadcastStateUpdate(Instance);
}
Item.RequestUpdate(1);
break;
}
return true;
}
private static bool HandleScoreboard(Session Session, Item Item, RoomInstance Instance, ItemEventType Event, int RequestData)
{
switch (Event)
{
case ItemEventType.Interact:
if (!Instance.CheckUserRights(Session))
{
break;
}
RoomActor Actor = Instance.GetActorByReferenceId(Session.CharacterId);
if (Actor == null)
{
break;
}
if (!Distance.TilesTouching(Actor.Position.GetVector2(), Item.RoomPosition.GetVector2()))
{
Actor.MoveToItemAndInteract(Item, RequestData);
break;
}
int Val = 0;
int.TryParse(Item.DisplayFlags, out Val);
if (RequestData == 1)
{
Val--;
if (Val < 0)
{
Val = 99;
}
}
else if (RequestData == 2)
{
Val++;
if (Val > 99)
{
Val = 0;
}
}
else
{
Val = (Val == -1 ? 0 : -1);
}
Item.DisplayFlags = Val.ToString();
Item.BroadcastStateUpdate(Instance);
break;
}
return true;
}
private static bool HandleOneWayGate(Session Session, Item Item, RoomInstance Instance, ItemEventType Event, int RequestData, uint Opcode)
{
switch (Event)
{
case ItemEventType.InstanceLoaded:
case ItemEventType.Moved:
case ItemEventType.Placed:
if (Item.DisplayFlags != "0")
{
Item.DisplayFlags = "0";
Item.BroadcastStateUpdate(Instance);
}
foreach (uint ActorId in Item.TemporaryInteractionReferenceIds.Values)
{
RoomActor ActorToUnlock = Instance.GetActor(ActorId);
if (ActorToUnlock != null)
{
ActorToUnlock.UnblockWalking();
}
}
Item.TemporaryInteractionReferenceIds.Clear();
break;
case ItemEventType.Interact:
RoomActor Actor = Instance.GetActorByReferenceId(Session.CharacterId);
if (Actor == null)
{
break;
}
if (Actor.Position.X != Item.SquareInFront.X || Actor.Position.Y != Item.SquareInFront.Y)
{
Actor.MoveToItemAndInteract(Item, RequestData, Opcode);
break;
}
if (Item.TemporaryInteractionReferenceIds.Count == 0 && Instance.IsValidStep(Item.RoomPosition.GetVector2(),
Item.SquareBehind, true) && Item.DisplayFlags == "0")
{
Actor.BlockWalking();
Actor.MoveTo(Item.RoomPosition.GetVector2(), true, true, true);
Item.TemporaryInteractionReferenceIds.Add(1, Actor.Id);
Item.RequestUpdate(1);
}
break;
case ItemEventType.UpdateTick:
RoomActor UpdateActor = null;
if (Item.TemporaryInteractionReferenceIds.ContainsKey(1))
{
UpdateActor = Instance.GetActor(Item.TemporaryInteractionReferenceIds[1]);
}
if (UpdateActor == null || !Instance.IsValidStep(Item.RoomPosition.GetVector2(), Item.SquareBehind, true)
|| ((UpdateActor.Position.X != Item.RoomPosition.X || UpdateActor.Position.Y !=
Item.RoomPosition.Y) && (UpdateActor.Position.X != Item.SquareInFront.X ||
UpdateActor.Position.Y != Item.SquareInFront.Y)))
{
if (Item.DisplayFlags != "0")
{
Item.DisplayFlags = "0";
Item.BroadcastStateUpdate(Instance);
}
if (Item.TemporaryInteractionReferenceIds.Count > 0)
{
Item.TemporaryInteractionReferenceIds.Clear();
}
if (UpdateActor != null)
{
UpdateActor.UnblockWalking();
}
break;
}
Item.DisplayFlags = "1";
Item.BroadcastStateUpdate(Instance);
UpdateActor.MoveTo(Item.SquareBehind, true, true, true);
Item.RequestUpdate(2);
break;
}
return true;
}
public static RoomActor TryCreateActor(uint Id, RoomActorType Type, uint ReferenceId, object ReferenceObject, Vector3 Position, int Rotation, RoomInstance Instance)
{
if (ReferenceObject == null)
{
return null;
}
return new RoomActor(Id, Type, ReferenceId, ReferenceObject, Position, Rotation, Instance);
}
private static bool HandleDispenser(Session Session, Item Item, RoomInstance Instance, ItemEventType Event, int RequestData, uint Opcode)
{
switch (Event)
{
case ItemEventType.Moved:
{
RoomActor InteractingActor = (Item.TemporaryInteractionReferenceIds.ContainsKey(0) ?
Instance.GetActor(Item.TemporaryInteractionReferenceIds[0]) : null);
if (InteractingActor != null)
{
InteractingActor.UnblockWalking();
}
goto case ItemEventType.InstanceLoaded;
}
case ItemEventType.InstanceLoaded:
{
if (Item.DisplayFlags != "0")
{
Item.DisplayFlags = "0";
Item.BroadcastStateUpdate(Instance);
}
return true;
}
case ItemEventType.Interact:
{
RoomActor InteractingActor = Instance.GetActorByReferenceId(Session.CharacterId);
if (InteractingActor == null)
{
return true;
}
if (InteractingActor.Position.X != Item.SquareInFront.X || InteractingActor.Position.Y !=
Item.SquareInFront.Y)
{
InteractingActor.MoveToItemAndInteract(Item, RequestData, Opcode);
return true;
}
if (Item.TemporaryInteractionReferenceIds.Count == 0)
{
Item.TemporaryInteractionReferenceIds.Add(0, InteractingActor.Id);
InteractingActor.BlockWalking();
InteractingActor.PositionToSet = Item.SquareInFront;
int NewRot = Rotation.Calculate(InteractingActor.Position.GetVector2(),
Item.RoomPosition.GetVector2());
if (InteractingActor.BodyRotation != NewRot)
{
InteractingActor.BodyRotation = NewRot;
InteractingActor.HeadRotation = NewRot;
InteractingActor.UpdateNeeded = true;
}
Item.DisplayFlags = "1";
Item.BroadcastStateUpdate(Instance);
Item.RequestUpdate(2);
}
return true;
}
case ItemEventType.UpdateTick:
{
if (Item.DisplayFlags != "0")
{
Item.DisplayFlags = "0";
Item.BroadcastStateUpdate(Instance);
}
if (Item.TemporaryInteractionReferenceIds.Count < 1)
{
return true;
}
RoomActor InteractingActor = Instance.GetActor(Item.TemporaryInteractionReferenceIds[0]);
Item.TemporaryInteractionReferenceIds.Clear();
if (InteractingActor == null)
{
return true;
}
InteractingActor.CarryItem(DrinkSetManager.GetRandomDrinkForSet(Item.Definition.BehaviorData));
int NewRot = Rotation.Calculate(InteractingActor.Position.GetVector2(),
Item.RoomPosition.GetVector2());
if (InteractingActor.BodyRotation != NewRot)
{
InteractingActor.BodyRotation = NewRot;
InteractingActor.HeadRotation = NewRot;
InteractingActor.UpdateNeeded = true;
}
InteractingActor.UnblockWalking();
return true;
}
}
return true;
}
private static bool HandleRoller(Session Session, Item Item, RoomInstance Instance, ItemEventType Event, int RequestData, uint Opcode)
{
switch (Event)
{
case ItemEventType.UpdateTick:
List<RoomActor> ActorsToMove = Instance.GetActorsOnPosition(Item.RoomPosition.GetVector2());
List<Item> ItemsToMove = new List<Item>();
ItemsToMove.AddRange(Instance.GetItemsOnPosition(Item.RoomPosition.GetVector2()));
if (ActorsToMove != null)
{
foreach (RoomActor Actor in ActorsToMove)
{
if (Actor.IsMoving)
{
continue;
}
if (Instance.IsValidStep(Actor.Position.GetVector2(), Item.SquareInFront, true))
{
Actor.PositionToSet = Item.SquareInFront;
Instance.BroadcastMessage(RollerEventComposer.Compose(Actor.Position, new Vector3(
Actor.PositionToSet.X, Actor.PositionToSet.Y,
Instance.GetUserStepHeight(Actor.PositionToSet)), Item.Id, Actor.Id, 0));
}
}
}
if (ItemsToMove.Count != 0)
{
foreach (Item item in ItemsToMove)
{
if (item == Item)
{
continue;
}
if (Item.RoomPosition.X == item.RoomPosition.X && Item.RoomPosition.Y == item.RoomPosition.Y)
{
Vector2 NewPosition = new Vector2(Item.SquareInFront.X, Item.SquareInFront.Y);
int NewRotation = item.RoomRotation;
Vector3 FinalizedPosition = Instance.SetFloorItem(Session, item, NewPosition, NewRotation);
Vector3 oldpos = item.RoomPosition;
if (FinalizedPosition != null)
{
item.MoveToRoom(null, Instance.RoomId, FinalizedPosition, NewRotation, string.Empty);
RoomManager.MarkWriteback(item, false);
Instance.RegenerateRelativeHeightmap();
Instance.BroadcastMessage(RoomItemUpdatedComposer.Compose(item));
ItemEventDispatcher.InvokeItemEventHandler(Session, item, Instance, ItemEventType.Moved, 0);
Instance.BroadcastMessage(RollerEventComposer.Compose(oldpos, FinalizedPosition, Item.Id, 0, item.Id));
}
}
}
}
goto case ItemEventType.InstanceLoaded;
case ItemEventType.InstanceLoaded:
case ItemEventType.Placed:
Item.RequestUpdate(4);
break;
}
return true;
}
private static bool HandleFireworks(Session Session, Item Item, RoomInstance Instance, ItemEventType Event, int RequestData)
{
int CurrentCharges = 0;
int.TryParse(Item.Flags, out CurrentCharges);
switch (Event)
{
case ItemEventType.InstanceLoaded:
case ItemEventType.Placed:
case ItemEventType.Moved:
case ItemEventType.UpdateTick:
string DesiredDisplayFlags = "0";
if (CurrentCharges > 0)
{
DesiredDisplayFlags = "1";
}
if (Item.DisplayFlags != DesiredDisplayFlags)
{
Item.DisplayFlags = DesiredDisplayFlags;
Item.BroadcastStateUpdate(Instance);
}
break;
case ItemEventType.Interact:
RoomActor Actor = Instance.GetActorByReferenceId(Session.CharacterId);
if (Actor == null)
{
return true;
}
if (Distance.Calculate(Actor.Position.GetVector2(), Item.RoomPosition.GetVector2()) > 1)
{
Actor.MoveToItemAndInteract(Item, RequestData, Item.SquareBehind);
return true;
}
switch (RequestData)
{
// Purchase charges
case 2:
if (Session.CharacterInfo.CreditsBalance < CHARGE_COSTS_CREDITS)
{
return true;
}
if (Session.CharacterInfo.ActivityPointsBalance < CHARGE_COSTS_PIXELS)
{
return true;
}
bool Update = (CurrentCharges <= 0);
CurrentCharges += CHARGE_AMOUNT;
Item.Flags = CurrentCharges.ToString();
using (SqlDatabaseClient MySqlClient = SqlDatabaseManager.GetClient())
{
if (CHARGE_COSTS_CREDITS > 0)
{
Session.CharacterInfo.UpdateCreditsBalance(MySqlClient, -CHARGE_COSTS_CREDITS);
Session.SendData(CreditsBalanceComposer.Compose(Session.CharacterInfo.CreditsBalance));
}
if (CHARGE_COSTS_PIXELS > 0)
{
Session.CharacterInfo.UpdateActivityPointsBalance(MySqlClient, -CHARGE_COSTS_PIXELS);
Session.SendData(ActivityPointsBalanceComposer.Compose(Session.CharacterInfo.ActivityPointsBalance,
-CHARGE_COSTS_PIXELS));
}
Item.SynchronizeDatabase(MySqlClient, true);
}
Session.SendData(FireworksChargeInfoComposer.Compose(Item.Id, CurrentCharges, CHARGE_COSTS_CREDITS,
CHARGE_COSTS_PIXELS, CHARGE_AMOUNT));
if (Update)
{
Item.DisplayFlags = "1";
Item.BroadcastStateUpdate(Instance);
}
break;
case 1:
Session.SendData(FireworksChargeInfoComposer.Compose(Item.Id, CurrentCharges, CHARGE_COSTS_CREDITS,
CHARGE_COSTS_PIXELS, CHARGE_AMOUNT));
break;
default:
case 0:
if (Item.DisplayFlags == "2")
{
return true;
}
if (CurrentCharges > 0)
{
Item.DisplayFlags = "2";
Item.BroadcastStateUpdate(Instance);
Item.Flags = (--CurrentCharges).ToString();
RoomManager.MarkWriteback(Item, true);
Item.RequestUpdate(Item.Definition.BehaviorData);
}
else
{
goto case 1;
}
break;
}
break;
}
return true;
}
private static bool HandleJukebox(Session Session, Item Item, RoomInstance Instance, ItemEventType Event, int RequestData, uint Opcode)
{
switch (Event)
{
case ItemEventType.Placed:
case ItemEventType.InstanceLoaded:
Instance.MusicController.Reset();
Instance.MusicController.LinkRoomOutputItem(Item);
List<Item> Disks = new List<Item>();
using (SqlDatabaseClient MySqlClient = SqlDatabaseManager.GetClient())
{
Disks = LoadPlaylist(MySqlClient, Item.Id);
}
foreach (Item Disk in Disks)
{
Instance.MusicController.AddDisk(Disk);
}
if (Item.DisplayFlags == "1")
{
if (Instance.MusicController.PlaylistSize > 0)
{
Instance.MusicController.Start();
}
else
{
Item.DisplayFlags = "0";
Item.BroadcastStateUpdate(Instance);
}
}
break;
case ItemEventType.Removing:
if (Instance.MusicController.IsPlaying)
{
Instance.MusicController.Stop();
Instance.MusicController.BroadcastCurrentSongData(Instance);
}
Instance.MusicController.Reset();
break;
case ItemEventType.Interact:
if (!Instance.CheckUserRights(Session, true))
{
return true;
}
switch (RequestData)
{
case -1: // Open interface
break;
default: // it loves sending random numbers. as you do.
if (Item.DisplayFlags == "1")
{
Item.DisplayFlags = "0";
Instance.MusicController.Stop();
}
else
{
if (Instance.MusicController.PlaylistSize < 1)
{
break;
}
Item.DisplayFlags = "1";
Instance.MusicController.Start();
}
Item.BroadcastStateUpdate(Instance);
RoomManager.MarkWriteback(Item, true);
Instance.MusicController.BroadcastCurrentSongData(Instance);
break;
}
break;
}
return true;
}