private static void UserMoveTo(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 RequestX = Message.PopWiredInt32();
int RequestY = Message.PopWiredInt32();
if (RequestX < 0 || RequestY < 0)
{
return;
}
Actor.MoveTo(new Vector2(RequestX, RequestY));
}
private static void UserDance(Session Session, ClientMessage Message)
{
RoomInstance Instance = RoomManager.GetInstanceByRoomId(Session.CurrentRoomId);
if (Instance == null)
{
return;
}
RoomActor Actor = Instance.GetActorByReferenceId(Session.CharacterId);
if (Actor == null || Actor.AvatarEffectId > 0)
{
return;
}
int DanceId = Message.PopWiredInt32();
if (DanceId < 0 || DanceId > 4)
{
return;
}
if (!Session.HasRight("club_regular") && !Session.HasRight("club_vip") && DanceId != 0)
{
DanceId = 1;
}
Actor.Dance(DanceId);
QuestManager.ProgressUserQuest(Session, QuestType.SOCIAL_DANCE);
}
private static void TakePet(Session Session, ClientMessage Message)
{
RoomInstance Instance = RoomManager.GetInstanceByRoomId(Session.CurrentRoomId);
if (Instance == null)
{
return;
}
RoomActor Actor = Instance.GetActorByReferenceId(Message.PopWiredUInt32(), RoomActorType.AiBot);
if (Actor == null)
{
return;
}
Pet PetData = ((Bot)Actor.ReferenceObject).PetData;
if (PetData == null || (PetData.OwnerId != Session.CharacterId && !Session.HasRight("hotel_admin")))
{
return;
}
Instance.RemoveActorFromRoom(Actor.Id);
Session.PetInventoryCache.Add(PetData);
Session.SendData(InventoryPetAddedComposer.Compose(PetData));
}
private static void GetPetInfo(Session Session, ClientMessage Message)
{
RoomInstance Instance = RoomManager.GetInstanceByRoomId(Session.CurrentRoomId);
if (Instance == null)
{
return;
}
uint ActorRefId = Message.PopWiredUInt32();
RoomActor Actor = Instance.GetActorByReferenceId(ActorRefId, RoomActorType.AiBot);
if (Actor == null)
{
return;
}
Pet PetData = ((Bot)Actor.ReferenceObject).PetData;
if (PetData == null)
{
return;
}
Session.SendData(PetInfoComposer.Compose(Actor.ReferenceId, PetData));
}
public void Whisper(string MessageText, uint TargetUserId, bool CanOverrideRoomMute = false)
{
if (mIsLeavingRoom && mForcedLeave)
{
return;
}
Unidle();
if (mInstance.RoomMuted && !CanOverrideRoomMute)
{
return;
}
ServerMessage Message = RoomChatComposer.Compose(Id, MessageText, 0, ChatType.Whisper);
if (Type == RoomActorType.UserCharacter)
{
Session Session = SessionManager.GetSessionByCharacterId(mReferenceId);
if (Session != null)
{
Session.SendData(Message);
}
}
string LogTargetName = "Unknown User";
if (TargetUserId != mReferenceId)
{
RoomActor TargetActor = mInstance.GetActorByReferenceId(TargetUserId);
if (TargetActor == null || TargetActor.Type != RoomActorType.UserCharacter)
{
return;
}
Session TargetSession = SessionManager.GetSessionByCharacterId(TargetActor.ReferenceId);
if (TargetSession != null)
{
if (!TargetSession.IgnoreCache.UserIsIgnored(this.ReferenceId))
{
TargetSession.SendData(Message);
}
LogTargetName = TargetSession.CharacterInfo.Username;
}
}
if (mType == RoomActorType.UserCharacter)
{
using (SqlDatabaseClient MySqlClient = SqlDatabaseManager.GetClient())
{
ModerationLogs.LogChatMessage(MySqlClient, mReferenceId, mInstance.RoomId, "(Whisper to " + LogTargetName + ") " + MessageText);
IncrecementAntiSpam(MySqlClient);
}
}
}
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 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 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 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 void UserWave(Session Session, ClientMessage Message)
{
RoomInstance Instance = RoomManager.GetInstanceByRoomId(Session.CurrentRoomId);
if (Instance == null)
{
return;
}
RoomActor Actor = Instance.GetActorByReferenceId(Session.CharacterId);
if (Actor == null || Actor.AvatarEffectId > 0)
{
return;
}
Actor.Wave();
QuestManager.ProgressUserQuest(Session, QuestType.SOCIAL_WAVE);
}
private static void GetUserTags(Session Session, ClientMessage Message)
{
RoomInstance Instance = RoomManager.GetInstanceByRoomId(Session.CurrentRoomId);
if (Instance == null)
{
return;
}
RoomActor Actor = Instance.GetActorByReferenceId(Message.PopWiredUInt32());
if (Actor == null)
{
return;
}
CharacterInfo Info = (CharacterInfo)Actor.ReferenceObject;
Session.SendData(RoomUserTagsComposer.Compose(Info.Id, Info.Tags));
}
private static void UserChangeRotation(Session Session, ClientMessage Message)
{
RoomInstance Instance = RoomManager.GetInstanceByRoomId(Session.CurrentRoomId);
if (Instance == null)
{
return;
}
RoomActor Actor = Instance.GetActorByReferenceId(Session.CharacterId);
if (Actor == null || Actor.IsMoving)
{
return;
}
Vector2 PositionToFace = new Vector2(Message.PopWiredInt32(), Message.PopWiredInt32());
if ((Actor.Position.X == PositionToFace.X && Actor.Position.Y == PositionToFace.Y) ||
Actor.UserStatusses.ContainsKey("lay") || Actor.UserStatusses.ContainsKey("sit"))
{
return;
}
int NewRotation = 0;
NewRotation = Rotation.Calculate(Actor.Position.GetVector2(), PositionToFace);
if (Actor.BodyRotation != NewRotation)
{
Actor.BodyRotation = NewRotation;
Actor.UpdateNeeded = true;
}
if (Actor.HeadRotation != NewRotation)
{
Actor.HeadRotation = NewRotation;
Actor.UpdateNeeded = true;
}
}
private static void RespectUser(Session Session, ClientMessage Message)
{
RoomInstance Instance = RoomManager.GetInstanceByRoomId(Session.CurrentRoomId);
if (Instance == null || Session.CharacterInfo.RespectCreditHuman <= 0)
{
return;
}
RoomActor TargetActor = Instance.GetActorByReferenceId(Message.PopWiredUInt32());
if (TargetActor == null)
{
return;
}
Session TargetSession = SessionManager.GetSessionByCharacterId(TargetActor.ReferenceId);
if (TargetSession == null)
{
return;
}
TargetSession.CharacterInfo.RespectPoints++;
Session.CharacterInfo.RespectCreditHuman--;
Instance.BroadcastMessage(RoomUserRespectedComposer.Compose(TargetSession.CharacterId,
TargetSession.CharacterInfo.RespectPoints));
using (SqlDatabaseClient MySqlClient = SqlDatabaseManager.GetClient())
{
TargetSession.CharacterInfo.SynchronizeRespectData(MySqlClient);
Session.CharacterInfo.SynchronizeRespectData(MySqlClient);
AchievementManager.ProgressUserAchievement(MySqlClient, TargetSession, "ACH_RespectEarned", 1);
AchievementManager.ProgressUserAchievement(MySqlClient, Session, "ACH_RespectGiven", 1);
}
QuestManager.ProgressUserQuest(Session, QuestType.SOCIAL_RESPECT);
}
private static void RespectPet(Session Session, ClientMessage Message)
{
if (Session.CharacterInfo.RespectCreditPets <= 0)
{
return;
}
RoomInstance Instance = RoomManager.GetInstanceByRoomId(Session.CurrentRoomId);
if (Instance == null)
{
return;
}
RoomActor Actor = Instance.GetActorByReferenceId(Message.PopWiredUInt32(), RoomActorType.AiBot);
if (Actor == null)
{
return;
}
Pet PetData = ((Bot)Actor.ReferenceObject).PetData;
if (PetData == null)
{
return;
}
Session.CharacterInfo.RespectCreditPets = 500;/*--;*/
PetData.Score++;
using (SqlDatabaseClient MySqlClient = SqlDatabaseManager.GetClient())
{
Session.CharacterInfo.SynchronizeRespectData(MySqlClient);
PetData.SynchronizeDatabase(MySqlClient);
}
Instance.BroadcastMessage(RoomPetUpdateComposer.Compose(Actor.ReferenceId, PetData));
}
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 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 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 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 HandleDice(Session Session, Item Item, RoomInstance Instance, ItemEventType Event, int RequestData)
{
switch (Event)
{
case ItemEventType.Placed:
case ItemEventType.Removing:
if (Item.Flags != "0" && Item.Flags != "1")
{
Item.Flags = "0";
Item.DisplayFlags = "0";
RoomManager.MarkWriteback(Item, true);
}
break;
case ItemEventType.Interact:
RoomActor TargetActor = Instance.GetActorByReferenceId(Session.CharacterId);
if (TargetActor == null)
{
break;
}
if (!Distance.TilesTouching(TargetActor.Position.GetVector2(), Item.RoomPosition.GetVector2())
&& !Distance.IsDiagonal(TargetActor.Position.GetVector2(), Item.RoomPosition.GetVector2()))
{
TargetActor.MoveToItemAndInteract(Item, RequestData);
break;
}
if (RequestData >= 0)
{
if (Item.Flags != "-1")
{
Item.Flags = "-1";
Item.DisplayFlags = "-1";
Item.BroadcastStateUpdate(Instance);
Item.RequestUpdate(3);
}
}
else
{
Item.Flags = "0";
Item.DisplayFlags = "0";
}
break;
case ItemEventType.UpdateTick:
Item.Flags = RandomGenerator.GetNext(1, 6).ToString();
Item.DisplayFlags = Item.Flags;
Item.BroadcastStateUpdate(Instance);
RoomManager.MarkWriteback(Item, true);
break;
}
return true;
}
private static bool HandleTeleporter(Session Session, Item Item, RoomInstance Instance, ItemEventType Event, int RequestData, uint Opcode)
{
RoomActor Actor = null;
uint LinkedRef = 0;
uint.TryParse(Item.Flags, out LinkedRef);
switch (Event)
{
case ItemEventType.InstanceLoaded:
Item.DisplayFlags = "0";
break;
case ItemEventType.Moved:
if (RequestData != 1)
{
goto case ItemEventType.Removing;
}
break;
case ItemEventType.Removing:
case ItemEventType.Placed:
if (Item.DisplayFlags != "0")
{
Item.DisplayFlags = "0";
if (Event == ItemEventType.Moved)
{
Item.BroadcastStateUpdate(Instance);
}
}
foreach (uint RefId in Item.TemporaryInteractionReferenceIds.Values)
{
RoomActor InteractingActor = Instance.GetActor(RefId);
if (InteractingActor != null)
{
InteractingActor.UnblockWalking();
}
}
Item.TemporaryInteractionReferenceIds.Clear();
break;
case ItemEventType.Interact:
if (Session != null)
{
Actor = Instance.GetActorByReferenceId(Session.CharacterId);
}
if (Actor == null)
{
break;
}
bool IsInFront = (Actor.Position.X == Item.SquareInFront.X && Actor.Position.Y == Item.SquareInFront.Y);
bool IsInTele = !IsInFront && (Actor.Position.X == Item.RoomPosition.X &&
Actor.Position.Y == Item.RoomPosition.Y);
if (!IsInFront && !IsInTele)
{
Actor.MoveToItemAndInteract(Item, RequestData, Opcode);
break;
}
if (Item.DisplayFlags == "0" && Item.TemporaryInteractionReferenceIds.Count == 0)
{
Item.TemporaryInteractionReferenceIds.Add(1, Actor.Id);
Actor.BlockWalking();
using (SqlDatabaseClient MySqlClient = SqlDatabaseManager.GetClient())
{
TeleporterLinkFinder.FillCache(MySqlClient, LinkedRef);
}
if (IsInTele)
{
Item.RequestUpdate(1);
}
else
{
Item.DisplayFlags = "1";
Actor.MoveTo(Item.RoomPosition.GetVector2(), true, true, true);
Item.BroadcastStateUpdate(Instance);
Item.RequestUpdate(3);
}
}
break;
case ItemEventType.UpdateTick:
RoomActor OutgoingUser = null;
RoomActor IncomingUser = null;
if (Item.TemporaryInteractionReferenceIds.ContainsKey(1))
{
OutgoingUser = Instance.GetActor(Item.TemporaryInteractionReferenceIds[1]);
if (OutgoingUser == null)
{
Item.TemporaryInteractionReferenceIds.Remove(1);
}
}
if (Item.TemporaryInteractionReferenceIds.ContainsKey(2))
{
IncomingUser = Instance.GetActor(Item.TemporaryInteractionReferenceIds[2]);
if (IncomingUser == null)
{
Item.TemporaryInteractionReferenceIds.Remove(2);
}
}
string EffectToApply = "0";
uint LinkedRoomRefId = TeleporterLinkFinder.GetValue(LinkedRef);
RoomInstance LinkedRoomRef = RoomManager.GetInstanceByRoomId(LinkedRoomRefId);
if (OutgoingUser != null)
{
Item TargetItem = null;
Session OutgoingSession = SessionManager.GetSessionByCharacterId(OutgoingUser.ReferenceId);
if (LinkedRoomRef == null && LinkedRoomRefId > 0)
{
RoomManager.TryLoadRoomInstance(LinkedRoomRefId);
LinkedRoomRef = RoomManager.GetInstanceByRoomId(LinkedRoomRefId);
}
if (LinkedRoomRef != null)
{
TargetItem = LinkedRoomRef.GetItem(LinkedRef);
}
if (OutgoingSession == null || OutgoingUser.Position.X != Item.RoomPosition.X ||
OutgoingUser.Position.Y != Item.RoomPosition.Y || (TargetItem != null &&
TargetItem.TemporaryInteractionReferenceIds.ContainsKey(2)))
{
OutgoingUser.UnblockWalking();
Item.TemporaryInteractionReferenceIds.Remove(1);
}
else if (TargetItem != null)
{
EffectToApply = "2";
RoomActor TeleActor = OutgoingUser;
if (Instance != LinkedRoomRef)
{
OutgoingSession.IsTeleporting = true;
OutgoingSession.TargetTeleporterId = LinkedRef;
RoomHandler.PrepareRoom(OutgoingSession, LinkedRoomRefId, string.Empty, true);
TeleActor = null;
}
if (TeleActor != null)
{
TeleActor.BlockWalking();
TeleActor.Position = new Vector3(TargetItem.RoomPosition.X, TargetItem.RoomPosition.Y, TargetItem.RoomPosition.Z);
TeleActor.BodyRotation = TargetItem.RoomRotation;
TeleActor.HeadRotation = TeleActor.BodyRotation;
TeleActor.UpdateNeeded = true;
if (TargetItem.DisplayFlags != "2")
{
TargetItem.DisplayFlags = "2";
TargetItem.BroadcastStateUpdate(LinkedRoomRef);
TargetItem.RequestUpdate(3);
}
TargetItem.TemporaryInteractionReferenceIds.Add(2, TeleActor.Id);
}
Item.TemporaryInteractionReferenceIds.Remove(1);
Item.RequestUpdate(2);
}
else if (TargetItem == null)
{
EffectToApply = "1";
OutgoingUser.UnblockWalking();
if (Instance.IsValidStep(OutgoingUser.Position.GetVector2(), Item.SquareInFront, true))
{
OutgoingUser.MoveTo(Item.SquareInFront);
}
Item.TemporaryInteractionReferenceIds.Remove(1);
Item.RequestUpdate(2);
}
}
if (IncomingUser != null)
{
if (IncomingUser.Position.X != Item.RoomPosition.X || IncomingUser.Position.Y != IncomingUser.Position.Y)
{
IncomingUser.UnblockWalking();
Item.TemporaryInteractionReferenceIds.Remove(2);
}
else
{
EffectToApply = "1";
IncomingUser.UnblockWalking();
Item.TemporaryInteractionReferenceIds.Remove(2);
if (Instance.CanInitiateMoveToPosition(Item.SquareInFront))
{
IncomingUser.MoveTo(Item.SquareInFront);
}
Item.RequestUpdate(3);
}
}
if (Item.DisplayFlags != EffectToApply)
{
Item.DisplayFlags = EffectToApply;
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;
}