Merge remote-tracking branch 'upstream/master'

Conflicts:
	.gitignore
	OpenSim/Region/CoreModules/Scripting/DynamicTexture/DynamicTextureModule.cs

OpenSim/Data/IRegionData.cs

@@ -74,6 +74,8 @@ namespace OpenSim.Data
         RegionData Get(int x, int y, UUID ScopeID);
         List<RegionData> Get(int xStart, int yStart, int xEnd, int yEnd, UUID ScopeID);
 
+        RegionData GetEmptyCoordinates(UUID ScopeID, int desiredX, int desiredY);
+
         bool Store(RegionData data);
 
         bool SetDataItem(UUID principalID, string item, string value);

OpenSim/Data/MSSQL/MSSQLRegionData.cs

@@ -343,5 +343,21 @@ namespace OpenSim.Data.MSSQL
                 return RunCommand(cmd);
             }
         }
+
+        /// <summary>
+        /// GetEmptyCoordinates - return one coordinate at grid based on desired X,Y
+        /// </summary>
+        /// <param name="ScopeID"></param>
+        /// <param name="desiredX"></param>
+        /// <param name="desiredY"></param>
+        /// <returns></returns>
+        public RegionData GetEmptyCoordinates(UUID ScopeID, int desiredX, int desiredY)
+        {
+            RegionData region = new RegionData() { posX = desiredX, posY = desiredY };
+
+            // TODO: Search a empty spot and reserve it for a while;
+
+            return region;
+        }
     }
 }

OpenSim/Data/MySQL/MySQLRegionData.cs

@@ -336,5 +336,21 @@ namespace OpenSim.Data.MySQL
                 return RunCommand(cmd);
             }
         }
+
+        /// <summary>
+        /// GetEmptyCoordinates - return one coordinate at grid based on desired X,Y
+        /// </summary>
+        /// <param name="ScopeID"></param>
+        /// <param name="desiredX"></param>
+        /// <param name="desiredY"></param>
+        /// <returns></returns>
+        public RegionData GetEmptyCoordinates(UUID ScopeID, int desiredX, int desiredY)
+        {
+            RegionData region = new RegionData() { posX = desiredX, posY = desiredY };
+
+            // TODO: Search a empty spot and reserve it for a while;
+
+            return region;
+        }
     }
-}
+}

OpenSim/Data/Null/NullRegionData.cs

@@ -270,5 +270,21 @@ namespace OpenSim.Data.Null
 
             return ret;
         }
+
+        /// <summary>
+        /// GetEmptyCoordinates - return one coordinate at grid based on desired X,Y
+        /// </summary>
+        /// <param name="ScopeID"></param>
+        /// <param name="desiredX"></param>
+        /// <param name="desiredY"></param>
+        /// <returns></returns>
+        public RegionData GetEmptyCoordinates(UUID ScopeID, int desiredX, int desiredY)
+        {
+            RegionData region = new RegionData() { posX = desiredX, posY = desiredY };
+
+            // TODO: Search a empty spot and reserve it for a while;
+
+            return region;
+        }
     }
 }

OpenSim/Region/CoreModules/ServiceConnectorsOut/Grid/LocalGridServiceConnector.cs

@@ -175,6 +175,11 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Grid
             return m_GridService.DeregisterRegion(regionID);
         }
 
+        public GridRegion GetEmptyCoordinates(UUID scopeID, int desiredX, int desiredY)
+        {
+            return m_GridService.GetEmptyCoordinates(scopeID, desiredX, desiredY);
+        }
+
         public List<GridRegion> GetNeighbours(UUID scopeID, UUID regionID)
         {
             return m_GridService.GetNeighbours(scopeID, regionID); 
@@ -256,4 +261,4 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Grid
             MainConsole.Instance.Output(caps.ToString());
         }
     }
-}
+}

OpenSim/Region/CoreModules/ServiceConnectorsOut/Grid/RemoteGridServiceConnector.cs

@@ -166,6 +166,11 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Grid
             return false;
         }
 
+        public GridRegion GetEmptyCoordinates(UUID scopeID, int desiredX, int desiredY)
+        {
+            return m_RemoteGridService.GetEmptyCoordinates(scopeID, desiredX, desiredY);
+        }
+
         public List<GridRegion> GetNeighbours(UUID scopeID, UUID regionID)
         {
             return m_RemoteGridService.GetNeighbours(scopeID, regionID);

OpenSim/Region/Framework/Scenes/Scene.cs

@@ -912,10 +912,41 @@ namespace OpenSim.Region.Framework.Scenes
                     string tile = startupConfig.GetString("MaptileStaticUUID", UUID.Zero.ToString());
                     UUID tileID;
 
+                    m_log.Info(String.Format("[SCENE]: MaptileStaticUUID for {0} config -> {1}", RegionInfo.RegionName, RegionInfo.RegionFile));
+
+                    IniConfigSource sourceRegion = new IniConfigSource(RegionInfo.RegionFile);
+
+                    if (sourceRegion.Configs[RegionInfo.RegionName] != null)
+                    {
+                        if (sourceRegion.Configs[RegionInfo.RegionName].Contains("MaptileStaticUUID"))
+                        {
+                            tile = sourceRegion.Configs[RegionInfo.RegionName].GetString("MaptileStaticUUID", UUID.Zero.ToString());
+                            m_log.Info("[SCENE]: MaptileStaticUUID " + tile);
+                        }
+                    }
+
                     if (UUID.TryParse(tile, out tileID))
                     {
                         RegionInfo.RegionSettings.TerrainImageID = tileID;
                     }
+                    else
+                    {
+                        tileID = UUID.Zero;
+                    }
+
+                    if (tileID == UUID.Zero)
+                    {
+                        m_generateMaptiles = true;
+
+                        int maptileRefresh = startupConfig.GetInt("MaptileRefresh", 0);
+                        if (maptileRefresh != 0)
+                        {
+                            m_mapGenerationTimer.Interval = maptileRefresh * 1000;
+                            m_mapGenerationTimer.Elapsed += RegenerateMaptileAndReregister;
+                            m_mapGenerationTimer.AutoReset = true;
+                            m_mapGenerationTimer.Start();
+                        }
+                    }
                 }
 
                 string grant = startupConfig.GetString("AllowedClients", String.Empty);

OpenSim/Server/Handlers/Grid/GridServerPostHandler.cs

@@ -85,6 +85,9 @@ namespace OpenSim.Server.Handlers.Grid
                     case "deregister":
                         return Deregister(request);
 
+                    case "get_empty_coordinates":
+                        return GetEmptyCoordinates(request);
+
                     case "get_neighbours":
                         return GetNeighbours(request);
 
@@ -194,6 +197,41 @@ namespace OpenSim.Server.Handlers.Grid
 
         }
 
+        byte[] GetEmptyCoordinates(Dictionary<string, object> request)
+        {
+            UUID scopeID = UUID.Zero;
+            if (request.ContainsKey("SCOPEID"))
+                UUID.TryParse(request["SCOPEID"].ToString(), out scopeID);
+            else
+                m_log.WarnFormat("[GRID HANDLER]: no scopeID in request to get empty coordinates");
+
+            Dictionary<string, object> result = new Dictionary<string, object>();
+
+            int desiredX = 7000; // put this at OpenSim.ini file
+            int desiredY = 7000; // this also
+
+            if (request.ContainsKey("X"))
+                int.TryParse( request["X"].ToString(), out desiredX);
+
+            if (request.ContainsKey("Y"))
+                int.TryParse(request["Y"].ToString(), out desiredY);
+
+            // TODO: Create the Method to get Empty Coordinates
+            GridRegion rinfo = m_GridService.GetEmptyCoordinates(scopeID, desiredX, desiredY);
+
+            if (rinfo == null)
+                result["coordinates"] = desiredX + "," + desiredY;
+            else
+            {
+                result["coordinates"] = rinfo.RegionCoordX.ToString() + "," + rinfo.RegionCoordY.ToString();
+            }
+
+            string xmlString = ServerUtils.BuildXmlResponse(result);
+            //m_log.DebugFormat("[GRID HANDLER]: resp string: {0}", xmlString);
+            UTF8Encoding encoding = new UTF8Encoding();
+            return encoding.GetBytes(xmlString);
+        }
+
         byte[] GetNeighbours(Dictionary<string, object> request)
         {
             UUID scopeID = UUID.Zero;

OpenSim/Services/Connectors/Grid/GridServicesConnector.cs

@@ -178,6 +178,15 @@ namespace OpenSim.Services.Connectors
             return false;
         }
 
+        public GridRegion GetEmptyCoordinates(UUID scopeID, int desiredX, int desiredY)
+        {
+            GridRegion rinfo = new GridRegion();
+
+            // TODO : Search empty spots on Grid to register a new SIM
+
+            return rinfo;
+        }
+
         public List<GridRegion> GetNeighbours(UUID scopeID, UUID regionID)
         {
             Dictionary<string, object> sendData = new Dictionary<string, object>();

OpenSim/Services/Connectors/SimianGrid/SimianGridServiceConnector.cs

@@ -154,6 +154,15 @@ namespace OpenSim.Services.Connectors.SimianGrid
             return success;
         }
 
+        public GridRegion GetEmptyCoordinates(UUID scopeID, int desiredX, int desiredY)
+        {
+            GridRegion rinfo = new GridRegion();
+
+            // TODO : Search empty spots on Grid to register a new SIM
+
+            return rinfo;
+        }
+
         public List<GridRegion> GetNeighbours(UUID scopeID, UUID regionID)
         {
             const int NEIGHBOR_RADIUS = 128;

OpenSim/Services/GridService/GridService.cs

@@ -304,6 +304,15 @@ namespace OpenSim.Services.GridService
             return m_Database.Delete(regionID);
         }
 
+        public GridRegion GetEmptyCoordinates(UUID scopeID, int desiredX, int desiredY)
+        {
+            GridRegion rinfo = new GridRegion();
+
+            // TODO : Search empty spots on Grid to register a new SIM
+
+            return rinfo;
+        }
+
         public List<GridRegion> GetNeighbours(UUID scopeID, UUID regionID)
         {
             List<GridRegion> rinfos = new List<GridRegion>();

OpenSim/Services/Interfaces/IGridService.cs

@@ -52,6 +52,12 @@ namespace OpenSim.Services.Interfaces
         /// <exception cref="System.Exception">Thrown if region deregistration failed</exception>
         bool DeregisterRegion(UUID regionID);
 
+        /// <summary>
+        /// Get information about the empty spot to register a new Simulator.
+        /// </summary>
+        /// <returns></returns>
+        GridRegion GetEmptyCoordinates(UUID scopeID, int desiredX, int desiredY);
+
         /// <summary>
         /// Get information about the regions neighbouring the given co-ordinates (in meters).
         /// </summary>
@@ -60,6 +66,7 @@ namespace OpenSim.Services.Interfaces
         /// <returns></returns>
         List<GridRegion> GetNeighbours(UUID scopeID, UUID regionID);
 
+
         GridRegion GetRegionByUUID(UUID scopeID, UUID regionID);
 
         /// <summary>

bin/lib32/libsqlite3.txt

@@ -1 +0,0 @@
-libsqlite version: 3.7.5

syncneb.bat

@@ -0,0 +1,6 @@
+rem git remote add upstream https://github.com/nebadon2025/opensimulator.git
+
+git fetch upstream
+
+git merge upstream/master
+