public void Setup()
{
m_rs = new RegionSettings();
m_rs.AgentLimit = 17;
m_rs.AllowDamage = true;
m_rs.AllowLandJoinDivide = true;
m_rs.AllowLandResell = true;
m_rs.BlockFly = true;
m_rs.BlockShowInSearch = true;
m_rs.BlockTerraform = true;
m_rs.DisableCollisions = true;
m_rs.DisablePhysics = true;
m_rs.DisableScripts = true;
m_rs.Elevation1NW = 15.9;
m_rs.Elevation1NE = 45.3;
m_rs.Elevation1SE = 49;
m_rs.Elevation1SW = 1.9;
m_rs.Elevation2NW = 4.5;
m_rs.Elevation2NE = 19.2;
m_rs.Elevation2SE = 9.2;
m_rs.Elevation2SW = 2.1;
m_rs.FixedSun = true;
m_rs.SunPosition = 12.0;
m_rs.ObjectBonus = 1.4;
m_rs.RestrictPushing = true;
m_rs.TerrainLowerLimit = 0.4;
m_rs.TerrainRaiseLimit = 17.9;
m_rs.TerrainTexture1 = UUID.Parse("00000000-0000-0000-0000-000000000020");
m_rs.TerrainTexture2 = UUID.Parse("00000000-0000-0000-0000-000000000040");
m_rs.TerrainTexture3 = UUID.Parse("00000000-0000-0000-0000-000000000060");
m_rs.TerrainTexture4 = UUID.Parse("00000000-0000-0000-0000-000000000080");
m_rs.UseEstateSun = true;
m_rs.WaterHeight = 23;
}
public RegionSettings LoadRegionSettings(UUID regionUUID)
{
RegionSettings rs = new RegionSettings();
rs.RegionUUID = regionUUID;
return(rs);
}
public static string Serialize(RegionSettings settings)
{
StringWriter sw = new StringWriter();
XmlTextWriter xtw = new XmlTextWriter(sw)
{
Formatting = Formatting.Indented
};
xtw.WriteStartDocument();
xtw.WriteStartElement("RegionSettings");
xtw.WriteStartElement("General");
xtw.WriteElementString("AllowDamage", settings.AllowDamage.ToString());
xtw.WriteElementString("AllowLandResell", settings.AllowLandResell.ToString());
xtw.WriteElementString("AllowLandJoinDivide", settings.AllowLandJoinDivide.ToString());
xtw.WriteElementString("BlockFly", settings.BlockFly.ToString());
xtw.WriteElementString("BlockLandShowInSearch", settings.BlockShowInSearch.ToString());
xtw.WriteElementString("BlockTerraform", settings.BlockTerraform.ToString());
xtw.WriteElementString("DisableCollisions", settings.DisableCollisions.ToString());
xtw.WriteElementString("DisablePhysics", settings.DisablePhysics.ToString());
xtw.WriteElementString("DisableScripts", settings.DisableScripts.ToString());
xtw.WriteElementString("MaturityRating", settings.Maturity.ToString());
xtw.WriteElementString("RestrictPushing", settings.RestrictPushing.ToString());
xtw.WriteElementString("AgentLimit", settings.AgentLimit.ToString());
xtw.WriteElementString("ObjectBonus", settings.ObjectBonus.ToString());
xtw.WriteEndElement();
xtw.WriteStartElement("GroundTextures");
xtw.WriteElementString("Texture1", settings.TerrainTexture1.ToString());
xtw.WriteElementString("Texture2", settings.TerrainTexture2.ToString());
xtw.WriteElementString("Texture3", settings.TerrainTexture3.ToString());
xtw.WriteElementString("Texture4", settings.TerrainTexture4.ToString());
xtw.WriteElementString("ElevationLowSW", settings.Elevation1SW.ToString());
xtw.WriteElementString("ElevationLowNW", settings.Elevation1NW.ToString());
xtw.WriteElementString("ElevationLowSE", settings.Elevation1SE.ToString());
xtw.WriteElementString("ElevationLowNE", settings.Elevation1NE.ToString());
xtw.WriteElementString("ElevationHighSW", settings.Elevation2SW.ToString());
xtw.WriteElementString("ElevationHighNW", settings.Elevation2NW.ToString());
xtw.WriteElementString("ElevationHighSE", settings.Elevation2SE.ToString());
xtw.WriteElementString("ElevationHighNE", settings.Elevation2NE.ToString());
xtw.WriteEndElement();
xtw.WriteStartElement("Terrain");
xtw.WriteElementString("WaterHeight", settings.WaterHeight.ToString());
xtw.WriteElementString("TerrainRaiseLimit", settings.TerrainRaiseLimit.ToString());
xtw.WriteElementString("TerrainLowerLimit", settings.TerrainLowerLimit.ToString());
xtw.WriteElementString("UseEstateSun", settings.UseEstateSun.ToString());
xtw.WriteElementString("FixedSun", settings.FixedSun.ToString());
// XXX: Need to expose interface to get sun phase information from sun module
// xtw.WriteStartElement("SunPhase",
xtw.WriteEndElement();
xtw.WriteEndElement();
xtw.Close();
sw.Close();
return(sw.ToString());
}
public RegionSettings LoadRegionSettings(UUID regionUUID)
{
RegionSettings rs = null;
m_regionSettings.TryGetValue(regionUUID, out rs);
return(rs);
}
public BaseTest()
{
// var serviceProvider = new ServiceCollection()
////.AddEntityFrameworkSqlServer()
//.AddEntityFrameworkNpgsql()
//.AddTransient<ITestService, TestService>()
//.BuildServiceProvider();
DbContextOptionsBuilder <RegionDatabaseContext> builder = new DbContextOptionsBuilder <RegionDatabaseContext>();
var connectionString = "server=localhost;userid=root;password=12345678;database=CityDatabase;";
builder.UseMySql(connectionString);
//.UseInternalServiceProvider(serviceProvider); //burası postgress ile sıkıntı çıkartmıyor, fakat mysql'de çalışmıyor test esnasında hata veriyor.
_regionDatabaseContext = new RegionDatabaseContext(builder.Options);
//_context.Database.Migrate();
RegionSettings _regionSettings = new RegionSettings()
{
FileUploadFolderPath = "c:/"
};
IOptions <RegionSettings> regionOptions = Options.Create(_regionSettings);
IHttpContextAccessor iHttpContextAccessor = new HttpContextAccessor {
HttpContext = new DefaultHttpContext()
};
_cityService = new CityService(_regionDatabaseContext, regionOptions, iHttpContextAccessor);
regionSchemaService = new RegionSchemaService(_regionDatabaseContext, regionOptions, iHttpContextAccessor);
}
public override void Load()
{
if (!Enabled)
{
return;
}
IServerSettingsClient serverSettings = ServiceRegistration.Get <IServerSettingsClient>();
RegionSettings settings = serverSettings.Load <RegionSettings>();
if (string.IsNullOrEmpty(settings.Culture))
{
settings.Culture = "en-US";
}
CultureInfo current = new CultureInfo(settings.Culture);
_items = new List <IResourceString>(_cultures.Count);
for (int i = 0; i < _cultures.Count; i++)
{
CultureInfo ci = _cultures[i];
_items.Add(LocalizationHelper.CreateStaticString(ci.DisplayName));
if (ci.Equals(current))
{
Selected = i;
}
}
}
/// <summary>
/// Load region settings data
/// </summary>
/// <param name="settingsPath"></param>
/// <param name="data"></param>
/// <returns>
/// true if settings were loaded successfully, false otherwise
/// </returns>
private void LoadRegionSettings(string settingsPath, byte[] data)
{
RegionSettings loadedRegionSettings;
try
{
loadedRegionSettings = RegionSettingsSerializer.Deserialize(data);
}
catch (Exception e)
{
MainConsole.Instance.ErrorFormat(
"[ARCHIVER]: Could not parse region settings file {0}. Ignoring. Exception was {1}",
settingsPath, e);
return;
}
RegionSettings currentRegionSettings = m_scene.RegionInfo.RegionSettings;
currentRegionSettings.AgentLimit = loadedRegionSettings.AgentLimit;
currentRegionSettings.AllowDamage = loadedRegionSettings.AllowDamage;
currentRegionSettings.AllowLandJoinDivide = loadedRegionSettings.AllowLandJoinDivide;
currentRegionSettings.AllowLandResell = loadedRegionSettings.AllowLandResell;
currentRegionSettings.BlockFly = loadedRegionSettings.BlockFly;
currentRegionSettings.BlockShowInSearch = loadedRegionSettings.BlockShowInSearch;
currentRegionSettings.BlockTerraform = loadedRegionSettings.BlockTerraform;
currentRegionSettings.DisableCollisions = loadedRegionSettings.DisableCollisions;
currentRegionSettings.DisablePhysics = loadedRegionSettings.DisablePhysics;
currentRegionSettings.DisableScripts = loadedRegionSettings.DisableScripts;
currentRegionSettings.Elevation1NE = loadedRegionSettings.Elevation1NE;
currentRegionSettings.Elevation1NW = loadedRegionSettings.Elevation1NW;
currentRegionSettings.Elevation1SE = loadedRegionSettings.Elevation1SE;
currentRegionSettings.Elevation1SW = loadedRegionSettings.Elevation1SW;
currentRegionSettings.Elevation2NE = loadedRegionSettings.Elevation2NE;
currentRegionSettings.Elevation2NW = loadedRegionSettings.Elevation2NW;
currentRegionSettings.Elevation2SE = loadedRegionSettings.Elevation2SE;
currentRegionSettings.Elevation2SW = loadedRegionSettings.Elevation2SW;
currentRegionSettings.FixedSun = loadedRegionSettings.FixedSun;
currentRegionSettings.ObjectBonus = loadedRegionSettings.ObjectBonus;
currentRegionSettings.RestrictPushing = loadedRegionSettings.RestrictPushing;
currentRegionSettings.TerrainLowerLimit = loadedRegionSettings.TerrainLowerLimit;
currentRegionSettings.TerrainRaiseLimit = loadedRegionSettings.TerrainRaiseLimit;
currentRegionSettings.TerrainTexture1 = loadedRegionSettings.TerrainTexture1;
currentRegionSettings.TerrainTexture2 = loadedRegionSettings.TerrainTexture2;
currentRegionSettings.TerrainTexture3 = loadedRegionSettings.TerrainTexture3;
currentRegionSettings.TerrainTexture4 = loadedRegionSettings.TerrainTexture4;
currentRegionSettings.UseEstateSun = loadedRegionSettings.UseEstateSun;
currentRegionSettings.WaterHeight = loadedRegionSettings.WaterHeight;
currentRegionSettings.Save();
IEstateModule estateModule = m_scene.RequestModuleInterface <IEstateModule>();
if (estateModule != null)
{
estateModule.sendRegionHandshakeToAll();
}
return;
}
public static string Serialize(RegionSettings settings)
{
StringWriter sw = new StringWriter();
XmlTextWriter xtw = new XmlTextWriter(sw);
xtw.Formatting = Formatting.Indented;
xtw.WriteStartDocument();
xtw.WriteStartElement("RegionSettings");
xtw.WriteStartElement("General");
xtw.WriteElementString("AllowDamage", settings.AllowDamage.ToString());
xtw.WriteElementString("AllowLandResell", settings.AllowLandResell.ToString());
xtw.WriteElementString("AllowLandJoinDivide", settings.AllowLandJoinDivide.ToString());
xtw.WriteElementString("BlockFly", settings.BlockFly.ToString());
xtw.WriteElementString("BlockLandShowInSearch", settings.BlockShowInSearch.ToString());
xtw.WriteElementString("BlockTerraform", settings.BlockTerraform.ToString());
xtw.WriteElementString("DisableCollisions", settings.DisableCollisions.ToString());
xtw.WriteElementString("DisablePhysics", settings.DisablePhysics.ToString());
xtw.WriteElementString("DisableScripts", settings.DisableScripts.ToString());
xtw.WriteElementString("MaturityRating", settings.Maturity.ToString());
xtw.WriteElementString("RestrictPushing", settings.RestrictPushing.ToString());
xtw.WriteElementString("AgentLimit", settings.AgentLimit.ToString());
xtw.WriteElementString("ObjectBonus", settings.ObjectBonus.ToString());
xtw.WriteEndElement();
xtw.WriteStartElement("GroundTextures");
xtw.WriteElementString("Texture1", settings.TerrainTexture1.ToString());
xtw.WriteElementString("Texture2", settings.TerrainTexture2.ToString());
xtw.WriteElementString("Texture3", settings.TerrainTexture3.ToString());
xtw.WriteElementString("Texture4", settings.TerrainTexture4.ToString());
xtw.WriteElementString("ElevationLowSW", settings.Elevation1SW.ToString());
xtw.WriteElementString("ElevationLowNW", settings.Elevation1NW.ToString());
xtw.WriteElementString("ElevationLowSE", settings.Elevation1SE.ToString());
xtw.WriteElementString("ElevationLowNE", settings.Elevation1NE.ToString());
xtw.WriteElementString("ElevationHighSW", settings.Elevation2SW.ToString());
xtw.WriteElementString("ElevationHighNW", settings.Elevation2NW.ToString());
xtw.WriteElementString("ElevationHighSE", settings.Elevation2SE.ToString());
xtw.WriteElementString("ElevationHighNE", settings.Elevation2NE.ToString());
xtw.WriteEndElement();
xtw.WriteStartElement("Terrain");
xtw.WriteElementString("WaterHeight", settings.WaterHeight.ToString());
xtw.WriteElementString("TerrainRaiseLimit", settings.TerrainRaiseLimit.ToString());
xtw.WriteElementString("TerrainLowerLimit", settings.TerrainLowerLimit.ToString());
xtw.WriteElementString("UseEstateSun", settings.UseEstateSun.ToString());
xtw.WriteElementString("FixedSun", settings.FixedSun.ToString());
xtw.WriteElementString("SunPosition", settings.SunPosition.ToString());
// Note: 'SunVector' isn't saved because this value is owned by the Sun Module, which
// calculates it automatically according to the date and other factors.
xtw.WriteEndElement();
xtw.WriteEndElement();
xtw.Close();
sw.Close();
return(sw.ToString());
}
public static string Serialize(Simulator settings, RegionSettings reg)
{
StringWriter sw = new StringWriter();
XmlTextWriter xtw = new XmlTextWriter(sw);
xtw.Formatting = Formatting.Indented;
xtw.WriteStartDocument();
xtw.WriteStartElement("RegionSettings");
xtw.WriteStartElement("General");
xtw.WriteElementString("AllowDamage", ((settings.Flags & RegionFlags.AllowDamage) != 0).ToString());
xtw.WriteElementString("AllowLandResell", ((settings.Flags & RegionFlags.BlockLandResell) == 0).ToString());
xtw.WriteElementString("AllowLandJoinDivide", ((settings.Flags & RegionFlags.AllowParcelChanges) != 0).ToString());
xtw.WriteElementString("BlockFly", ((settings.Flags & RegionFlags.NoFly) != 0).ToString());
xtw.WriteElementString("BlockLandShowInSearch", ((settings.Flags & RegionFlags.BlockParcelSearch) != 0).ToString());
xtw.WriteElementString("BlockTerraform", ((settings.Flags & RegionFlags.BlockTerraform) != 0).ToString());
xtw.WriteElementString("DisableCollisions", ((settings.Flags & RegionFlags.SkipCollisions) != 0).ToString());
xtw.WriteElementString("DisablePhysics", ((settings.Flags & RegionFlags.SkipPhysics) != 0).ToString());
xtw.WriteElementString("DisableScripts", ((settings.Flags & RegionFlags.SkipScripts) != 0).ToString());
xtw.WriteElementString("MaturityRating", settings.Access.ToString());
xtw.WriteElementString("RestrictPushing", ((settings.Flags & RegionFlags.RestrictPushObject) != 0).ToString());
xtw.WriteElementString("AgentLimit", reg.AgentLimit.ToString());
xtw.WriteElementString("ObjectBonus", reg.ObjectBonus.ToString());
xtw.WriteEndElement();
xtw.WriteStartElement("GroundTextures");
xtw.WriteElementString("Texture1", settings.TerrainDetail0.ToString());
xtw.WriteElementString("Texture2", settings.TerrainDetail1.ToString());
xtw.WriteElementString("Texture3", settings.TerrainDetail2.ToString());
xtw.WriteElementString("Texture4", settings.TerrainDetail3.ToString());
xtw.WriteElementString("ElevationLowSW", settings.TerrainStartHeight00.ToString());
xtw.WriteElementString("ElevationLowNW", settings.TerrainStartHeight01.ToString());
xtw.WriteElementString("ElevationLowSE", settings.TerrainStartHeight10.ToString());
xtw.WriteElementString("ElevationLowNE", settings.TerrainStartHeight11.ToString());
xtw.WriteElementString("ElevationHighSW", settings.TerrainHeightRange00.ToString());
xtw.WriteElementString("ElevationHighNW", settings.TerrainHeightRange01.ToString());
xtw.WriteElementString("ElevationHighSE", settings.TerrainHeightRange10.ToString());
xtw.WriteElementString("ElevationHighNE", settings.TerrainHeightRange11.ToString());
xtw.WriteEndElement();
xtw.WriteStartElement("Terrain");
xtw.WriteElementString("WaterHeight", settings.WaterHeight.ToString());
xtw.WriteElementString("TerrainRaiseLimit", reg.TerrainRaiseLimit.ToString());
xtw.WriteElementString("TerrainLowerLimit", reg.TerrainLowerLimit.ToString());
xtw.WriteElementString("UseEstateSun", reg.UseEstateSun.ToString());
xtw.WriteElementString("FixedSun", reg.FixedSun.ToString());
//todo xtw.WriteElementString("SunPosition", settings.SunPosition.ToString());
// Note: 'SunVector' isn't saved because this value is owned by the Sun Module, which
// calculates it automatically according to the date and other factors.
xtw.WriteEndElement();
xtw.WriteEndElement();
xtw.Close();
sw.Close();
return(sw.ToString());
}
public virtual async Task <IHttpActionResult> SaveSettings(ODataActionParameters parameters)
{
if (!CheckPermission(Permissions.RegionsWrite))
{
return(Unauthorized());
}
string settingsId = (string)parameters["settingsId"];
int regionId = (int)parameters["regionId"];
string fields = (string)parameters["fields"];
if (string.IsNullOrEmpty(settingsId))
{
return(this.BadRequest("SettingsId has not been provided"));
}
if (regionId == 0)
{
return(this.BadRequest("RegionId has not been provided."));
}
var allSettingsIds = regionSettings.Select(x => x.Name.ToSlugUrl());
if (!allSettingsIds.Contains(settingsId))
{
return(this.BadRequest(string.Format("SettingsId, '{0}' is not recognized.", settingsId)));
}
var dataEntity = await regionSettingsService.Value.FindOneAsync(x =>
x.RegionId == regionId &&
x.SettingsId == settingsId);
if (dataEntity == null)
{
dataEntity = new RegionSettings
{
SettingsId = settingsId,
RegionId = regionId,
Fields = fields
};
await regionSettingsService.Value.InsertAsync(dataEntity);
return(Ok());
//TODO (currently throws error because of missing entity set on odata, basically we need to create
// the separate Api Controller for it. A good idea might be to make this controller do that and make the
// current Get() method an OData action instead... and maybe call it GetSettingsTypes())
//return Created(dataEntity);
}
else
{
dataEntity.Fields = fields;
await regionSettingsService.Value.UpdateAsync(dataEntity);
return(Ok());
//TODO (currently throws error because of missing entity set on odata, basically we need to create
// the separate Api Controller for it. A good idea might be to make this controller do that and make the
// current Get() method an OData action instead... and maybe call it GetSettingsTypes())
//return Updated(dataEntity);
}
}
public void RegionSettingsTest01()
{
RegionSettings settings = new RegionSettings();
settings.OnSave += RegionSaveFired;
settings.Save();
settings.OnSave -= RegionSaveFired;
Assert.That(m_RegionSettingsOnSaveEventFired, "RegionSettings Save Event didn't Fire");
}
bool ISimulationDataRegionSettingsStorageInterface.TryGetValue(UUID regionID, out RegionSettings settings)
{
if (m_RegionSettingsData.TryGetValue(regionID, out settings))
{
settings = new RegionSettings(settings);
return(true);
}
settings = null;
return(false);
}
public void StoreRegionSettings(RegionSettings rs)
{
QueryFilter filter = new QueryFilter();
filter.andFilters["regionUUID"] = rs.RegionUUID;
//Delete the original
GD.Delete(m_regionSettingsRealm, filter);
//Now replace with the new
GD.Insert(m_regionSettingsRealm, new object[] {
rs.RegionUUID,
rs.BlockTerraform ? 1 : 0,
rs.BlockFly ? 1 : 0,
rs.AllowDamage ? 1 : 0,
rs.RestrictPushing ? 1 : 0,
rs.AllowLandResell ? 1 : 0,
rs.AllowLandJoinDivide ? 1 : 0,
rs.BlockShowInSearch ? 1 : 0,
rs.AgentLimit, rs.ObjectBonus,
rs.Maturity,
rs.DisableScripts ? 1 : 0,
rs.DisableCollisions ? 1 : 0,
rs.DisablePhysics ? 1 : 0,
rs.TerrainTexture1,
rs.TerrainTexture2,
rs.TerrainTexture3,
rs.TerrainTexture4,
rs.Elevation1NW,
rs.Elevation2NW,
rs.Elevation1NE,
rs.Elevation2NE,
rs.Elevation1SE,
rs.Elevation2SE,
rs.Elevation1SW,
rs.Elevation2SW,
rs.WaterHeight,
rs.TerrainRaiseLimit,
rs.TerrainLowerLimit,
rs.UseEstateSun ? 1 : 0,
rs.FixedSun ? 1 : 0,
rs.SunPosition,
rs.Covenant,
rs.Sandbox ? 1 : 0,
rs.SunVector.X,
rs.SunVector.Y,
rs.SunVector.Z,
(rs.LoadedCreationID ?? ""),
rs.LoadedCreationDateTime,
rs.TerrainMapImageID,
rs.TerrainImageID,
rs.MinimumAge,
rs.CovenantLastUpdated,
OSDParser.SerializeJsonString(rs.Generic),
Util.ToUnixTime(rs.TerrainMapLastRegenerated)
});
}
private void LoadDefaultLanguage()
{
if (ServiceRegistration.IsRegistered <ISettingsManager>())
{
RegionSettings settings = ServiceRegistration.Get <ISettingsManager>().Load <RegionSettings>();
if (!string.IsNullOrEmpty(settings.Culture))
{
DEFAULT_LANGUAGE = settings.Culture;
}
}
}
public void BeginRegion(PrintRegionType regionType)
{
RegionSettings settings = _appSettings.GetRegionSetting(regionType);
_currentRegion = new RegionNode(regionType, settings);
// Add the default padding values.
_currentYPos += settings.PaddingTop + settings.PaddingBottom;
_children.Add(_currentRegion);
}
public AddressSelector(IObjectSpace os, string address) : base(((XPObjectSpace)os).Session)
{
var code = RegionSettings.RegionCode(Session);
this.Level1 = Session.FindObject <Kladr>(CriteriaOperator.Parse("CodeSignificantChars=?", code));
var cityCode = "81401000000"; // улан-удэ
this.Level3 = Session.FindObject <Kladr>(CriteriaOperator.Parse("CodeOkato=?", cityCode));
GetValues(address);
}
public void TestRegionSettingsDeserialize()
{
TestHelpers.InMethod();
// log4net.Config.XmlConfigurator.Configure();
RegionSettings deserRs = RegionSettingsSerializer.Deserialize(m_serializedRs);
Assert.That(deserRs, Is.Not.Null);
Assert.That(deserRs.TerrainTexture2, Is.EqualTo(m_rs.TerrainTexture2));
Assert.That(deserRs.DisablePhysics, Is.EqualTo(m_rs.DisablePhysics));
Assert.That(deserRs.TerrainLowerLimit, Is.EqualTo(m_rs.TerrainLowerLimit));
}
public void ChangeLanguage(CultureInfo culture)
{
lock (_syncObj)
{
_currentCulture = culture;
ReLoad();
RegionSettings settings = ServiceRegistration.Get <ISettingsManager>().Load <RegionSettings>();
settings.Culture = _currentCulture.Name;
ServiceRegistration.Get <ISettingsManager>().Save(settings);
}
LocalizationMessaging.SendLanguageChangedMessage(culture);
}
public void StoreRegionSettings(RegionSettings rs)
{
RegionSettings oldRegionSettings = (RegionSettings)manager.Get(typeof(RegionSettings), rs.RegionUUID);
if (oldRegionSettings != null)
{
manager.Update(rs);
}
else
{
manager.Insert(rs);
}
}
/// <summary>
/// Load oar control file
/// </summary>
/// <param name="path"></param>
/// <param name="data"></param>
public void LoadControlFile(string path, byte[] data)
{
XmlNamespaceManager nsmgr = new XmlNamespaceManager(new NameTable());
XmlParserContext context = new XmlParserContext(null, nsmgr, null, XmlSpace.None);
XmlTextReader xtr = new XmlTextReader(Encoding.ASCII.GetString(data), XmlNodeType.Document, context);
RegionSettings currentRegionSettings = m_scene.RegionInfo.RegionSettings;
// Loaded metadata will empty if no information exists in the archive
currentRegionSettings.LoadedCreationDateTime = 0;
currentRegionSettings.LoadedCreationID = "";
while (xtr.Read())
{
if (xtr.NodeType == XmlNodeType.Element)
{
if (xtr.Name.ToString() == "archive")
{
int majorVersion = int.Parse(xtr["major_version"]);
int minorVersion = int.Parse(xtr["minor_version"]);
string version = string.Format("{0}.{1}", majorVersion, minorVersion);
if (majorVersion > MAX_MAJOR_VERSION)
{
throw new Exception(
string.Format(
"The OAR you are trying to load has major version number of {0} but this version of OpenSim can only load OARs with major version number {1} and below",
majorVersion, MAX_MAJOR_VERSION));
}
m_log.InfoFormat("[ARCHIVER]: Loading OAR with version {0}", version);
}
if (xtr.Name.ToString() == "datetime")
{
int value;
if (Int32.TryParse(xtr.ReadElementContentAsString(), out value))
{
currentRegionSettings.LoadedCreationDateTime = value;
}
}
else if (xtr.Name.ToString() == "id")
{
currentRegionSettings.LoadedCreationID = xtr.ReadElementContentAsString();
}
}
}
currentRegionSettings.Save();
ControlFileLoaded = true;
}
RegionSettings ISimulationDataRegionSettingsStorageInterface.this[UUID regionID]
{
get
{
RegionSettings settings;
if (!RegionSettings.TryGetValue(regionID, out settings))
{
throw new KeyNotFoundException();
}
return(settings);
}
set { m_RegionSettingsData[regionID] = new RegionSettings(value); }
}
public void TestRegionSettingsDeserialize()
{
TestHelpers.InMethod();
// log4net.Config.XmlConfigurator.Configure();
RegionSettings deserRs = RegionSettingsSerializer.Deserialize(m_serializedRs, out ViewerEnvironment dummy);
Assert.That(deserRs, Is.Not.Null);
Assert.That(deserRs.TerrainTexture2, Is.EqualTo(m_rs.TerrainTexture2));
Assert.That(deserRs.DisablePhysics, Is.EqualTo(m_rs.DisablePhysics));
Assert.That(deserRs.TerrainLowerLimit, Is.EqualTo(m_rs.TerrainLowerLimit));
Assert.That(deserRs.TelehubObject, Is.EqualTo(m_rs.TelehubObject));
Assert.That(deserRs.SpawnPoints()[0].ToString(), Is.EqualTo(m_rs.SpawnPoints()[0].ToString()));
}
public override void Save()
{
if (!Enabled)
{
return;
}
base.Save();
IServerSettingsClient serverSettings = ServiceRegistration.Get <IServerSettingsClient>();
RegionSettings settings = serverSettings.Load <RegionSettings>();
settings.Culture = _cultures[Selected].Name;
serverSettings.Save(settings);
}
public void RegionSettingsTest01()
{
RegionSettings settings = new RegionSettings();
settings.OnSave += RegionSaveFired;
settings.Save();
settings.OnSave -= RegionSaveFired;
// string str = settings.LoadedCreationDate;
// int dt = settings.LoadedCreationDateTime;
// string id = settings.LoadedCreationID;
// string time = settings.LoadedCreationTime;
Assert.That(m_RegionSettingsOnSaveEventFired, "RegionSettings Save Event didn't Fire");
}
public RegionSettings LoadRegionSettings(UUID regionUUID)
{
RegionSettings regionSettings = (RegionSettings)manager.Get(typeof(RegionSettings), regionUUID);
if (regionSettings == null)
{
regionSettings = new RegionSettings();
regionSettings.RegionUUID = regionUUID;
manager.Insert(regionSettings);
}
regionSettings.OnSave += StoreRegionSettings;
return(regionSettings);
}
private void SettingsHandler(string regionName, RegionSettings settings)
{
if (m_regionInfo != null)
{
m_regionInfo.MaxAgents = (uint)settings.AgentLimit;
m_regionInfo.RegionFlags = ToggleRegionFlag(m_regionInfo.RegionFlags, RegionFlags.AllowDamage, settings.AllowDamage);
m_regionInfo.RegionFlags = ToggleRegionFlag(m_regionInfo.RegionFlags, RegionFlags.AllowParcelChanges, settings.AllowLandJoinDivide);
m_regionInfo.RegionFlags = ToggleRegionFlag(m_regionInfo.RegionFlags, RegionFlags.BlockLandResell, !settings.AllowLandResell);
m_regionInfo.RegionFlags = ToggleRegionFlag(m_regionInfo.RegionFlags, RegionFlags.BlockParcelSearch, settings.BlockLandShowInSearch);
m_regionInfo.RegionFlags = ToggleRegionFlag(m_regionInfo.RegionFlags, RegionFlags.BlockTerraform, settings.BlockTerraform);
m_regionInfo.RegionFlags = ToggleRegionFlag(m_regionInfo.RegionFlags, RegionFlags.SkipCollisions, settings.DisableCollisions);
m_regionInfo.RegionFlags = ToggleRegionFlag(m_regionInfo.RegionFlags, RegionFlags.SkipPhysics, settings.DisablePhysics);
m_regionInfo.RegionFlags = ToggleRegionFlag(m_regionInfo.RegionFlags, RegionFlags.SkipScripts, settings.DisableScripts);
m_regionInfo.RegionFlags = ToggleRegionFlag(m_regionInfo.RegionFlags, RegionFlags.SunFixed, settings.FixedSun);
//settings.MaturityRating
//settings.ObjectBonus
m_regionInfo.RegionFlags = ToggleRegionFlag(m_regionInfo.RegionFlags, RegionFlags.RestrictPushObject, settings.RestrictPushing);
m_regionInfo.TerrainDetail0 = settings.TerrainDetail0;
m_regionInfo.TerrainDetail1 = settings.TerrainDetail1;
m_regionInfo.TerrainDetail2 = settings.TerrainDetail2;
m_regionInfo.TerrainDetail3 = settings.TerrainDetail3;
m_regionInfo.TerrainHeightRange00 = settings.TerrainHeightRange00;
m_regionInfo.TerrainHeightRange01 = settings.TerrainHeightRange01;
m_regionInfo.TerrainHeightRange10 = settings.TerrainHeightRange10;
m_regionInfo.TerrainHeightRange11 = settings.TerrainHeightRange11;
m_regionInfo.TerrainStartHeight00 = settings.TerrainStartHeight00;
m_regionInfo.TerrainStartHeight01 = settings.TerrainStartHeight01;
m_regionInfo.TerrainStartHeight10 = settings.TerrainStartHeight10;
m_regionInfo.TerrainStartHeight11 = settings.TerrainStartHeight11;
//settings.TerrainLowerLimit
//settings.TerrainRaiseLimit
m_regionInfo.UseEstateSun = settings.UseEstateSun;
m_regionInfo.WaterHeight = settings.WaterHeight;
if (m_udp != null)
{
m_scene.ForEachPresence(
delegate(IScenePresence presence)
{
if (presence is LLAgent)
{
Estates.SendRegionHandshake((LLAgent)presence, m_udp, m_scene, m_regionInfo, m_permissions);
}
}
);
}
}
}
public StringManager()
{
RegionSettings settings = new RegionSettings();
ServiceScope.Get<ISettingsManager>().Load(settings);
if (settings.Culture == string.Empty)
{
_stringProvider = new LocalisationProvider("Language", null);
settings.Culture = _stringProvider.CurrentCulture.Name;
ServiceScope.Get<ISettingsManager>().Save(settings);
}
else
{
_stringProvider = new LocalisationProvider("Language", settings.Culture);
}
}
public StringManager()
{
ServiceRegistration.Get <ILogger>().Debug("StringManager: Loading settings");
RegionSettings settings = ServiceRegistration.Get <ISettingsManager>().Load <RegionSettings>();
if (string.IsNullOrEmpty(settings.Culture))
{
_currentCulture = CultureInfo.CurrentUICulture;
ServiceRegistration.Get <ILogger>().Info("StringManager: Culture not set. Using culture: '{0}'", _currentCulture.Name);
}
else
{
_currentCulture = CultureInfo.GetCultureInfo(settings.Culture);
ServiceRegistration.Get <ILogger>().Info("StringManager: Using culture: " + _currentCulture.Name);
}
}
public void StoreRegionSettings(RegionSettings rs)
{
//Delete the original
GD.Delete(m_regionSettingsRealm, new string[1] {
"regionUUID"
}, new object[1] {
rs.RegionUUID
});
//Now replace with the new
GD.Insert(m_regionSettingsRealm, new object[] { rs.RegionUUID, rs.BlockTerraform, rs.BlockFly, rs.AllowDamage,
rs.RestrictPushing, rs.AllowLandResell, rs.AllowLandJoinDivide, rs.BlockShowInSearch, rs.AgentLimit, rs.ObjectBonus,
rs.Maturity, rs.DisableScripts, rs.DisableCollisions, rs.DisablePhysics, rs.TerrainTexture1,
rs.TerrainTexture2, rs.TerrainTexture3, rs.TerrainTexture4, rs.Elevation1NW, rs.Elevation2NW,
rs.Elevation1NE, rs.Elevation2NE, rs.Elevation1SE, rs.Elevation2SE, rs.Elevation1SW, rs.Elevation2SW,
rs.WaterHeight, rs.TerrainRaiseLimit, rs.TerrainLowerLimit, rs.UseEstateSun, rs.FixedSun, rs.SunPosition,
rs.Covenant, rs.Sandbox, rs.SunVector.X, rs.SunVector.Y, rs.SunVector.Z, rs.LoadedCreationID, rs.LoadedCreationDateTime,
rs.TerrainMapImageID, rs.TerrainImageID, rs.MinimumAge, rs.CovenantLastUpdated, OSDParser.SerializeJsonString(rs.Generic) });
}
/// <summary>
/// Load oar control file
/// </summary>
/// <param name="data"></param>
void LoadControlFile(byte [] data)
{
//Create the XmlNamespaceManager.
NameTable nt = new NameTable();
XmlNamespaceManager nsmgr = new XmlNamespaceManager(nt);
// Create the XmlParserContext.
XmlParserContext context = new XmlParserContext(null, nsmgr, null, XmlSpace.None);
XmlTextReader xtr = new XmlTextReader(m_asciiEncoding.GetString(data), XmlNodeType.Document, context);
RegionSettings currentRegionSettings = m_scene.RegionInfo.RegionSettings;
// Loaded metadata will be empty if no information exists in the archive
currentRegionSettings.LoadedCreationDateTime = 0;
currentRegionSettings.LoadedCreationID = "";
try {
while (xtr.Read())
{
if (xtr.NodeType == XmlNodeType.Element)
{
if (xtr.Name == "datetime")
{
int value;
if (int.TryParse(xtr.ReadElementContentAsString(), out value))
{
currentRegionSettings.LoadedCreationDateTime = value;
}
}
else if (xtr.Name == "id")
{
currentRegionSettings.LoadedCreationID = xtr.ReadElementContentAsString();
}
}
}
} finally {
xtr.Close();
}
}
public RegionSettings LoadRegionSettings (UUID regionUUID)
{
RegionSettings settings = new RegionSettings ();
Dictionary<string, List<string>> query = GD.QueryNames (new string[1] { "regionUUID" }, new object[1] { regionUUID }, m_regionSettingsRealm, "*");
if (query.Count == 0)
{
settings.RegionUUID = regionUUID;
StoreRegionSettings (settings);
}
else
{
for (int i = 0; i < query.ElementAt (0).Value.Count; i++)
{
settings.RegionUUID = UUID.Parse (query["regionUUID"][i]);
settings.BlockTerraform = int.Parse (query["block_terraform"][i]) == 1;
settings.BlockFly = int.Parse (query["block_fly"][i]) == 1;
settings.AllowDamage = int.Parse (query["allow_damage"][i]) == 1;
settings.RestrictPushing = int.Parse (query["restrict_pushing"][i]) == 1;
settings.AllowLandResell = int.Parse (query["allow_land_resell"][i]) == 1;
settings.AllowLandJoinDivide = int.Parse (query["allow_land_join_divide"][i]) == 1;
settings.BlockShowInSearch = int.Parse (query["block_show_in_search"][i]) == 1;
settings.AgentLimit = int.Parse (query["agent_limit"][i]);
settings.ObjectBonus = double.Parse (query["object_bonus"][i]);
settings.Maturity = int.Parse (query["maturity"][i]);
settings.DisableScripts = int.Parse (query["disable_scripts"][i]) == 1;
settings.DisableCollisions = int.Parse (query["disable_collisions"][i]) == 1;
settings.DisablePhysics = int.Parse (query["disable_physics"][i]) == 1;
settings.TerrainTexture1 = UUID.Parse (query["terrain_texture_1"][i]);
settings.TerrainTexture2 = UUID.Parse (query["terrain_texture_2"][i]);
settings.TerrainTexture3 = UUID.Parse (query["terrain_texture_3"][i]);
settings.TerrainTexture4 = UUID.Parse (query["terrain_texture_4"][i]);
settings.Elevation1NW = double.Parse (query["elevation_1_nw"][i]);
settings.Elevation2NW = double.Parse (query["elevation_2_nw"][i]);
settings.Elevation1NE = double.Parse (query["elevation_1_ne"][i]);
settings.Elevation2NE = double.Parse (query["elevation_2_ne"][i]);
settings.Elevation1SE = double.Parse (query["elevation_1_se"][i]);
settings.Elevation2SE = double.Parse (query["elevation_2_se"][i]);
settings.Elevation1SW = double.Parse (query["elevation_1_sw"][i]);
settings.Elevation2SW = double.Parse (query["elevation_2_sw"][i]);
settings.WaterHeight = double.Parse (query["water_height"][i]);
settings.TerrainRaiseLimit = double.Parse (query["terrain_raise_limit"][i]);
settings.TerrainLowerLimit = double.Parse (query["terrain_lower_limit"][i]);
settings.UseEstateSun = int.Parse (query["use_estate_sun"][i]) == 1;
settings.FixedSun = int.Parse (query["fixed_sun"][i]) == 1;
settings.SunPosition = double.Parse (query["sun_position"][i]);
settings.Covenant = UUID.Parse (query["covenant"][i]);
if(query.ContainsKey("Sandbox"))
if(query["Sandbox"][i] != null)
settings.Sandbox = int.Parse (query["Sandbox"][i]) == 1;
settings.SunVector = new Vector3 (float.Parse (query["sunvectorx"][i]),
float.Parse (query["sunvectory"][i]),
float.Parse (query["sunvectorz"][i]));
settings.LoadedCreationID = query["loaded_creation_id"][i];
settings.LoadedCreationDateTime = int.Parse (query["loaded_creation_datetime"][i]);
settings.TerrainMapImageID = UUID.Parse (query["map_tile_ID"][i]);
settings.TerrainImageID = UUID.Parse (query["terrain_tile_ID"][i]);
if (query["minimum_age"][i] != null)
settings.MinimumAge = int.Parse (query["minimum_age"][i]);
if(query["covenantlastupdated"][i] != null)
settings.CovenantLastUpdated = int.Parse (query["covenantlastupdated"][i]);
if (query.ContainsKey ("generic") && query["generic"].Count > i && query["generic"][i] != null)
{
OSD o = OSDParser.DeserializeJson (query["generic"][i]);
if (o.Type == OSDType.Map)
settings.Generic = (OSDMap)o;
}
}
}
settings.OnSave += StoreRegionSettings;
return settings;
}
public void StoreRegionSettings (RegionSettings rs)
{
//Delete the original
GD.Delete (m_regionSettingsRealm, new string[1] { "regionUUID" }, new object[1] { rs.RegionUUID });
//Now replace with the new
GD.Insert (m_regionSettingsRealm, new object[] { rs.RegionUUID, rs.BlockTerraform ? 1 : 0, rs.BlockFly ? 1 : 0, rs.AllowDamage ? 1 : 0,
rs.RestrictPushing ? 1 : 0, rs.AllowLandResell ? 1 : 0, rs.AllowLandJoinDivide ? 1 : 0, rs.BlockShowInSearch ? 1 : 0, rs.AgentLimit, rs.ObjectBonus,
rs.Maturity, rs.DisableScripts ? 1 : 0, rs.DisableCollisions ? 1 : 0, rs.DisablePhysics ? 1 : 0, rs.TerrainTexture1,
rs.TerrainTexture2, rs.TerrainTexture3, rs.TerrainTexture4, rs.Elevation1NW, rs.Elevation2NW,
rs.Elevation1NE, rs.Elevation2NE, rs.Elevation1SE, rs.Elevation2SE, rs.Elevation1SW, rs.Elevation2SW,
rs.WaterHeight, rs.TerrainRaiseLimit, rs.TerrainLowerLimit, rs.UseEstateSun ? 1 : 0, rs.FixedSun ? 1 : 0, rs.SunPosition,
rs.Covenant, rs.Sandbox ? 1 : 0, rs.SunVector.X, rs.SunVector.Y, rs.SunVector.Z, (rs.LoadedCreationID == null ? "" : rs.LoadedCreationID), rs.LoadedCreationDateTime,
rs.TerrainMapImageID, rs.TerrainImageID, rs.MinimumAge, rs.CovenantLastUpdated, OSDParser.SerializeJsonString(rs.Generic)});
}
/// <summary>
/// Changes the language.
/// </summary>
/// <param name = "cultureName">Name of the culture.</param>
public void ChangeLanguage(string cultureName)
{
_stringProvider.ChangeLanguage(cultureName);
RegionSettings settings = new RegionSettings();
ServiceScope.Get<ISettingsManager>().Load(settings);
settings.Culture = cultureName;
ServiceScope.Get<ISettingsManager>().Save(settings);
}
public static string Serialize(RegionSettings settings)
{
StringWriter sw = new StringWriter();
XmlTextWriter xtw = new XmlTextWriter(sw);
xtw.Formatting = Formatting.Indented;
xtw.WriteStartDocument();
xtw.WriteStartElement("RegionSettings");
xtw.WriteStartElement("General");
xtw.WriteElementString("AllowDamage", settings.AllowDamage.ToString());
xtw.WriteElementString("AllowLandResell", settings.AllowLandResell.ToString());
xtw.WriteElementString("AllowLandJoinDivide", settings.AllowLandJoinDivide.ToString());
xtw.WriteElementString("BlockFly", settings.BlockFly.ToString());
xtw.WriteElementString("BlockLandShowInSearch", settings.BlockShowInSearch.ToString());
xtw.WriteElementString("BlockTerraform", settings.BlockTerraform.ToString());
xtw.WriteElementString("DisableCollisions", settings.DisableCollisions.ToString());
xtw.WriteElementString("DisablePhysics", settings.DisablePhysics.ToString());
xtw.WriteElementString("DisableScripts", settings.DisableScripts.ToString());
xtw.WriteElementString("MaturityRating", settings.Maturity.ToString());
xtw.WriteElementString("RestrictPushing", settings.RestrictPushing.ToString());
xtw.WriteElementString("AgentLimit", settings.AgentLimit.ToString());
xtw.WriteElementString("ObjectBonus", settings.ObjectBonus.ToString());
xtw.WriteEndElement();
xtw.WriteStartElement("GroundTextures");
xtw.WriteElementString("Texture1", settings.TerrainTexture1.ToString());
xtw.WriteElementString("Texture2", settings.TerrainTexture2.ToString());
xtw.WriteElementString("Texture3", settings.TerrainTexture3.ToString());
xtw.WriteElementString("Texture4", settings.TerrainTexture4.ToString());
xtw.WriteElementString("ElevationLowSW", settings.Elevation1SW.ToString());
xtw.WriteElementString("ElevationLowNW", settings.Elevation1NW.ToString());
xtw.WriteElementString("ElevationLowSE", settings.Elevation1SE.ToString());
xtw.WriteElementString("ElevationLowNE", settings.Elevation1NE.ToString());
xtw.WriteElementString("ElevationHighSW", settings.Elevation2SW.ToString());
xtw.WriteElementString("ElevationHighNW", settings.Elevation2NW.ToString());
xtw.WriteElementString("ElevationHighSE", settings.Elevation2SE.ToString());
xtw.WriteElementString("ElevationHighNE", settings.Elevation2NE.ToString());
xtw.WriteEndElement();
xtw.WriteStartElement("Terrain");
xtw.WriteElementString("WaterHeight", settings.WaterHeight.ToString());
xtw.WriteElementString("TerrainRaiseLimit", settings.TerrainRaiseLimit.ToString());
xtw.WriteElementString("TerrainLowerLimit", settings.TerrainLowerLimit.ToString());
xtw.WriteElementString("UseEstateSun", settings.UseEstateSun.ToString());
xtw.WriteElementString("FixedSun", settings.FixedSun.ToString());
xtw.WriteElementString("SunPosition", settings.SunPosition.ToString());
// Note: 'SunVector' isn't saved because this value is owned by the Sun Module, which
// calculates it automatically according to the date and other factors.
xtw.WriteEndElement();
xtw.WriteStartElement("Telehub");
if (settings.TelehubObject != UUID.Zero)
{
xtw.WriteElementString("TelehubObject", settings.TelehubObject.ToString());
foreach (SpawnPoint sp in settings.SpawnPoints())
xtw.WriteElementString("SpawnPoint", sp.ToString());
}
xtw.WriteEndElement();
xtw.WriteEndElement();
xtw.Close();
sw.Close();
return sw.ToString();
}
public static string Serialize(RegionSettings settings)
{
StringWriter sw = new StringWriter();
XmlTextWriter xtw = new XmlTextWriter(sw) {Formatting = Formatting.Indented};
xtw.WriteStartDocument();
xtw.WriteStartElement("RegionSettings");
xtw.WriteStartElement("General");
xtw.WriteElementString("AllowDamage", settings.AllowDamage.ToString());
xtw.WriteElementString("AllowLandResell", settings.AllowLandResell.ToString());
xtw.WriteElementString("AllowLandJoinDivide", settings.AllowLandJoinDivide.ToString());
xtw.WriteElementString("BlockFly", settings.BlockFly.ToString());
xtw.WriteElementString("BlockLandShowInSearch", settings.BlockShowInSearch.ToString());
xtw.WriteElementString("BlockTerraform", settings.BlockTerraform.ToString());
xtw.WriteElementString("DisableCollisions", settings.DisableCollisions.ToString());
xtw.WriteElementString("DisablePhysics", settings.DisablePhysics.ToString());
xtw.WriteElementString("DisableScripts", settings.DisableScripts.ToString());
xtw.WriteElementString("MaturityRating", settings.Maturity.ToString());
xtw.WriteElementString("RestrictPushing", settings.RestrictPushing.ToString());
xtw.WriteElementString("AgentLimit", settings.AgentLimit.ToString());
xtw.WriteElementString("ObjectBonus", settings.ObjectBonus.ToString());
xtw.WriteEndElement();
xtw.WriteStartElement("GroundTextures");
xtw.WriteElementString("Texture1", settings.TerrainTexture1.ToString());
xtw.WriteElementString("Texture2", settings.TerrainTexture2.ToString());
xtw.WriteElementString("Texture3", settings.TerrainTexture3.ToString());
xtw.WriteElementString("Texture4", settings.TerrainTexture4.ToString());
xtw.WriteElementString("ElevationLowSW", settings.Elevation1SW.ToString());
xtw.WriteElementString("ElevationLowNW", settings.Elevation1NW.ToString());
xtw.WriteElementString("ElevationLowSE", settings.Elevation1SE.ToString());
xtw.WriteElementString("ElevationLowNE", settings.Elevation1NE.ToString());
xtw.WriteElementString("ElevationHighSW", settings.Elevation2SW.ToString());
xtw.WriteElementString("ElevationHighNW", settings.Elevation2NW.ToString());
xtw.WriteElementString("ElevationHighSE", settings.Elevation2SE.ToString());
xtw.WriteElementString("ElevationHighNE", settings.Elevation2NE.ToString());
xtw.WriteEndElement();
xtw.WriteStartElement("Terrain");
xtw.WriteElementString("WaterHeight", settings.WaterHeight.ToString());
xtw.WriteElementString("TerrainRaiseLimit", settings.TerrainRaiseLimit.ToString());
xtw.WriteElementString("TerrainLowerLimit", settings.TerrainLowerLimit.ToString());
xtw.WriteElementString("UseEstateSun", settings.UseEstateSun.ToString());
xtw.WriteElementString("FixedSun", settings.FixedSun.ToString());
// XXX: Need to expose interface to get sun phase information from sun module
// xtw.WriteStartElement("SunPhase",
xtw.WriteEndElement();
xtw.WriteEndElement();
xtw.Close();
sw.Close();
return sw.ToString();
}
/// <summary>
/// Deserialize settings
/// </summary>
/// <param name = "serializedSettings"></param>
/// <returns></returns>
/// <exception cref = "System.Xml.XmlException"></exception>
public static RegionSettings Deserialize(string serializedSettings)
{
RegionSettings settings = new RegionSettings();
StringReader sr = new StringReader(serializedSettings);
XmlTextReader xtr = new XmlTextReader(sr);
xtr.ReadStartElement("RegionSettings");
xtr.ReadStartElement("General");
while (xtr.Read() && xtr.NodeType != XmlNodeType.EndElement)
{
switch (xtr.Name)
{
case "AllowDamage":
settings.AllowDamage = bool.Parse(xtr.ReadElementContentAsString());
break;
case "AllowLandResell":
settings.AllowLandResell = bool.Parse(xtr.ReadElementContentAsString());
break;
case "AllowLandJoinDivide":
settings.AllowLandJoinDivide = bool.Parse(xtr.ReadElementContentAsString());
break;
case "BlockFly":
settings.BlockFly = bool.Parse(xtr.ReadElementContentAsString());
break;
case "BlockLandShowInSearch":
settings.BlockShowInSearch = bool.Parse(xtr.ReadElementContentAsString());
break;
case "BlockTerraform":
settings.BlockTerraform = bool.Parse(xtr.ReadElementContentAsString());
break;
case "DisableCollisions":
settings.DisableCollisions = bool.Parse(xtr.ReadElementContentAsString());
break;
case "DisablePhysics":
settings.DisablePhysics = bool.Parse(xtr.ReadElementContentAsString());
break;
case "DisableScripts":
settings.DisableScripts = bool.Parse(xtr.ReadElementContentAsString());
break;
case "MaturityRating":
settings.Maturity = int.Parse(xtr.ReadElementContentAsString());
break;
case "RestrictPushing":
settings.RestrictPushing = bool.Parse(xtr.ReadElementContentAsString());
break;
case "AgentLimit":
settings.AgentLimit = int.Parse(xtr.ReadElementContentAsString());
break;
case "ObjectBonus":
settings.ObjectBonus = double.Parse(xtr.ReadElementContentAsString(), Culture.NumberFormatInfo);
break;
}
}
xtr.ReadEndElement();
xtr.ReadStartElement("GroundTextures");
while (xtr.Read() && xtr.NodeType != XmlNodeType.EndElement)
{
switch (xtr.Name)
{
case "Texture1":
settings.TerrainTexture1 = UUID.Parse(xtr.ReadElementContentAsString());
break;
case "Texture2":
settings.TerrainTexture2 = UUID.Parse(xtr.ReadElementContentAsString());
break;
case "Texture3":
settings.TerrainTexture3 = UUID.Parse(xtr.ReadElementContentAsString());
break;
case "Texture4":
settings.TerrainTexture4 = UUID.Parse(xtr.ReadElementContentAsString());
break;
case "ElevationLowSW":
settings.Elevation1SW = double.Parse(xtr.ReadElementContentAsString(), Culture.NumberFormatInfo);
break;
case "ElevationLowNW":
settings.Elevation1NW = double.Parse(xtr.ReadElementContentAsString(), Culture.NumberFormatInfo);
break;
case "ElevationLowSE":
settings.Elevation1SE = double.Parse(xtr.ReadElementContentAsString(), Culture.NumberFormatInfo);
break;
case "ElevationLowNE":
settings.Elevation1NE = double.Parse(xtr.ReadElementContentAsString(), Culture.NumberFormatInfo);
break;
case "ElevationHighSW":
settings.Elevation2SW = double.Parse(xtr.ReadElementContentAsString(), Culture.NumberFormatInfo);
break;
case "ElevationHighNW":
settings.Elevation2NW = double.Parse(xtr.ReadElementContentAsString(), Culture.NumberFormatInfo);
break;
case "ElevationHighSE":
settings.Elevation2SE = double.Parse(xtr.ReadElementContentAsString(), Culture.NumberFormatInfo);
break;
case "ElevationHighNE":
settings.Elevation2NE = double.Parse(xtr.ReadElementContentAsString(), Culture.NumberFormatInfo);
break;
}
}
xtr.ReadEndElement();
xtr.ReadStartElement("Terrain");
while (xtr.Read() && xtr.NodeType != XmlNodeType.EndElement)
{
switch (xtr.Name)
{
case "WaterHeight":
settings.WaterHeight = double.Parse(xtr.ReadElementContentAsString(), Culture.NumberFormatInfo);
break;
case "TerrainRaiseLimit":
settings.TerrainRaiseLimit = double.Parse(xtr.ReadElementContentAsString(),
Culture.NumberFormatInfo);
break;
case "TerrainLowerLimit":
settings.TerrainLowerLimit = double.Parse(xtr.ReadElementContentAsString(),
Culture.NumberFormatInfo);
break;
case "UseEstateSun":
settings.UseEstateSun = bool.Parse(xtr.ReadElementContentAsString());
break;
case "FixedSun":
settings.FixedSun = bool.Parse(xtr.ReadElementContentAsString());
break;
}
}
xtr.Close();
sr.Close();
return settings;
}
private void ArchiveOneRegion(Scene scene, string regionDir, Dictionary <UUID, sbyte> assetUuids,
HashSet <UUID> failedIDs, HashSet <UUID> uncertainAssetsUUIDs)
{
m_log.InfoFormat("[ARCHIVER]: Writing region {0}", scene.Name);
EntityBase[] entities = scene.GetEntities();
List <SceneObjectGroup> sceneObjects = new List <SceneObjectGroup>();
int numObjectsSkippedPermissions = 0;
// Filter entities so that we only have scene objects.
// FIXME: Would be nicer to have this as a proper list in SceneGraph, since lots of methods
// end up having to do this
IPermissionsModule permissionsModule = scene.RequestModuleInterface <IPermissionsModule>();
foreach (EntityBase entity in entities)
{
if (entity is SceneObjectGroup)
{
SceneObjectGroup sceneObject = entity as SceneObjectGroup;
if (!sceneObject.IsDeleted && !sceneObject.IsAttachment && !sceneObject.IsTemporary && !sceneObject.inTransit)
{
if (!CanUserArchiveObject(scene.RegionInfo.EstateSettings.EstateOwner, sceneObject, FilterContent, permissionsModule))
{
// The user isn't allowed to copy/transfer this object, so it will not be included in the OAR.
++numObjectsSkippedPermissions;
}
else
{
sceneObjects.Add(sceneObject);
}
}
}
}
if (SaveAssets)
{
UuidGatherer assetGatherer = new UuidGatherer(scene.AssetService, assetUuids, failedIDs, uncertainAssetsUUIDs);
int prevAssets = assetUuids.Count;
foreach (SceneObjectGroup sceneObject in sceneObjects)
{
int curErrorCntr = assetGatherer.ErrorCount;
int possible = assetGatherer.possibleNotAssetCount;
assetGatherer.AddForInspection(sceneObject);
assetGatherer.GatherAll();
curErrorCntr = assetGatherer.ErrorCount - curErrorCntr;
possible = assetGatherer.possibleNotAssetCount - possible;
if (curErrorCntr > 0)
{
m_log.ErrorFormat("[ARCHIVER]: object {0} '{1}', at {2}, contains {3} references to missing or damaged assets",
sceneObject.UUID, sceneObject.Name, sceneObject.AbsolutePosition.ToString(), curErrorCntr);
if (possible > 0)
{
m_log.WarnFormat("[ARCHIVER Warning]: object also contains {0} references that may not be assets or are missing", possible);
}
}
else if (possible > 0)
{
m_log.WarnFormat("[ARCHIVER Warning]: object {0} '{1}', at {2}, contains {3} references that may not be assets or are missing",
sceneObject.UUID, sceneObject.Name, sceneObject.AbsolutePosition.ToString(), possible);
}
}
assetGatherer.GatherAll();
GC.Collect();
int errors = assetGatherer.FailedUUIDs.Count;
m_log.DebugFormat(
"[ARCHIVER]: {0} region scene objects to save reference {1} possible assets",
sceneObjects.Count, assetUuids.Count - prevAssets + errors);
if (errors > 0)
{
m_log.DebugFormat("[ARCHIVER]: {0} of these have problems or are not assets and will be ignored", errors);
}
}
if (numObjectsSkippedPermissions > 0)
{
m_log.DebugFormat(
"[ARCHIVER]: {0} scene objects skipped due to lack of permissions",
numObjectsSkippedPermissions);
}
// Make sure that we also request terrain texture assets
RegionSettings regionSettings = scene.RegionInfo.RegionSettings;
if (regionSettings.TerrainTexture1 != RegionSettings.DEFAULT_TERRAIN_TEXTURE_1)
{
assetUuids[regionSettings.TerrainTexture1] = (sbyte)AssetType.Texture;
}
if (regionSettings.TerrainTexture2 != RegionSettings.DEFAULT_TERRAIN_TEXTURE_2)
{
assetUuids[regionSettings.TerrainTexture2] = (sbyte)AssetType.Texture;
}
if (regionSettings.TerrainTexture3 != RegionSettings.DEFAULT_TERRAIN_TEXTURE_3)
{
assetUuids[regionSettings.TerrainTexture3] = (sbyte)AssetType.Texture;
}
if (regionSettings.TerrainTexture4 != RegionSettings.DEFAULT_TERRAIN_TEXTURE_4)
{
assetUuids[regionSettings.TerrainTexture4] = (sbyte)AssetType.Texture;
}
if (scene.RegionEnvironment != null)
{
scene.RegionEnvironment.GatherAssets(assetUuids);
}
List <ILandObject> landObjects = scene.LandChannel.AllParcels();
foreach (ILandObject lo in landObjects)
{
if (lo.LandData != null && lo.LandData.Environment != null)
{
lo.LandData.Environment.GatherAssets(assetUuids);
}
}
Save(scene, sceneObjects, regionDir);
GC.Collect();
}
public void TestLoadOarV0_2RegionSettings()
{
TestHelper.InMethod();
//log4net.Config.XmlConfigurator.Configure();
MemoryStream archiveWriteStream = new MemoryStream();
TarArchiveWriter tar = new TarArchiveWriter(archiveWriteStream);
tar.WriteDir(ArchiveConstants.TERRAINS_PATH);
tar.WriteFile(ArchiveConstants.CONTROL_FILE_PATH, ArchiveWriteRequestExecution.Create0p2ControlFile());
RegionSettings rs = new RegionSettings();
rs.AgentLimit = 17;
rs.AllowDamage = true;
rs.AllowLandJoinDivide = true;
rs.AllowLandResell = true;
rs.BlockFly = true;
rs.BlockShowInSearch = true;
rs.BlockTerraform = true;
rs.DisableCollisions = true;
rs.DisablePhysics = true;
rs.DisableScripts = true;
rs.Elevation1NW = 15.9;
rs.Elevation1NE = 45.3;
rs.Elevation1SE = 49;
rs.Elevation1SW = 1.9;
rs.Elevation2NW = 4.5;
rs.Elevation2NE = 19.2;
rs.Elevation2SE = 9.2;
rs.Elevation2SW = 2.1;
rs.FixedSun = true;
rs.ObjectBonus = 1.4;
rs.RestrictPushing = true;
rs.TerrainLowerLimit = 0.4;
rs.TerrainRaiseLimit = 17.9;
rs.TerrainTexture1 = UUID.Parse("00000000-0000-0000-0000-000000000020");
rs.TerrainTexture2 = UUID.Parse("00000000-0000-0000-0000-000000000040");
rs.TerrainTexture3 = UUID.Parse("00000000-0000-0000-0000-000000000060");
rs.TerrainTexture4 = UUID.Parse("00000000-0000-0000-0000-000000000080");
rs.UseEstateSun = true;
rs.WaterHeight = 23;
tar.WriteFile(ArchiveConstants.SETTINGS_PATH + "region1.xml", RegionSettingsSerializer.Serialize(rs));
tar.Close();
MemoryStream archiveReadStream = new MemoryStream(archiveWriteStream.ToArray());
lock (this)
{
m_scene.EventManager.OnOarFileLoaded += LoadCompleted;
m_archiverModule.DearchiveRegion(archiveReadStream);
}
Assert.That(m_lastErrorMessage, Is.Null);
RegionSettings loadedRs = m_scene.RegionInfo.RegionSettings;
Assert.That(loadedRs.AgentLimit, Is.EqualTo(17));
Assert.That(loadedRs.AllowDamage, Is.True);
Assert.That(loadedRs.AllowLandJoinDivide, Is.True);
Assert.That(loadedRs.AllowLandResell, Is.True);
Assert.That(loadedRs.BlockFly, Is.True);
Assert.That(loadedRs.BlockShowInSearch, Is.True);
Assert.That(loadedRs.BlockTerraform, Is.True);
Assert.That(loadedRs.DisableCollisions, Is.True);
Assert.That(loadedRs.DisablePhysics, Is.True);
Assert.That(loadedRs.DisableScripts, Is.True);
Assert.That(loadedRs.Elevation1NW, Is.EqualTo(15.9));
Assert.That(loadedRs.Elevation1NE, Is.EqualTo(45.3));
Assert.That(loadedRs.Elevation1SE, Is.EqualTo(49));
Assert.That(loadedRs.Elevation1SW, Is.EqualTo(1.9));
Assert.That(loadedRs.Elevation2NW, Is.EqualTo(4.5));
Assert.That(loadedRs.Elevation2NE, Is.EqualTo(19.2));
Assert.That(loadedRs.Elevation2SE, Is.EqualTo(9.2));
Assert.That(loadedRs.Elevation2SW, Is.EqualTo(2.1));
Assert.That(loadedRs.FixedSun, Is.True);
Assert.That(loadedRs.ObjectBonus, Is.EqualTo(1.4));
Assert.That(loadedRs.RestrictPushing, Is.True);
Assert.That(loadedRs.TerrainLowerLimit, Is.EqualTo(0.4));
Assert.That(loadedRs.TerrainRaiseLimit, Is.EqualTo(17.9));
Assert.That(loadedRs.TerrainTexture1, Is.EqualTo(UUID.Parse("00000000-0000-0000-0000-000000000020")));
Assert.That(loadedRs.TerrainTexture2, Is.EqualTo(UUID.Parse("00000000-0000-0000-0000-000000000040")));
Assert.That(loadedRs.TerrainTexture3, Is.EqualTo(UUID.Parse("00000000-0000-0000-0000-000000000060")));
Assert.That(loadedRs.TerrainTexture4, Is.EqualTo(UUID.Parse("00000000-0000-0000-0000-000000000080")));
Assert.That(loadedRs.UseEstateSun, Is.True);
Assert.That(loadedRs.WaterHeight, Is.EqualTo(23));
}
