bad merge?

1 files changed, 773 insertions, 254 deletions

diff --git a/OpenSim/Region/CoreModules/Framework/EntityTransfer/EntityTransferModule.cs b/OpenSim/Region/CoreModules/Framework/EntityTransfer/EntityTransferModule.cs
index 4be19f0..7937383 100644
--- a/OpenSim/Region/CoreModules/Framework/EntityTransfer/EntityTransferModule.cs
+++ b/OpenSim/Region/CoreModules/Framework/EntityTransfer/EntityTransferModule.cs
@@ -154,12 +154,25 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
             // Add this agent in this region as a banned person
             public void Add(ulong pRegionHandle, UUID pAgentID)
             {
+<<<<<<< HEAD
                 if (!m_bannedRegions.TryGetValue(pAgentID, out m_idCache))
                 {
                     m_idCache = new ExpiringCache<ulong, DateTime>();
                     m_bannedRegions.Add(pAgentID, m_idCache, TimeSpan.FromSeconds(45));
                 }
                 m_idCache.Add(pRegionHandle, DateTime.Now + TimeSpan.FromSeconds(15), TimeSpan.FromSeconds(15));
+=======
+                this.Add(pRegionHandle, pAgentID, 45, 15);
+            }
+            public void Add(ulong pRegionHandle, UUID pAgentID, double newTime, double extendTime)
+            {
+                if (!m_bannedRegions.TryGetValue(pAgentID, out m_idCache))
+                {
+                    m_idCache = new ExpiringCache<ulong, DateTime>();
+                    m_bannedRegions.Add(pAgentID, m_idCache, TimeSpan.FromSeconds(newTime));
+                }
+                m_idCache.Add(pRegionHandle, DateTime.Now + TimeSpan.FromSeconds(extendTime), TimeSpan.FromSeconds(extendTime));
+>>>>>>> avn/ubitvar
             }
             // Remove the agent from the region's banned list
             public void Remove(ulong pRegionHandle, UUID pAgentID)
@@ -209,6 +222,7 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
         {
             string transferVersionName = "SIMULATION";
             float maxTransferVersion = 0.3f;
+<<<<<<< HEAD
 
             IConfig hypergridConfig = source.Configs["Hypergrid"];
             if (hypergridConfig != null)
@@ -221,6 +235,8 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                 if (m_GatekeeperURI != string.Empty && !m_GatekeeperURI.EndsWith("/"))
                     m_GatekeeperURI += '/';
             }
+=======
+>>>>>>> avn/ubitvar
 
             IConfig transferConfig = source.Configs["EntityTransfer"];
             if (transferConfig != null)
@@ -491,16 +507,23 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
             }
 
             // TODO: Get proper AVG Height
-            float localAVHeight = 1.56f;
+            float localHalfAVHeight = 0.8f;
+            if (sp.Appearance != null)
+                localHalfAVHeight = sp.Appearance.AvatarHeight / 2;
+
             float posZLimit = 22;
 
             // TODO: Check other Scene HeightField
             posZLimit = (float)sp.Scene.Heightmap[(int)position.X, (int)position.Y];
+<<<<<<< HEAD
+=======
+
+            posZLimit += localHalfAVHeight + 0.1f;
+>>>>>>> avn/ubitvar
 
-            float newPosZ = posZLimit + localAVHeight;
-            if (posZLimit >= (position.Z - (localAVHeight / 2)) && !(Single.IsInfinity(newPosZ) || Single.IsNaN(newPosZ)))
+            if ((position.Z < posZLimit) && !(Single.IsInfinity(posZLimit) || Single.IsNaN(posZLimit)))
             {
-                position.Z = newPosZ;
+                position.Z = posZLimit;
             }
 
             if (sp.Flying)
@@ -599,9 +622,15 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                 Util.RegionHandleToRegionLoc(regionHandle, out regX, out regY);
 
                 MapBlockData block = new MapBlockData();
+<<<<<<< HEAD
                 block.X = (ushort)regX;
                 block.Y = (ushort)regY;
                 block.Access = (byte)SimAccess.Down;
+=======
+                block.X = (ushort)(regX);
+                block.Y = (ushort)(regY);
+                block.Access = (byte)SimAccess.Down; // == not there
+>>>>>>> avn/ubitvar
 
                 List<MapBlockData> blocks = new List<MapBlockData>();
                 blocks.Add(block);
@@ -736,10 +765,13 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                 return;
             }
 
+<<<<<<< HEAD
             uint newRegionX, newRegionY, oldRegionX, oldRegionY;
             Util.RegionHandleToRegionLoc(reg.RegionHandle, out newRegionX, out newRegionY);
             Util.RegionHandleToRegionLoc(sp.Scene.RegionInfo.RegionHandle, out oldRegionX, out oldRegionY);
 
+=======
+>>>>>>> avn/ubitvar
             ulong destinationHandle = finalDestination.RegionHandle;
 
             // Let's do DNS resolution only once in this process, please!
@@ -762,7 +794,11 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
             string version;
             string myversion = string.Format("{0}/{1}", OutgoingTransferVersionName, MaxOutgoingTransferVersion);
             if (!Scene.SimulationService.QueryAccess(
+<<<<<<< HEAD
                 finalDestination, sp.ControllingClient.AgentId, homeURI, true, position, myversion, sp.Scene.GetFormatsOffered(), out version, out reason))
+=======
+                 finalDestination, sp.ControllingClient.AgentId, homeURI, true, position, myversion, out version, out reason))
+>>>>>>> avn/ubitvar
             {
                 sp.ControllingClient.SendTeleportFailed(reason);
 
@@ -808,7 +844,12 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
             AgentCircuitData agentCircuit = sp.ControllingClient.RequestClientInfo();
             agentCircuit.startpos = position;
             agentCircuit.child = true;
-            agentCircuit.Appearance = sp.Appearance;
+            
+//            agentCircuit.Appearance = sp.Appearance;
+//            agentCircuit.Appearance = new AvatarAppearance(sp.Appearance, true, false);
+            agentCircuit.Appearance = new AvatarAppearance();
+            agentCircuit.Appearance.AvatarHeight = sp.Appearance.AvatarHeight;
+
             if (currentAgentCircuit != null)
             {
                 agentCircuit.ServiceURLs = currentAgentCircuit.ServiceURLs;
@@ -819,14 +860,48 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                 agentCircuit.Id0 = currentAgentCircuit.Id0;
             }
 
+<<<<<<< HEAD
             // if (NeedsNewAgent(sp.DrawDistance, oldRegionX, newRegionX, oldRegionY, newRegionY))
             float dist = (float)Math.Max(sp.Scene.DefaultDrawDistance,
                 (float)Math.Max(sp.Scene.RegionInfo.RegionSizeX, sp.Scene.RegionInfo.RegionSizeY));
             if (NeedsNewAgent(dist, oldRegionX, newRegionX, oldRegionY, newRegionY))
+=======
+            IClientIPEndpoint ipepClient;
+       
+            uint newRegionX, newRegionY, oldRegionX, oldRegionY;
+            Util.RegionHandleToRegionLoc(destinationHandle, out newRegionX, out newRegionY);
+            Util.RegionHandleToRegionLoc(sourceRegion.RegionHandle, out oldRegionX, out oldRegionY);
+            int oldSizeX = (int)sourceRegion.RegionSizeX;
+            int oldSizeY = (int)sourceRegion.RegionSizeY;
+            int newSizeX = finalDestination.RegionSizeX;
+            int newSizeY = finalDestination.RegionSizeY;
+
+            bool OutSideViewRange = NeedsNewAgent(sp.DrawDistance, oldRegionX, newRegionX, oldRegionY, newRegionY,
+                oldSizeX, oldSizeY, newSizeX, newSizeY);
+
+            if (OutSideViewRange)
+>>>>>>> avn/ubitvar
             {
-                // brand new agent, let's create a new caps seed
+                m_log.DebugFormat(
+                    "[ENTITY TRANSFER MODULE]: Determined that region {0} at {1},{2} needs new child agent for agent {3} from {4}",
+                    finalDestination.RegionName, newRegionX, newRegionY, sp.Name, Scene.Name);
+
+                //sp.ControllingClient.SendTeleportProgress(teleportFlags, "Creating agent...");
+                #region IP Translation for NAT
+                // Uses ipepClient above
+                if (sp.ClientView.TryGet(out ipepClient))
+                {
+                    endPoint.Address = NetworkUtil.GetIPFor(ipepClient.EndPoint, endPoint.Address);
+                }
+                #endregion
                 agentCircuit.CapsPath = CapsUtil.GetRandomCapsObjectPath();
             }
+            else
+            {
+                agentCircuit.CapsPath = sp.Scene.CapsModule.GetChildSeed(sp.UUID, reg.RegionHandle);
+                if (agentCircuit.CapsPath == null)
+                    agentCircuit.CapsPath = CapsUtil.GetRandomCapsObjectPath();
+            }
 
             // We're going to fallback to V1 if the destination gives us anything smaller than 0.2 or we're forcing
             // use of the earlier protocol
@@ -836,13 +911,17 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                 float.TryParse(versionComponents[1], out versionNumber);
 
             if (versionNumber >= 0.2f && MaxOutgoingTransferVersion >= versionNumber)
+<<<<<<< HEAD
                 TransferAgent_V2(sp, agentCircuit, reg, finalDestination, endPoint, teleportFlags, oldRegionX, newRegionX, oldRegionY, newRegionY, version, out reason);
+=======
+                TransferAgent_V2(sp, agentCircuit, reg, finalDestination, endPoint, teleportFlags, OutSideViewRange , version, out reason);
+>>>>>>> avn/ubitvar
             else
-                TransferAgent_V1(sp, agentCircuit, reg, finalDestination, endPoint, teleportFlags, oldRegionX, newRegionX, oldRegionY, newRegionY, version, out reason);           
+                TransferAgent_V1(sp, agentCircuit, reg, finalDestination, endPoint, teleportFlags, OutSideViewRange, version, out reason);           
         }
 
         private void TransferAgent_V1(ScenePresence sp, AgentCircuitData agentCircuit, GridRegion reg, GridRegion finalDestination,
-            IPEndPoint endPoint, uint teleportFlags, uint oldRegionX, uint newRegionX, uint oldRegionY, uint newRegionY, string version, out string reason)
+            IPEndPoint endPoint, uint teleportFlags, bool OutSideViewRange, string version, out string reason)
         {
             ulong destinationHandle = finalDestination.RegionHandle;
             AgentCircuitData currentAgentCircuit = sp.Scene.AuthenticateHandler.GetAgentCircuitData(sp.ControllingClient.CircuitCode);
@@ -851,6 +930,8 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                 "[ENTITY TRANSFER MODULE]: Using TP V1 for {0} going from {1} to {2}", 
                 sp.Name, Scene.Name, finalDestination.RegionName);
 
+            string capsPath = finalDestination.ServerURI + CapsUtil.GetCapsSeedPath(agentCircuit.CapsPath);
+
             // Let's create an agent there if one doesn't exist yet. 
             // NOTE: logout will always be false for a non-HG teleport.
             bool logout = false;
@@ -892,6 +973,7 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
             m_entityTransferStateMachine.UpdateInTransit(sp.UUID, AgentTransferState.Transferring);
 
             // OK, it got this agent. Let's close some child agents
+<<<<<<< HEAD
             sp.CloseChildAgents(newRegionX, newRegionY);
 
             IClientIPEndpoint ipepClient;
@@ -903,17 +985,12 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                 m_log.DebugFormat(
                     "[ENTITY TRANSFER MODULE]: Determined that region {0} at {1},{2} needs new child agent for incoming agent {3} from {4}",
                     finalDestination.RegionName, newRegionX, newRegionY, sp.Name, Scene.Name);
+=======
+>>>>>>> avn/ubitvar
 
-                //sp.ControllingClient.SendTeleportProgress(teleportFlags, "Creating agent...");
-                #region IP Translation for NAT
-                // Uses ipepClient above
-                if (sp.ClientView.TryGet(out ipepClient))
-                {
-                    endPoint.Address = NetworkUtil.GetIPFor(ipepClient.EndPoint, endPoint.Address);
-                }
-                #endregion
-                capsPath = finalDestination.ServerURI + CapsUtil.GetCapsSeedPath(agentCircuit.CapsPath);
 
+            if (OutSideViewRange)
+            {
                 if (m_eqModule != null)
                 {
                     // The EnableSimulator message makes the client establish a connection with the destination
@@ -943,15 +1020,14 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                     sp.ControllingClient.InformClientOfNeighbour(destinationHandle, endPoint);
                 }
             }
-            else
-            {
-                agentCircuit.CapsPath = sp.Scene.CapsModule.GetChildSeed(sp.UUID, reg.RegionHandle);
-                capsPath = finalDestination.ServerURI + CapsUtil.GetCapsSeedPath(agentCircuit.CapsPath);
-            }
 
             // Let's send a full update of the agent. This is a synchronous call.
             AgentData agent = new AgentData();
             sp.CopyTo(agent);
+
+            if ((teleportFlags & (uint)TeleportFlags.IsFlying) != 0)
+                agent.ControlFlags |= (uint)AgentManager.ControlFlags.AGENT_CONTROL_FLY;
+
             agent.Position = agentCircuit.startpos;
             SetCallbackURL(agent, sp.Scene.RegionInfo);
 
@@ -1053,7 +1129,6 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                 return;
             }
 
-            m_entityTransferStateMachine.UpdateInTransit(sp.UUID, AgentTransferState.CleaningUp);
 
             // For backwards compatibility
             if (version == "Unknown" || version == string.Empty)
@@ -1063,18 +1138,30 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                 CrossAttachmentsIntoNewRegion(finalDestination, sp, true);
             }
 
+            m_entityTransferStateMachine.UpdateInTransit(sp.UUID, AgentTransferState.CleaningUp);
+
+
             // May need to logout or other cleanup
-            AgentHasMovedAway(sp, logout);
+//            AgentHasMovedAway(sp, logout);
+//            AgentHasMovedAway(sp, true); // until logout use is checked
 
             // Well, this is it. The agent is over there.
-            KillEntity(sp.Scene, sp.LocalId);
+//            KillEntity(sp.Scene, sp.LocalId);
+
+            sp.HasMovedAway(!OutSideViewRange);
+
+            sp.CloseChildAgents(destinationHandle,finalDestination.RegionSizeX,finalDestination.RegionSizeY);
 
             // Now let's make it officially a child agent
-            sp.MakeChildAgent();
+            sp.MakeChildAgent(destinationHandle);
 
             // Finally, let's close this previously-known-as-root agent, when the jump is outside the view zone
 
+<<<<<<< HEAD
             if (NeedsClosing(sp.Scene.DefaultDrawDistance, oldRegionX, newRegionX, oldRegionY, newRegionY, reg))
+=======
+            if (OutSideViewRange)
+>>>>>>> avn/ubitvar
             {
                 if (!sp.Scene.IncomingPreCloseClient(sp))
                     return;
@@ -1089,19 +1176,16 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
 
                 sp.Scene.CloseAgent(sp.UUID, false);
             }
-            else
-            {
-                // now we have a child agent in this region. 
-                sp.Reset();
-            }
         }
 
         private void TransferAgent_V2(ScenePresence sp, AgentCircuitData agentCircuit, GridRegion reg, GridRegion finalDestination,
-            IPEndPoint endPoint, uint teleportFlags, uint oldRegionX, uint newRegionX, uint oldRegionY, uint newRegionY, string version, out string reason)
+            IPEndPoint endPoint, uint teleportFlags, bool OutSideViewRange, string version, out string reason)
         {
             ulong destinationHandle = finalDestination.RegionHandle;
             AgentCircuitData currentAgentCircuit = sp.Scene.AuthenticateHandler.GetAgentCircuitData(sp.ControllingClient.CircuitCode);
 
+            string capsPath = finalDestination.ServerURI + CapsUtil.GetCapsSeedPath(agentCircuit.CapsPath);;
+
             // Let's create an agent there if one doesn't exist yet. 
             // NOTE: logout will always be false for a non-HG teleport.
             bool logout = false;
@@ -1142,6 +1226,7 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
             // Past this point we have to attempt clean up if the teleport fails, so update transfer state.
             m_entityTransferStateMachine.UpdateInTransit(sp.UUID, AgentTransferState.Transferring);
 
+<<<<<<< HEAD
             IClientIPEndpoint ipepClient;
             string capsPath = String.Empty;
             float dist = (float)Math.Max(sp.Scene.DefaultDrawDistance, 
@@ -1168,6 +1253,8 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                 capsPath = finalDestination.ServerURI + CapsUtil.GetCapsSeedPath(agentCircuit.CapsPath);
             }
 
+=======
+>>>>>>> avn/ubitvar
             // We need to set this here to avoid an unlikely race condition when teleporting to a neighbour simulator,
             // where that neighbour simulator could otherwise request a child agent create on the source which then 
             // closes our existing agent which is still signalled as root.
@@ -1189,6 +1276,10 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
             AgentData agent = new AgentData();
             sp.CopyTo(agent);
             agent.Position = agentCircuit.startpos;
+
+            if ((teleportFlags & (uint)TeleportFlags.IsFlying) != 0)
+                agent.ControlFlags |= (uint)AgentManager.ControlFlags.AGENT_CONTROL_FLY;
+
             agent.SenderWantsToWaitForRoot = true;
             //SetCallbackURL(agent, sp.Scene.RegionInfo);
 
@@ -1224,25 +1315,29 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
             
             m_entityTransferStateMachine.UpdateInTransit(sp.UUID, AgentTransferState.CleaningUp);
 
+            sp.HasMovedAway(!OutSideViewRange);
+
             // Need to signal neighbours whether child agents may need closing irrespective of whether this
             // one needed closing.  We also need to close child agents as quickly as possible to avoid complicated
             // race conditions with rapid agent releporting (e.g. from A1 to a non-neighbour B, back
             // to a neighbour A2 then off to a non-neighbour C).  Closing child agents any later requires complex
             // distributed checks to avoid problems in rapid reteleporting scenarios and where child agents are
             // abandoned without proper close by viewer but then re-used by an incoming connection.
-            sp.CloseChildAgents(newRegionX, newRegionY);
-
-            // May need to logout or other cleanup
-            AgentHasMovedAway(sp, logout);
+            sp.CloseChildAgents(destinationHandle, finalDestination.RegionSizeX, finalDestination.RegionSizeY);
 
+//            AgentHasMovedAway(sp, true);
             // Well, this is it. The agent is over there.
-            KillEntity(sp.Scene, sp.LocalId);
+//            KillEntity(sp.Scene, sp.LocalId);
 
             // Now let's make it officially a child agent
-            sp.MakeChildAgent();
+            sp.MakeChildAgent(destinationHandle);
 
             // Finally, let's close this previously-known-as-root agent, when the jump is outside the view zone
+<<<<<<< HEAD
             if (NeedsClosing(sp.Scene.DefaultDrawDistance, oldRegionX, newRegionX, oldRegionY, newRegionY, reg))
+=======
+            if (OutSideViewRange)
+>>>>>>> avn/ubitvar
             {
                 if (!sp.Scene.IncomingPreCloseClient(sp))
                     return;
@@ -1263,11 +1358,13 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
 
                 sp.Scene.CloseAgent(sp.UUID, false);
             }
+/*
             else
             {
                 // now we have a child agent in this region. 
                 sp.Reset();
             }
+ */
         }
 
         /// <summary>
@@ -1351,7 +1448,7 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
         protected virtual void AgentHasMovedAway(ScenePresence sp, bool logout)
         {
             if (sp.Scene.AttachmentsModule != null)
-                sp.Scene.AttachmentsModule.DeleteAttachmentsFromScene(sp, true);
+                sp.Scene.AttachmentsModule.DeleteAttachmentsFromScene(sp, logout);
         }
 
         protected void KillEntity(Scene scene, uint localID)
@@ -1368,7 +1465,12 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
         // This returns 'true' if the new region already has a child agent for our
         //    incoming agent. The implication is that, if 'false', we have to create  the
         //    child and then teleport into the region.
+<<<<<<< HEAD
         protected virtual bool NeedsNewAgent(float drawdist, uint oldRegionX, uint newRegionX, uint oldRegionY, uint newRegionY)
+=======
+        protected virtual bool NeedsNewAgent(float drawdist, uint oldRegionX, uint newRegionX, uint oldRegionY, uint newRegionY,
+            int oldsizeX, int oldsizeY, int newsizeX, int newsizeY)
+>>>>>>> avn/ubitvar
         {
             if (m_regionCombinerModule != null && m_regionCombinerModule.IsRootForMegaregion(Scene.RegionInfo.RegionID))
             {
@@ -1381,17 +1483,23 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
 
                 return !(newRegionX >= swCorner.X && newRegionX <= neCorner.X && newRegionY >= swCorner.Y && newRegionY <= neCorner.Y);
             }
-            else
-            {
-                return Util.IsOutsideView(drawdist, oldRegionX, newRegionX, oldRegionY, newRegionY);
-            }
+
+            return Util.IsOutsideView(drawdist, oldRegionX, newRegionX, oldRegionY, newRegionY,
+                    oldsizeX, oldsizeY, newsizeX, newsizeY);
         }
+<<<<<<< HEAD
 
-        protected virtual bool NeedsClosing(float drawdist, uint oldRegionX, uint newRegionX, uint oldRegionY, uint newRegionY, GridRegion reg)
+=======
+/*
+        protected virtual bool NeedsClosing(float drawdist, uint oldRegionX, uint newRegionX, uint oldRegionY, uint newRegionY,
+            uint oldsizeX, uint oldsizeY, uint newsizeX, uint newsizeY, GridRegion reg)
         {
-            return Util.IsOutsideView(drawdist, oldRegionX, newRegionX, oldRegionY, newRegionY);
-        }
 
+            return Util.IsOutsideView(drawdist, oldRegionX, newRegionX, oldRegionY, newRegionY,
+                oldsizeX, oldsizeY, newsizeX, newsizeY);
+        }
+*/
+>>>>>>> avn/ubitvar
         #endregion
 
         #region Landmark Teleport
@@ -1472,14 +1580,20 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
 
         #region Agent Crossings
 
+<<<<<<< HEAD
         // Given a position relative to the current region (which has previously been tested to
         //    see that it is actually outside the current region), find the new region that the
         //    point is actually in.
         // Returns the coordinates and information of the new region or 'null' of it doesn't exist.
         public GridRegion GetDestination(Scene scene, UUID agentID, Vector3 pos,
                                             out string version, out Vector3 newpos, out string failureReason)
+=======
+        public bool checkAgentAccessToRegion(ScenePresence agent, GridRegion destiny, Vector3 position, out string version, out string reason)
+>>>>>>> avn/ubitvar
         {
+            reason = String.Empty;
             version = String.Empty;
+<<<<<<< HEAD
             newpos = pos;
             failureReason = string.Empty;
             string homeURI = scene.GetAgentHomeURI(agentID);
@@ -1541,32 +1655,180 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                     LogHeader, neighbourRegion.RegionName,
                     neighbourRegion.RegionLocX, neighbourRegion.RegionLocY, neighbourRegion.RegionSizeX, neighbourRegion.RegionSizeY,
                     newpos.X, newpos.Y);
+=======
+
+            UUID agentID = agent.UUID;
+            ulong destinyHandle = destiny.RegionHandle;
+
+            if (m_bannedRegionCache.IfBanned(destinyHandle, agentID))
+            {
+                reason = "Cannot connect to region";
+                return false;
+            }
+
+            Scene ascene = agent.Scene;
+            string homeURI = ascene.GetAgentHomeURI(agentID);
+            string myversion = string.Format("{0}/{1}", OutgoingTransferVersionName, MaxOutgoingTransferVersion);
+
+
+            if (!ascene.SimulationService.QueryAccess(destiny, agentID, homeURI, false, position,
+                    myversion, out version, out reason))
+            {
+                m_bannedRegionCache.Add(destinyHandle, agentID, 30.0, 30.0);
+                return false;
+            }
+
+            return true;
+        }
+
+        public GridRegion GetDestination(Scene scene, UUID agentID, Vector3 pos, out string version, out Vector3 newpos)
+        {
+            string r = String.Empty;
+            return GetDestination(scene, agentID, pos, out version, out newpos, out r);
+        }
+
+        // Given a position relative to the current region (which has previously been tested to
+        //    see that it is actually outside the current region), find the new region that the
+        //    point is actually in.
+        // Returns the coordinates and information of the new region or 'null' of it doesn't exist.
+
+        // now only works for crossings
+
+        public GridRegion GetDestination(Scene scene, UUID agentID, Vector3 pos,
+                                            out string version, out Vector3 newpos, out string failureReason)
+        {
+            version = String.Empty;
+            newpos = pos;
+            failureReason = string.Empty;
+
+//            m_log.DebugFormat(
+//                "[ENTITY TRANSFER MODULE]: Crossing agent {0} at pos {1} in {2}", agent.Name, pos, scene.Name);
+
+            // Compute world location of the object's position
+            double presenceWorldX = (double)scene.RegionInfo.WorldLocX + pos.X;
+            double presenceWorldY = (double)scene.RegionInfo.WorldLocY + pos.Y;
+
+            // Call the grid service to lookup the region containing the new position.
+            GridRegion neighbourRegion = GetRegionContainingWorldLocation(scene.GridService, scene.RegionInfo.ScopeID,
+                                                        presenceWorldX, presenceWorldY, 
+                                                        Math.Max(scene.RegionInfo.RegionSizeX, scene.RegionInfo.RegionSizeY));
+
+            if (neighbourRegion != null)
+            {
+                // Compute the entity's position relative to the new region
+                newpos = new Vector3((float)(presenceWorldX - (double)neighbourRegion.RegionLocX),
+                                      (float)(presenceWorldY - (double)neighbourRegion.RegionLocY),
+                                      pos.Z);
+
+                if (m_bannedRegionCache.IfBanned(neighbourRegion.RegionHandle, agentID))
+                {
+                    failureReason = "Cannot region cross into banned parcel";
+                    neighbourRegion = null;
+                }
+                else
+                {
+                    // If not banned, make sure this agent is not in the list.
+                    m_bannedRegionCache.Remove(neighbourRegion.RegionHandle, agentID);
+                }
+
+                // Check to see if we have access to the target region.
+                string myversion = string.Format("{0}/{1}", OutgoingTransferVersionName, MaxOutgoingTransferVersion);
+                string homeURI = scene.GetAgentHomeURI(agentID);
+                if (neighbourRegion != null
+                    && !scene.SimulationService.QueryAccess(neighbourRegion, agentID, homeURI, false, newpos, myversion, out version, out failureReason))
+                {
+                    // remember banned
+                    m_bannedRegionCache.Add(neighbourRegion.RegionHandle, agentID);
+                    neighbourRegion = null;
+                }
+            }
+            else
+            {
+                // The destination region just doesn't exist
+                failureReason = "Cannot cross into non-existent region";
+            }
+>>>>>>> avn/ubitvar
+
+            if (neighbourRegion == null)
+                m_log.DebugFormat("{0} GetDestination: region not found. Old region name={1} at <{2},{3}> of size <{4},{5}>. Old pos={6}",
+                    LogHeader, scene.RegionInfo.RegionName,
+                    scene.RegionInfo.RegionLocX, scene.RegionInfo.RegionLocY,
+                    scene.RegionInfo.RegionSizeX, scene.RegionInfo.RegionSizeY,
+                    pos);
+            else
+                m_log.DebugFormat("{0} GetDestination: new region={1} at <{2},{3}> of size <{4},{5}>, newpos=<{6},{7}>",
+                    LogHeader, neighbourRegion.RegionName,
+                    neighbourRegion.RegionLocX, neighbourRegion.RegionLocY, neighbourRegion.RegionSizeX, neighbourRegion.RegionSizeY,
+                    newpos.X, newpos.Y);
 
             return neighbourRegion;
         }
 
         public bool Cross(ScenePresence agent, bool isFlying)
         {
+<<<<<<< HEAD
+=======
+            agent.IsInTransit = true;
+            CrossAsyncDelegate d = CrossAsync;
+            d.BeginInvoke(agent, isFlying, CrossCompleted, d);
+            return true;
+        }
+
+        private void CrossCompleted(IAsyncResult iar)
+        {
+            CrossAsyncDelegate icon = (CrossAsyncDelegate)iar.AsyncState;
+            ScenePresence agent = icon.EndInvoke(iar);
+
+            m_log.DebugFormat("[ENTITY TRANSFER MODULE]: Crossing agent {0} {1} completed.", agent.Firstname, agent.Lastname);
+
+            if(!agent.IsChildAgent)
+            {
+                // crossing failed
+                agent.CrossToNewRegionFail();
+            }
+            agent.IsInTransit = false;
+        }
+
+        public ScenePresence CrossAsync(ScenePresence agent, bool isFlying)
+        {
+            uint x;
+            uint y;
+>>>>>>> avn/ubitvar
             Vector3 newpos;
             string version;
             string failureReason;
 
+<<<<<<< HEAD
             GridRegion neighbourRegion = GetDestination(agent.Scene, agent.UUID, agent.AbsolutePosition,
                                                             out version, out newpos, out failureReason);
             if (neighbourRegion == null)
             {
                 agent.ControllingClient.SendAlertMessage(failureReason);
                 return false;
-            }
+=======
+            Vector3 pos = agent.AbsolutePosition + agent.Velocity;
 
-            agent.IsInTransit = true;
+            GridRegion neighbourRegion = GetDestination(agent.Scene, agent.UUID, pos,
+                                                            out version, out newpos, out failureReason);
+            if (neighbourRegion == null)
+            {
+                if (failureReason != String.Empty)
+                    agent.ControllingClient.SendAlertMessage(failureReason);
+                return agent;
+>>>>>>> avn/ubitvar
+            }
 
-            CrossAgentToNewRegionDelegate d = CrossAgentToNewRegionAsync;
-            d.BeginInvoke(agent, newpos, neighbourRegion, isFlying, version, CrossAgentToNewRegionCompleted, d);
+//            agent.IsInTransit = true;
 
+<<<<<<< HEAD
             Scene.EventManager.TriggerCrossAgentToNewRegion(agent, isFlying, neighbourRegion);
 
             return true;
+=======
+            CrossAgentToNewRegionAsync(agent, newpos, neighbourRegion, isFlying, version);
+            agent.IsInTransit = false;
+            return agent;
+>>>>>>> avn/ubitvar
         }
 
 
@@ -1691,12 +1953,23 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
 
         public bool CrossAgentIntoNewRegionMain(ScenePresence agent, Vector3 pos, GridRegion neighbourRegion, bool isFlying)
         {
+            int ts = Util.EnvironmentTickCount();
             try
             {
                 AgentData cAgent = new AgentData(); 
                 agent.CopyTo(cAgent);
+<<<<<<< HEAD
                 cAgent.Position = pos;
 
+=======
+
+//                agent.Appearance.WearableCacheItems = null;
+
+                cAgent.Position = pos;
+
+                cAgent.ChildrenCapSeeds = agent.KnownRegions;
+
+>>>>>>> avn/ubitvar
                 if (isFlying)
                     cAgent.ControlFlags |= (uint)AgentManager.ControlFlags.AGENT_CONTROL_FLY;
 
@@ -1716,11 +1989,14 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                         neighbourRegion.RegionName, agent.Name);
 
                     ReInstantiateScripts(agent);
-                    agent.AddToPhysicalScene(isFlying);
+                    if(agent.ParentID == 0 && agent.ParentUUID == UUID.Zero)
+                        agent.AddToPhysicalScene(isFlying);
 
                     return false;
                 }
 
+            m_log.DebugFormat("[CrossAgentIntoNewRegionMain] ok, time {0}ms",Util.EnvironmentTickCountSubtract(ts));
+
             }
             catch (Exception e)
             {
@@ -1738,7 +2014,6 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
         public void CrossAgentToNewRegionPost(ScenePresence agent, Vector3 pos, GridRegion neighbourRegion,
             bool isFlying, string version)
         {
-            agent.ControllingClient.RequestClientInfo();
 
             string agentcaps;
             if (!agent.KnownRegions.TryGetValue(neighbourRegion.RegionHandle, out agentcaps))
@@ -1749,6 +2024,7 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
             }
 
             // No turning back
+
             agent.IsChildAgent = true;
 
             string capsPath = neighbourRegion.ServerURI + CapsUtil.GetCapsSeedPath(agentcaps);
@@ -1760,7 +2036,7 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
             if (m_eqModule != null)
             {
                 m_eqModule.CrossRegion(
-                    neighbourRegion.RegionHandle, pos + agent.Velocity, vel2 /* agent.Velocity */,
+                    neighbourRegion.RegionHandle, pos, vel2 /* agent.Velocity */,
                     neighbourRegion.ExternalEndPoint,
                     capsPath, agent.UUID, agent.ControllingClient.SessionId,
                     neighbourRegion.RegionSizeX, neighbourRegion.RegionSizeY);
@@ -1768,10 +2044,11 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
             else
             {
                 m_log.ErrorFormat("{0} Using old CrossRegion packet. Varregion will not work!!", LogHeader);
-                agent.ControllingClient.CrossRegion(neighbourRegion.RegionHandle, pos + agent.Velocity, agent.Velocity, neighbourRegion.ExternalEndPoint,
+                agent.ControllingClient.CrossRegion(neighbourRegion.RegionHandle, pos, agent.Velocity, neighbourRegion.ExternalEndPoint,
                                             capsPath);
             }
 
+<<<<<<< HEAD
             // SUCCESS!
             m_entityTransferStateMachine.UpdateInTransit(agent.UUID, AgentTransferState.ReceivedAtDestination);
 
@@ -1788,6 +2065,8 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
             agent.SendOtherAgentsAvatarDataToClient();
             agent.SendOtherAgentsAppearanceToClient();
 
+=======
+>>>>>>> avn/ubitvar
             // Backwards compatibility. Best effort
             if (version == "Unknown" || version == string.Empty)
             {
@@ -1796,14 +2075,31 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                 CrossAttachmentsIntoNewRegion(neighbourRegion, agent, true);
             }
 
+<<<<<<< HEAD
             // Next, let's close the child agent connections that are too far away.
             uint neighbourx;
             uint neighboury;
             Util.RegionHandleToRegionLoc(neighbourRegion.RegionHandle, out neighbourx, out neighboury);
+=======
+            // SUCCESS!
+            m_entityTransferStateMachine.UpdateInTransit(agent.UUID, AgentTransferState.ReceivedAtDestination);
+
+            // Unlike a teleport, here we do not wait for the destination region to confirm the receipt.
+            m_entityTransferStateMachine.UpdateInTransit(agent.UUID, AgentTransferState.CleaningUp);
 
-            agent.CloseChildAgents(neighbourx, neighboury);
+            // this may need the attachments
+
+            agent.HasMovedAway(true);
+
+            agent.MakeChildAgent(neighbourRegion.RegionHandle);
+
+            // FIXME: Possibly this should occur lower down after other commands to close other agents,
+            // but not sure yet what the side effects would be.
+            m_entityTransferStateMachine.ResetFromTransit(agent.UUID);
+>>>>>>> avn/ubitvar
+
+            agent.CloseChildAgents(neighbourRegion.RegionHandle, neighbourRegion.RegionSizeX, neighbourRegion.RegionSizeY);
 
-            AgentHasMovedAway(agent, false);
 
             // the user may change their profile information in other region,
             // so the userinfo in UserProfileCache is not reliable any more, delete it
@@ -1843,7 +2139,7 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
         #region Enable Child Agent
 
         /// <summary>
-        /// This informs a single neighbouring region about agent "avatar".
+        /// This informs a single neighbouring region about agent "avatar", and avatar about it
         /// Calls an asynchronous method to do so..  so it doesn't lag the sim.
         /// </summary>
         /// <param name="sp"></param>
@@ -1852,22 +2148,36 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
         {
             m_log.DebugFormat("[ENTITY TRANSFER]: Enabling child agent in new neighbour {0}", region.RegionName);
 
+            ulong currentRegionHandler = sp.Scene.RegionInfo.RegionHandle;
+            ulong regionhandler = region.RegionHandle;
+
+            Dictionary<ulong, string> seeds = new Dictionary<ulong, string>(sp.Scene.CapsModule.GetChildrenSeeds(sp.UUID));
+
+            if (seeds.ContainsKey(regionhandler))
+                seeds.Remove(regionhandler);
+/*
+            List<ulong> oldregions = new List<ulong>(seeds.Keys);
+
+            if (oldregions.Contains(currentRegionHandler))
+                oldregions.Remove(currentRegionHandler);
+*/
+            if (!seeds.ContainsKey(currentRegionHandler))
+                seeds.Add(currentRegionHandler, sp.ControllingClient.RequestClientInfo().CapsPath);
+
             AgentCircuitData currentAgentCircuit = sp.Scene.AuthenticateHandler.GetAgentCircuitData(sp.ControllingClient.CircuitCode);
             AgentCircuitData agent = sp.ControllingClient.RequestClientInfo();
             agent.BaseFolder = UUID.Zero;
             agent.InventoryFolder = UUID.Zero;
-            agent.startpos = new Vector3(128, 128, 70);
+            agent.startpos = sp.AbsolutePosition + CalculateOffset(sp, region);
             agent.child = true;
-            agent.Appearance = sp.Appearance;
-            agent.CapsPath = CapsUtil.GetRandomCapsObjectPath();
+            agent.Appearance = new AvatarAppearance();
+            agent.Appearance.AvatarHeight = sp.Appearance.AvatarHeight;
 
-            agent.ChildrenCapSeeds = new Dictionary<ulong, string>(sp.Scene.CapsModule.GetChildrenSeeds(sp.UUID));
-            //m_log.DebugFormat("[XXX] Seeds 1 {0}", agent.ChildrenCapSeeds.Count);
+            agent.CapsPath = CapsUtil.GetRandomCapsObjectPath();
 
-            if (!agent.ChildrenCapSeeds.ContainsKey(sp.Scene.RegionInfo.RegionHandle))
-                agent.ChildrenCapSeeds.Add(sp.Scene.RegionInfo.RegionHandle, sp.ControllingClient.RequestClientInfo().CapsPath);
-            //m_log.DebugFormat("[XXX] Seeds 2 {0}", agent.ChildrenCapSeeds.Count);
+            seeds.Add(regionhandler, agent.CapsPath);
 
+<<<<<<< HEAD
             sp.AddNeighbourRegion(region.RegionHandle, agent.CapsPath);
             //foreach (ulong h in agent.ChildrenCapSeeds.Keys)
             //    m_log.DebugFormat("[XXX] --> {0}", h);
@@ -1881,12 +2191,19 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
             }
 
             agent.ChildrenCapSeeds[region.RegionHandle] = agent.CapsPath;
+=======
+//            agent.ChildrenCapSeeds = new Dictionary<ulong, string>(seeds);
+            agent.ChildrenCapSeeds = null;
+>>>>>>> avn/ubitvar
 
             if (sp.Scene.CapsModule != null)
             {
-                sp.Scene.CapsModule.SetChildrenSeed(sp.UUID, agent.ChildrenCapSeeds);
+                sp.Scene.CapsModule.SetChildrenSeed(sp.UUID, seeds);
             }
 
+            sp.KnownRegions = seeds;
+            sp.AddNeighbourRegionSizeInfo(region);
+
             if (currentAgentCircuit != null)
             {
                 agent.ServiceURLs = currentAgentCircuit.ServiceURLs;
@@ -1896,7 +2213,24 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                 agent.Mac = currentAgentCircuit.Mac;
                 agent.Id0 = currentAgentCircuit.Id0;
             }
-
+/*
+            AgentPosition agentpos = null;
+
+            if (oldregions.Count > 0)
+            {
+                agentpos = new AgentPosition();
+                agentpos.AgentID = new UUID(sp.UUID.Guid);
+                agentpos.SessionID = sp.ControllingClient.SessionId;
+                agentpos.Size = sp.Appearance.AvatarSize;
+                agentpos.Center = sp.CameraPosition;
+                agentpos.Far = sp.DrawDistance;
+                agentpos.Position = sp.AbsolutePosition;
+                agentpos.Velocity = sp.Velocity;
+                agentpos.RegionHandle = currentRegionHandler;
+                agentpos.Throttles = sp.ControllingClient.GetThrottlesPacked(1);
+                agentpos.ChildrenCapSeeds = seeds;
+            }
+*/
             IPEndPoint external = region.ExternalEndPoint;
             if (external != null)
             {
@@ -1905,7 +2239,23 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                           InformClientOfNeighbourCompleted,
                           d);
             }
+/*
+            if(oldregions.Count >0)
+            {
+                uint neighbourx;
+                uint neighboury;
+                UUID scope = sp.Scene.RegionInfo.ScopeID;
+                foreach (ulong handler in oldregions)
+                {
+                    // crap code
+                    Utils.LongToUInts(handler, out neighbourx, out neighboury);
+                    GridRegion neighbour = sp.Scene.GridService.GetRegionByPosition(scope, (int)neighbourx, (int)neighboury);
+                    sp.Scene.SimulationService.UpdateAgent(neighbour, agentpos);
+                }
+            }
+ */
         }
+
         #endregion
 
         #region Enable Child Agents
@@ -1915,146 +2265,157 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
 
         /// <summary>
         /// This informs all neighbouring regions about agent "avatar".
+        /// and as important informs the avatar about then
         /// </summary>
         /// <param name="sp"></param>
         public void EnableChildAgents(ScenePresence sp)
         {
+            // assumes that out of view range regions are disconnected by the previus region
+
             List<GridRegion> neighbours = new List<GridRegion>();
-            RegionInfo m_regionInfo = sp.Scene.RegionInfo;
+            Scene spScene = sp.Scene;
+            RegionInfo m_regionInfo = spScene.RegionInfo;
 
             if (m_regionInfo != null)
             {
+<<<<<<< HEAD
                 neighbours = GetNeighbours(sp, m_regionInfo.RegionLocX, m_regionInfo.RegionLocY);
+=======
+                neighbours = GetNeighbors(sp, m_regionInfo.RegionLocX, m_regionInfo.RegionLocY);
+>>>>>>> avn/ubitvar
             }
             else
             {
                 m_log.Debug("[ENTITY TRANSFER MODULE]: m_regionInfo was null in EnableChildAgents, is this a NPC?");
             }
 
-            /// We need to find the difference between the new regions where there are no child agents
-            /// and the regions where there are already child agents. We only send notification to the former.
-            List<ulong> neighbourHandles = NeighbourHandles(neighbours); // on this region
-            neighbourHandles.Add(sp.Scene.RegionInfo.RegionHandle);  // add this region too
-            List<ulong> previousRegionNeighbourHandles;
+            ulong currentRegionHandler = m_regionInfo.RegionHandle;
 
-            if (sp.Scene.CapsModule != null)
+            LinkedList<ulong> previousRegionNeighbourHandles;
+            Dictionary<ulong, string> seeds;
+            ICapabilitiesModule capsModule = spScene.CapsModule;
+
+            if (capsModule != null)
             {
-                previousRegionNeighbourHandles =
-                    new List<ulong>(sp.Scene.CapsModule.GetChildrenSeeds(sp.UUID).Keys);
+                seeds = new Dictionary<ulong, string>(capsModule.GetChildrenSeeds(sp.UUID));
+                previousRegionNeighbourHandles = new LinkedList<ulong>(seeds.Keys);
             }
             else
             {
-                previousRegionNeighbourHandles = new List<ulong>();
+                seeds = new Dictionary<ulong, string>();
+                previousRegionNeighbourHandles = new LinkedList<ulong>();
             }
 
-            List<ulong> newRegions = NewNeighbours(neighbourHandles, previousRegionNeighbourHandles);
-            List<ulong> oldRegions = OldNeighbours(neighbourHandles, previousRegionNeighbourHandles);
-
-//            Dump("Current Neighbors", neighbourHandles);
-//            Dump("Previous Neighbours", previousRegionNeighbourHandles);
-//            Dump("New Neighbours", newRegions);
-//            Dump("Old Neighbours", oldRegions);
+            IClientAPI spClient = sp.ControllingClient;
 
-            /// Update the scene presence's known regions here on this region
-            sp.DropOldNeighbours(oldRegions);
+            if (!seeds.ContainsKey(currentRegionHandler))
+                seeds.Add(currentRegionHandler, spClient.RequestClientInfo().CapsPath);
 
-            /// Collect as many seeds as possible
-            Dictionary<ulong, string> seeds;
-            if (sp.Scene.CapsModule != null)
-                seeds = new Dictionary<ulong, string>(sp.Scene.CapsModule.GetChildrenSeeds(sp.UUID));
-            else
-                seeds = new Dictionary<ulong, string>();
+            AgentCircuitData currentAgentCircuit =
+                spScene.AuthenticateHandler.GetAgentCircuitData(sp.ControllingClient.CircuitCode);
 
-            //m_log.Debug(" !!! No. of seeds: " + seeds.Count);
-            if (!seeds.ContainsKey(sp.Scene.RegionInfo.RegionHandle))
-                seeds.Add(sp.Scene.RegionInfo.RegionHandle, sp.ControllingClient.RequestClientInfo().CapsPath);
-
-            /// Create the necessary child agents
             List<AgentCircuitData> cagents = new List<AgentCircuitData>();
+            List<ulong> newneighbours = new List<ulong>();
+
             foreach (GridRegion neighbour in neighbours)
             {
-                if (neighbour.RegionHandle != sp.Scene.RegionInfo.RegionHandle)
+                ulong handler = neighbour.RegionHandle;
+
+                if (previousRegionNeighbourHandles.Contains(handler))
                 {
-                    AgentCircuitData currentAgentCircuit = sp.Scene.AuthenticateHandler.GetAgentCircuitData(sp.ControllingClient.CircuitCode);
-                    AgentCircuitData agent = sp.ControllingClient.RequestClientInfo();
-                    agent.BaseFolder = UUID.Zero;
-                    agent.InventoryFolder = UUID.Zero;
-                    agent.startpos = sp.AbsolutePosition + CalculateOffset(sp, neighbour);
-                    agent.child = true;
-                    agent.Appearance = sp.Appearance;
-                    if (currentAgentCircuit != null)
-                    {
-                        agent.ServiceURLs = currentAgentCircuit.ServiceURLs;
-                        agent.IPAddress = currentAgentCircuit.IPAddress;
-                        agent.Viewer = currentAgentCircuit.Viewer;
-                        agent.Channel = currentAgentCircuit.Channel;
-                        agent.Mac = currentAgentCircuit.Mac;
-                        agent.Id0 = currentAgentCircuit.Id0;
-                    }
+                    // agent already knows this region
+                    previousRegionNeighbourHandles.Remove(handler);
+                    continue;
+                }
 
-                    if (newRegions.Contains(neighbour.RegionHandle))
-                    {
-                        agent.CapsPath = CapsUtil.GetRandomCapsObjectPath();
-                        sp.AddNeighbourRegion(neighbour.RegionHandle, agent.CapsPath);
-                        seeds.Add(neighbour.RegionHandle, agent.CapsPath);
-                    }
-                    else
-                    {
-                        agent.CapsPath = sp.Scene.CapsModule.GetChildSeed(sp.UUID, neighbour.RegionHandle);
-                    }
+                if (handler == currentRegionHandler)
+                    continue;
 
-                    cagents.Add(agent);
+                // a new region to add
+                AgentCircuitData agent = spClient.RequestClientInfo();
+                agent.BaseFolder = UUID.Zero;
+                agent.InventoryFolder = UUID.Zero;
+                agent.startpos = sp.AbsolutePosition + CalculateOffset(sp, neighbour);
+                agent.child = true;
+                agent.Appearance = new AvatarAppearance();
+                agent.Appearance.AvatarHeight = sp.Appearance.AvatarHeight;
+
+                if (currentAgentCircuit != null)
+                {
+                    agent.ServiceURLs = currentAgentCircuit.ServiceURLs;
+                    agent.IPAddress = currentAgentCircuit.IPAddress;
+                    agent.Viewer = currentAgentCircuit.Viewer;
+                    agent.Channel = currentAgentCircuit.Channel;
+                    agent.Mac = currentAgentCircuit.Mac;
+                    agent.Id0 = currentAgentCircuit.Id0;
                 }
-            }
 
-            /// Update all child agent with everyone's seeds
-            foreach (AgentCircuitData a in cagents)
-            {
-                a.ChildrenCapSeeds = new Dictionary<ulong, string>(seeds);
-            }
+                newneighbours.Add(handler);
+                agent.CapsPath = CapsUtil.GetRandomCapsObjectPath();
+                seeds.Add(handler, agent.CapsPath);
 
-            if (sp.Scene.CapsModule != null)
-            {
-                sp.Scene.CapsModule.SetChildrenSeed(sp.UUID, seeds);
+                agent.ChildrenCapSeeds = null;
+                cagents.Add(agent);
             }
-            sp.KnownRegions = seeds;
-            //avatar.Scene.DumpChildrenSeeds(avatar.UUID);
-            //avatar.DumpKnownRegions();
 
-            bool newAgent = false;
-            int count = 0;
-            foreach (GridRegion neighbour in neighbours)
-            {
-                //m_log.WarnFormat("--> Going to send child agent to {0}", neighbour.RegionName);
-                // Don't do it if there's already an agent in that region
-                if (newRegions.Contains(neighbour.RegionHandle))
-                    newAgent = true;
-                else
-                    newAgent = false;
-//                    continue;
+            if (previousRegionNeighbourHandles.Contains(currentRegionHandler))
+                previousRegionNeighbourHandles.Remove(currentRegionHandler);
+
+            // previousRegionNeighbourHandles now contains regions to forget
+            foreach (ulong handler in previousRegionNeighbourHandles)
+                seeds.Remove(handler);
+
+            /// Update all child agent with everyone's seeds
+            //            foreach (AgentCircuitData a in cagents)
+            //                a.ChildrenCapSeeds = new Dictionary<ulong, string>(seeds);
+
+            if (capsModule != null)
+                capsModule.SetChildrenSeed(sp.UUID, seeds);
 
-                if (neighbour.RegionHandle != sp.Scene.RegionInfo.RegionHandle)
+            sp.KnownRegions = seeds;
+            sp.SetNeighbourRegionSizeInfo(neighbours);
+
+            AgentPosition agentpos = new AgentPosition();
+            agentpos.AgentID = new UUID(sp.UUID.Guid);
+            agentpos.SessionID = spClient.SessionId;
+            agentpos.Size = sp.Appearance.AvatarSize;
+            agentpos.Center = sp.CameraPosition;
+            agentpos.Far = sp.DrawDistance;
+            agentpos.Position = sp.AbsolutePosition;
+            agentpos.Velocity = sp.Velocity;
+            agentpos.RegionHandle = currentRegionHandler;
+            agentpos.Throttles = spClient.GetThrottlesPacked(1);
+            //            agentpos.ChildrenCapSeeds = seeds;
+
+            Util.FireAndForget(delegate
+            {
+                Thread.Sleep(200);  // the original delay that was at InformClientOfNeighbourAsync start
+                int count = 0;
+
+                foreach (GridRegion neighbour in neighbours)
                 {
+                    ulong handler = neighbour.RegionHandle;
                     try
                     {
-                        // Let's put this back at sync, so that it doesn't clog 
-                        // the network, especially for regions in the same physical server.
-                        // We're really not in a hurry here.
-                        InformClientOfNeighbourAsync(sp, cagents[count], neighbour, neighbour.ExternalEndPoint, newAgent);
-                        //InformClientOfNeighbourDelegate d = InformClientOfNeighbourAsync;
-                        //d.BeginInvoke(sp, cagents[count], neighbour, neighbour.ExternalEndPoint, newAgent,
-                        //              InformClientOfNeighbourCompleted,
-                        //              d);
+                        if (newneighbours.Contains(handler))
+                        {
+                            InformClientOfNeighbourAsync(sp, cagents[count], neighbour,
+                                neighbour.ExternalEndPoint, true);
+                            count++;
+                        }
+                        else if (!previousRegionNeighbourHandles.Contains(handler))
+                        {
+                            spScene.SimulationService.UpdateAgent(neighbour, agentpos);
+                        }
                     }
-
                     catch (ArgumentOutOfRangeException)
                     {
                         m_log.ErrorFormat(
                            "[ENTITY TRANSFER MODULE]: Neighbour Regions response included the current region in the neighbour list.  The following region will not display to the client: {0} for region {1} ({2}, {3}).",
                            neighbour.ExternalHostName,
-                           neighbour.RegionHandle,
-                           neighbour.RegionLocX,
-                           neighbour.RegionLocY);
+                            neighbour.RegionHandle,
+                        neighbour.RegionLocX,
+                       neighbour.RegionLocY);
                     }
                     catch (Exception e)
                     {
@@ -2071,13 +2432,106 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
 
                         // XXX: Well, decided to swallow the exception instead for now.  Let us see how that goes.
                         // throw e;
+                    }
+                }
+            });
+        }
+
+        // Computes the difference between two region bases.
+        // Returns a vector of world coordinates (meters) from base of first region to the second.
+        // The first region is the home region of the passed scene presence.
+        Vector3 CalculateOffset(ScenePresence sp, GridRegion neighbour)
+        {
+              return new Vector3(sp.Scene.RegionInfo.WorldLocX - neighbour.RegionLocX,
+                                sp.Scene.RegionInfo.WorldLocY - neighbour.RegionLocY,
+                                0f);
+        }
+
 
+        #region NotFoundLocationCache class
+        // A collection of not found locations to make future lookups 'not found' lookups quick.
+        // A simple expiring cache that keeps not found locations for some number of seconds.
+        // A 'not found' location is presumed to be anywhere in the minimum sized region that
+        //    contains that point. A conservitive estimate.
+        private class NotFoundLocationCache
+        {
+            private struct NotFoundLocation
+            {
+                public double minX, maxX, minY, maxY;
+                public DateTime expireTime;
+            }
+            private List<NotFoundLocation> m_notFoundLocations = new List<NotFoundLocation>();
+            public NotFoundLocationCache()
+            {
+            }
+            // Add an area to the list of 'not found' places. The area is the snapped region
+            //    area around the added point.
+            public void Add(double pX, double pY)
+            {
+                lock (m_notFoundLocations)
+                {
+                    if (!LockedContains(pX, pY))
+                    {
+                        NotFoundLocation nfl = new NotFoundLocation();
+                        // A not found location is not found for at least a whole region sized area
+                        nfl.minX = pX - (pX % (double)Constants.RegionSize);
+                        nfl.minY = pY - (pY % (double)Constants.RegionSize);
+                        nfl.maxX = nfl.minX + (double)Constants.RegionSize;
+                        nfl.maxY = nfl.minY + (double)Constants.RegionSize;
+                        nfl.expireTime = DateTime.Now + TimeSpan.FromSeconds(30);
+                        m_notFoundLocations.Add(nfl);
+                    }
+                }
+                
+            }
+            // Test to see of this point is in any of the 'not found' areas.
+            // Return 'true' if the point is found inside the 'not found' areas.
+            public bool Contains(double pX, double pY)
+            {
+                bool ret = false;
+                lock (m_notFoundLocations)
+                    ret = LockedContains(pX, pY);
+                return ret;
+            }
+            private bool LockedContains(double pX, double pY)
+            {
+                bool ret = false;
+                this.DoExpiration();
+                foreach (NotFoundLocation nfl in m_notFoundLocations)
+                {
+                    if (pX >= nfl.minX && pX < nfl.maxX && pY >= nfl.minY && pY < nfl.maxY)
+                    {
+                        ret = true;
+                        break;
                     }
                 }
-                count++;
+                return ret;
+            }
+            private void DoExpiration()
+            {
+                List<NotFoundLocation> m_toRemove = null;
+                DateTime now = DateTime.Now;
+                foreach (NotFoundLocation nfl in m_notFoundLocations)
+                {
+                    if (nfl.expireTime < now)
+                    {
+                        if (m_toRemove == null)
+                            m_toRemove = new List<NotFoundLocation>();
+                        m_toRemove.Add(nfl);
+                    }
+                }
+                if (m_toRemove != null)
+                {
+                    foreach (NotFoundLocation nfl in m_toRemove)
+                        m_notFoundLocations.Remove(nfl);
+                    m_toRemove.Clear();
+                }
             }
         }
+        #endregion // NotFoundLocationCache class
+        private NotFoundLocationCache m_notFoundLocationCache = new NotFoundLocationCache();
 
+<<<<<<< HEAD
         // Computes the difference between two region bases.
         // Returns a vector of world coordinates (meters) from base of first region to the second.
         // The first region is the home region of the passed scene presence.
@@ -2197,6 +2651,27 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                             double px, double py, uint pSizeHint)
         {
             m_log.DebugFormat("{0} GetRegionContainingWorldLocation: query, loc=<{1},{2}>", LogHeader, px, py);
+=======
+// needed for current OSG or old grid code
+ 
+        public GridRegion GetRegionContainingWorldLocation(IGridService pGridService, UUID pScopeID, double px, double py)
+        {
+            // Since we don't know how big the regions could be, we have to search a very large area
+            //    to find possible regions.
+            return GetRegionContainingWorldLocation(pGridService, pScopeID, px, py, Constants.MaximumRegionSize);
+        }
+ 
+        // Given a world position, get the GridRegion info for
+        //   the region containing that point.
+        // Someday this should be a method on GridService.
+        // 'pSizeHint' is the size of the source region but since the destination point can be anywhere
+        //     the size of the target region is unknown thus the search area might have to be very large.
+        // Return 'null' if no such region exists.
+        public GridRegion GetRegionContainingWorldLocation(IGridService pGridService, UUID pScopeID,
+                            double px, double py, uint pSizeHint)
+        {
+            m_log.DebugFormat("{0} GetRegionContainingWorldLocation: call, XY=<{1},{2}>", LogHeader, px, py);
+>>>>>>> avn/ubitvar
             GridRegion ret = null;
             const double fudge = 2.0;
 
@@ -2289,55 +2764,71 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
         private void InformClientOfNeighbourAsync(ScenePresence sp, AgentCircuitData a, GridRegion reg,
                                                   IPEndPoint endPoint, bool newAgent)
         {
-            // Let's wait just a little to give time to originating regions to catch up with closing child agents
-            // after a cross here
-            Thread.Sleep(500);
 
+<<<<<<< HEAD
             Scene scene = sp.Scene;
             
             m_log.DebugFormat(
                 "[ENTITY TRANSFER MODULE]: Informing {0} {1} about neighbour {2} {3} at ({4},{5})",
                 sp.Name, sp.UUID, reg.RegionName, endPoint, reg.RegionCoordX, reg.RegionCoordY);
+=======
+            if (newAgent)
+            {
+                Scene scene = sp.Scene;
+
+                m_log.DebugFormat(
+                    "[ENTITY TRANSFER MODULE]: Informing {0} {1} about neighbour {2} {3} at ({4},{5})",
+                    sp.Name, sp.UUID, reg.RegionName, endPoint, reg.RegionCoordX, reg.RegionCoordY);
+>>>>>>> avn/ubitvar
 
-            string capsPath = reg.ServerURI + CapsUtil.GetCapsSeedPath(a.CapsPath);
+                string capsPath = reg.ServerURI + CapsUtil.GetCapsSeedPath(a.CapsPath);
 
-            string reason = String.Empty;
+                string reason = String.Empty;
 
+<<<<<<< HEAD
             bool regionAccepted = scene.SimulationService.CreateAgent(null, reg, a, (uint)TeleportFlags.Default, out reason);
+=======
+                bool regionAccepted = scene.SimulationService.CreateAgent(reg, a, (uint)TeleportFlags.Default, out reason);
+>>>>>>> avn/ubitvar
 
-            if (regionAccepted && newAgent)
-            {
-                if (m_eqModule != null)
+                if (regionAccepted)
                 {
-                    #region IP Translation for NAT
-                    IClientIPEndpoint ipepClient;
-                    if (sp.ClientView.TryGet(out ipepClient))
+                    // give  time for createAgent to finish, since it is async and does grid services access              
+                    Thread.Sleep(500);
+
+                    if (m_eqModule != null)
                     {
-                        endPoint.Address = NetworkUtil.GetIPFor(ipepClient.EndPoint, endPoint.Address);
-                    }
-                    #endregion
+                        #region IP Translation for NAT
+                        IClientIPEndpoint ipepClient;
+                        if (sp.ClientView.TryGet(out ipepClient))
+                        {
+                            endPoint.Address = NetworkUtil.GetIPFor(ipepClient.EndPoint, endPoint.Address);
+                        }
+                        #endregion
 
-                    m_log.DebugFormat("{0} {1} is sending {2} EnableSimulator for neighbour region {3}(loc=<{4},{5}>,siz=<{6},{7}>) " +
-                        "and EstablishAgentCommunication with seed cap {8}", LogHeader,
-                        scene.RegionInfo.RegionName, sp.Name,
-                        reg.RegionName, reg.RegionLocX, reg.RegionLocY, reg.RegionSizeX, reg.RegionSizeY , capsPath);
+                        m_log.DebugFormat("{0} {1} is sending {2} EnableSimulator for neighbour region {3}(loc=<{4},{5}>,siz=<{6},{7}>) " +
+                            "and EstablishAgentCommunication with seed cap {8}", LogHeader,
+                            scene.RegionInfo.RegionName, sp.Name,
+                            reg.RegionName, reg.RegionLocX, reg.RegionLocY, reg.RegionSizeX, reg.RegionSizeY, capsPath);
 
-                    m_eqModule.EnableSimulator(reg.RegionHandle, endPoint, sp.UUID, reg.RegionSizeX, reg.RegionSizeY);
-                    m_eqModule.EstablishAgentCommunication(sp.UUID, endPoint, capsPath, reg.RegionHandle, reg.RegionSizeX, reg.RegionSizeY);
-                }
-                else
-                {
-                    sp.ControllingClient.InformClientOfNeighbour(reg.RegionHandle, endPoint);
-                    // TODO: make Event Queue disablable!
+                        m_eqModule.EnableSimulator(reg.RegionHandle, endPoint, sp.UUID, reg.RegionSizeX, reg.RegionSizeY);
+                        m_eqModule.EstablishAgentCommunication(sp.UUID, endPoint, capsPath, reg.RegionHandle, reg.RegionSizeX, reg.RegionSizeY);
+                    }
+                    else
+                    {
+                        sp.ControllingClient.InformClientOfNeighbour(reg.RegionHandle, endPoint);
+                        // TODO: make Event Queue disablable!
+                    }
+
+                    m_log.DebugFormat("[ENTITY TRANSFER MODULE]: Completed inform {0} {1} about neighbour {2}", sp.Name, sp.UUID, endPoint);
                 }
 
-                m_log.DebugFormat("[ENTITY TRANSFER MODULE]: Completed inform {0} {1} about neighbour {2}", sp.Name, sp.UUID, endPoint);
+                if (!regionAccepted)
+                    m_log.WarnFormat(
+                        "[ENTITY TRANSFER MODULE]: Region {0} did not accept {1} {2}: {3}",
+                        reg.RegionName, sp.Name, sp.UUID, reason);
             }
-
-            if (!regionAccepted)
-                m_log.WarnFormat(
-                    "[ENTITY TRANSFER MODULE]: Region {0} did not accept {1} {2}: {3}",
-                    reg.RegionName, sp.Name, sp.UUID, reason);
+ 
         }
 
         /// <summary>
@@ -2357,6 +2848,10 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                 extent.Y = (float)Util.WorldToRegionLoc((uint)megaRegionSize.Y);
             }
 
+<<<<<<< HEAD
+=======
+
+>>>>>>> avn/ubitvar
             swCorner.X = Scene.RegionInfo.RegionLocX - 1;
             swCorner.Y = Scene.RegionInfo.RegionLocY - 1;
             neCorner.X = Scene.RegionInfo.RegionLocX + extent.X;
@@ -2370,7 +2865,11 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
         /// <param name="pRegionLocX"></param>
         /// <param name="pRegionLocY"></param>
         /// <returns></returns>        
+<<<<<<< HEAD
         protected List<GridRegion> GetNeighbours(ScenePresence avatar, uint pRegionLocX, uint pRegionLocY)
+=======
+        protected List<GridRegion> GetNeighbors(ScenePresence avatar, uint pRegionLocX, uint pRegionLocY)
+>>>>>>> avn/ubitvar
         {
             Scene pScene = avatar.Scene;
             RegionInfo m_regionInfo = pScene.RegionInfo;
@@ -2381,6 +2880,7 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
             // view to include everything in the megaregion
             if (m_regionCombinerModule == null || !m_regionCombinerModule.IsRootForMegaregion(Scene.RegionInfo.RegionID))
             {
+<<<<<<< HEAD
                 // The area to check is as big as the current region.
                 // We presume all adjacent regions are the same size as this region.
                 uint dd = Math.Max((uint)avatar.Scene.DefaultDrawDistance, 
@@ -2395,6 +2895,32 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                 neighbours 
                     = avatar.Scene.GridService.GetRegionRange(
                         m_regionInfo.ScopeID, (int)startX, (int)endX, (int)startY, (int)endY);
+=======
+                uint dd = (uint)avatar.DrawDistance;
+
+                // until avatar movement updates client connections, we need to seend at least this current region imediate Neighbors
+                uint ddX = Math.Max(dd, Constants.RegionSize);
+                uint ddY = Math.Max(dd, Constants.RegionSize);
+
+                ddX--;
+                ddY--;
+
+                // reference to region edges. Should be avatar position
+                uint startX = Util.RegionToWorldLoc(pRegionLocX);
+                uint endX = startX + m_regionInfo.RegionSizeX;
+                uint startY = Util.RegionToWorldLoc(pRegionLocY);
+                uint endY = startY + m_regionInfo.RegionSizeY;
+
+                startX -= ddX;
+                startY -= ddY;
+                endX += ddX;
+                endY += ddY;
+
+                neighbours
+                    = avatar.Scene.GridService.GetRegionRange(
+                        m_regionInfo.ScopeID, (int)startX, (int)endX, (int)startY, (int)endY);
+
+>>>>>>> avn/ubitvar
             }
             else
             {
@@ -2408,6 +2934,7 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                         (int)Util.RegionToWorldLoc((uint)swCorner.Y), (int)Util.RegionToWorldLoc((uint)neCorner.Y));
             }
 
+<<<<<<< HEAD
 //            neighbours.ForEach(
 //                n => 
 //                    m_log.DebugFormat(
@@ -2420,59 +2947,72 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                     r.RegionID == m_regionInfo.RegionID 
                         || (r.RegionFlags != null && (r.RegionFlags & OpenSim.Framework.RegionFlags.RegionOnline) == 0));
 
+=======
+            // The r.RegionFlags == null check only needs to be made for simulators before 2015-01-14 (pre 0.8.1).
+            neighbours.RemoveAll( r => r.RegionID == m_regionInfo.RegionID );
+
+>>>>>>> avn/ubitvar
             return neighbours;
         }
+        #endregion
+
+        #region Agent Arrived
 
-        private List<ulong> NewNeighbours(List<ulong> currentNeighbours, List<ulong> previousNeighbours)
+        public void AgentArrivedAtDestination(UUID id)
         {
-            return currentNeighbours.FindAll(delegate(ulong handle) { return !previousNeighbours.Contains(handle); });
+            m_entityTransferStateMachine.SetAgentArrivedAtDestination(id);
         }
 
-        //        private List<ulong> CommonNeighbours(List<ulong> currentNeighbours, List<ulong> previousNeighbours)
-        //        {
-        //            return currentNeighbours.FindAll(delegate(ulong handle) { return previousNeighbours.Contains(handle); });
-        //        }
+        #endregion
+
+        #region Object Transfers
 
-        private List<ulong> OldNeighbours(List<ulong> currentNeighbours, List<ulong> previousNeighbours)
+        public GridRegion GetObjectDestination(SceneObjectGroup grp, Vector3 targetPosition,out Vector3 newpos)
         {
-            return previousNeighbours.FindAll(delegate(ulong handle) { return !currentNeighbours.Contains(handle); });
-        }
+            newpos = targetPosition;
 
-        private List<ulong> NeighbourHandles(List<GridRegion> neighbours)
-        {
-            List<ulong> handles = new List<ulong>();
-            foreach (GridRegion reg in neighbours)
+            Scene scene = grp.Scene;
+            if (scene == null)
+                return null;
+
+            int x = (int)targetPosition.X + (int)scene.RegionInfo.WorldLocX;
+            if (targetPosition.X >= 0)
+                x++;
+            else
+                x--;
+
+            int y = (int)targetPosition.Y + (int)scene.RegionInfo.WorldLocY;
+            if (targetPosition.Y >= 0)
+                y++;
+            else
+                y--;
+
+
+            GridRegion neighbourRegion = scene.GridService.GetRegionByPosition(scene.RegionInfo.ScopeID,x,y);
+            if (neighbourRegion == null)
             {
-                handles.Add(reg.RegionHandle);
+                return null;
             }
-            return handles;
-        }
 
-//        private void Dump(string msg, List<ulong> handles)
-//        {
-//            m_log.InfoFormat("-------------- HANDLE DUMP ({0}) ---------", msg);
-//            foreach (ulong handle in handles)
-//            {
-//                uint x, y;
-//                Utils.LongToUInts(handle, out x, out y);
-//                x = x / Constants.RegionSize;
-//                y = y / Constants.RegionSize;
-//                m_log.InfoFormat("({0}, {1})", x, y);
-//            }
-//        }
+            float newRegionSizeX = neighbourRegion.RegionSizeX;
+            float newRegionSizeY = neighbourRegion.RegionSizeY;
+            if (newRegionSizeX == 0)
+                newRegionSizeX = Constants.RegionSize;
+            if (newRegionSizeY == 0)
+                newRegionSizeY = Constants.RegionSize;
 
-        #endregion
 
-        #region Agent Arrived
+            newpos.X = targetPosition.X - (neighbourRegion.RegionLocX - (int)scene.RegionInfo.WorldLocX);
+            newpos.Y = targetPosition.Y - (neighbourRegion.RegionLocY - (int)scene.RegionInfo.WorldLocY);
 
-        public void AgentArrivedAtDestination(UUID id)
-        {
-            m_entityTransferStateMachine.SetAgentArrivedAtDestination(id);
-        }
 
-        #endregion
+            const float enterDistance = 0.2f;
+            newpos.X = Util.Clamp(newpos.X, enterDistance, newRegionSizeX - enterDistance);
+            newpos.Y = Util.Clamp(newpos.Y, enterDistance, newRegionSizeY - enterDistance);
+
+            return neighbourRegion;
+        }
 
-        #region Object Transfers
 
         /// <summary>
         /// Move the given scene object into a new region depending on which region its absolute position has moved
@@ -2496,6 +3036,7 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
             if (scene == null)
                 return;
 
+<<<<<<< HEAD
             if (grp.RootPart.DIE_AT_EDGE)
             {
                 // We remove the object here
@@ -2510,6 +3051,8 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                 return;
             }
 
+=======
+>>>>>>> avn/ubitvar
             // Remember the old group position in case the region lookup fails so position can be restored.
             Vector3 oldGroupPosition = grp.RootPart.GroupPosition;
 
@@ -2562,7 +3105,7 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
         /// true if the crossing itself was successful, false on failure
         /// FIMXE: we still return true if the crossing object was not successfully deleted from the originating region
         /// </returns>
-        protected bool CrossPrimGroupIntoNewRegion(GridRegion destination, Vector3 newPosition, SceneObjectGroup grp, bool silent)
+        public bool CrossPrimGroupIntoNewRegion(GridRegion destination, Vector3 newPosition, SceneObjectGroup grp, bool silent)
         {
             //m_log.Debug("  >>> CrossPrimGroupIntoNewRegion <<<");
 
@@ -2603,30 +3146,6 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                             grp, e);
                     }
                 }
-/*
- * done on caller ( not in attachments crossing for now)
-                else
-                {
-
-                    if (!grp.IsDeleted)
-                    {
-                        PhysicsActor pa = grp.RootPart.PhysActor;
-                        if (pa != null)
-                        {
-                            pa.CrossingFailure();
-                            if (grp.RootPart.KeyframeMotion != null)
-                            {
-                                // moved to KeyframeMotion.CrossingFailure
-//                                grp.RootPart.Velocity = Vector3.Zero;
-                                grp.RootPart.KeyframeMotion.CrossingFailure();
-//                                grp.SendGroupRootTerseUpdate();
-                            }
-                        }
-                    }
-
-                    m_log.ErrorFormat("[ENTITY TRANSFER MODULE]: Prim crossing failed for {0}", grp);
-                }
- */
             }
             else
             {