public static void OnMapChange(WorldObject obj)
        {
            PhaseShift          phaseShift           = obj.GetPhaseShift();
            PhaseShift          suppressedPhaseShift = obj.GetSuppressedPhaseShift();
            ConditionSourceInfo srcInfo = new ConditionSourceInfo(obj);

            obj.GetPhaseShift().VisibleMapIds.Clear();
            obj.GetPhaseShift().UiMapPhaseIds.Clear();
            obj.GetSuppressedPhaseShift().VisibleMapIds.Clear();

            foreach (var pair in Global.ObjectMgr.GetTerrainSwaps())
            {
                if (Global.ConditionMgr.IsObjectMeetingNotGroupedConditions(ConditionSourceType.TerrainSwap, pair.Value.Id, srcInfo))
                {
                    if (pair.Key == obj.GetMapId())
                    {
                        phaseShift.AddVisibleMapId(pair.Value.Id, pair.Value);
                    }

                    // ui map is visible on all maps
                    foreach (uint uiMapPhaseId in pair.Value.UiMapPhaseIDs)
                    {
                        phaseShift.AddUiMapPhaseId(uiMapPhaseId);
                    }
                }
                else
                {
                    suppressedPhaseShift.AddVisibleMapId(pair.Value.Id, pair.Value);
                }
            }

            UpdateVisibilityIfNeeded(obj, false, true);
        }
        public static void OnMapChange(WorldObject obj)
        {
            PhaseShift          phaseShift           = obj.GetPhaseShift();
            PhaseShift          suppressedPhaseShift = obj.GetSuppressedPhaseShift();
            ConditionSourceInfo srcInfo = new ConditionSourceInfo(obj);

            obj.GetPhaseShift().VisibleMapIds.Clear();
            obj.GetPhaseShift().UiWorldMapAreaIdSwaps.Clear();
            obj.GetSuppressedPhaseShift().VisibleMapIds.Clear();

            var visibleMapIds = Global.ObjectMgr.GetTerrainSwapsForMap(obj.GetMapId());

            if (!visibleMapIds.Empty())
            {
                foreach (TerrainSwapInfo visibleMapInfo in visibleMapIds)
                {
                    if (Global.ConditionMgr.IsObjectMeetingNotGroupedConditions(ConditionSourceType.TerrainSwap, visibleMapInfo.Id, srcInfo))
                    {
                        phaseShift.AddVisibleMapId(visibleMapInfo.Id, visibleMapInfo);
                        foreach (uint uiWorldMapAreaIdSwap in visibleMapInfo.UiWorldMapAreaIDSwaps)
                        {
                            phaseShift.AddUiWorldMapAreaIdSwap(uiWorldMapAreaIdSwap);
                        }
                    }
                    else
                    {
                        suppressedPhaseShift.AddVisibleMapId(visibleMapInfo.Id, visibleMapInfo);
                    }
                }
            }

            UpdateVisibilityIfNeeded(obj, false, true);
        }
 public static void InitDbVisibleMapId(PhaseShift phaseShift, int visibleMapId)
 {
     phaseShift.VisibleMapIds.Clear();
     if (visibleMapId != -1)
     {
         phaseShift.AddVisibleMapId((uint)visibleMapId, Global.ObjectMgr.GetTerrainSwapInfo((uint)visibleMapId));
     }
 }
        public static void OnConditionChange(WorldObject obj)
        {
            PhaseShift          phaseShift           = obj.GetPhaseShift();
            PhaseShift          suppressedPhaseShift = obj.GetSuppressedPhaseShift();
            PhaseShift          newSuppressions      = new PhaseShift();
            ConditionSourceInfo srcInfo = new ConditionSourceInfo(obj);
            bool changed = false;

            foreach (var pair in phaseShift.Phases.ToList())
            {
                if (pair.Value.AreaConditions != null && !Global.ConditionMgr.IsObjectMeetToConditions(srcInfo, pair.Value.AreaConditions))
                {
                    newSuppressions.AddPhase(pair.Key, pair.Value.Flags, pair.Value.AreaConditions, pair.Value.References);
                    phaseShift.ModifyPhasesReferences(pair.Key, pair.Value, -pair.Value.References);
                    phaseShift.Phases.Remove(pair.Key);
                }
            }

            foreach (var pair in suppressedPhaseShift.Phases.ToList())
            {
                if (Global.ConditionMgr.IsObjectMeetToConditions(srcInfo, pair.Value.AreaConditions))
                {
                    changed = phaseShift.AddPhase(pair.Key, pair.Value.Flags, pair.Value.AreaConditions, pair.Value.References) || changed;
                    suppressedPhaseShift.ModifyPhasesReferences(pair.Key, pair.Value, -pair.Value.References);
                    suppressedPhaseShift.Phases.Remove(pair.Key);
                }
            }

            foreach (var pair in phaseShift.VisibleMapIds.ToList())
            {
                if (!Global.ConditionMgr.IsObjectMeetingNotGroupedConditions(ConditionSourceType.TerrainSwap, pair.Key, srcInfo))
                {
                    newSuppressions.AddVisibleMapId(pair.Key, pair.Value.VisibleMapInfo, pair.Value.References);
                    foreach (uint uiMapPhaseId in pair.Value.VisibleMapInfo.UiMapPhaseIDs)
                    {
                        changed = phaseShift.RemoveUiMapPhaseId(uiMapPhaseId) || changed;
                    }

                    phaseShift.VisibleMapIds.Remove(pair.Key);
                }
            }

            foreach (var pair in suppressedPhaseShift.VisibleMapIds.ToList())
            {
                if (Global.ConditionMgr.IsObjectMeetingNotGroupedConditions(ConditionSourceType.TerrainSwap, pair.Key, srcInfo))
                {
                    changed = phaseShift.AddVisibleMapId(pair.Key, pair.Value.VisibleMapInfo, pair.Value.References) || changed;
                    foreach (uint uiMapPhaseId in pair.Value.VisibleMapInfo.UiMapPhaseIDs)
                    {
                        changed = phaseShift.AddUiMapPhaseId(uiMapPhaseId) || changed;
                    }

                    suppressedPhaseShift.VisibleMapIds.Remove(pair.Key);
                }
            }

            Unit unit = obj.ToUnit();

            if (unit)
            {
                foreach (AuraEffect aurEff in unit.GetAuraEffectsByType(AuraType.Phase))
                {
                    uint phaseId = (uint)aurEff.GetMiscValueB();
                    // if condition was met previously there is nothing to erase
                    if (newSuppressions.RemovePhase(phaseId))
                    {
                        phaseShift.AddPhase(phaseId, GetPhaseFlags(phaseId), null);//todo needs checked
                    }
                }

                foreach (AuraEffect aurEff in unit.GetAuraEffectsByType(AuraType.PhaseGroup))
                {
                    var phasesInGroup = Global.DB2Mgr.GetPhasesForGroup((uint)aurEff.GetMiscValueB());
                    if (!phasesInGroup.Empty())
                    {
                        foreach (uint phaseId in phasesInGroup)
                        {
                            var eraseResult = newSuppressions.RemovePhase(phaseId);
                            // if condition was met previously there is nothing to erase
                            if (eraseResult)
                            {
                                phaseShift.AddPhase(phaseId, GetPhaseFlags(phaseId), null);
                            }
                        }
                    }
                }
            }

            changed = changed || !newSuppressions.Phases.Empty() || !newSuppressions.VisibleMapIds.Empty();
            foreach (var pair in newSuppressions.Phases)
            {
                suppressedPhaseShift.AddPhase(pair.Key, pair.Value.Flags, pair.Value.AreaConditions, pair.Value.References);
            }

            foreach (var pair in newSuppressions.VisibleMapIds)
            {
                suppressedPhaseShift.AddVisibleMapId(pair.Key, pair.Value.VisibleMapInfo, pair.Value.References);
            }

            if (unit)
            {
                if (changed)
                {
                    unit.OnPhaseChange();
                }

                ForAllControlled(unit, controlled =>
                {
                    InheritPhaseShift(controlled, unit);
                });

                if (changed)
                {
                    unit.RemoveNotOwnSingleTargetAuras(true);
                }
            }

            UpdateVisibilityIfNeeded(obj, true, changed);
        }