public static async Task <CompressedContent> Create(HttpContent content, Compressor compressor)
{
var result = new CompressedContent();
await result.CompressContent(content, compressor);
return(result);
}
private Task WriteAsync(string content, CancellationToken cancellationToken)
{
var httpContent = new StringContent(content, Encoding.UTF8, "text/plain");
var compressedContent = new CompressedContent(httpContent, CompressedContent.Compression.gzip);
return(_httpClient.PostAsync($"write?precision={_metricFormatter.Precision}", compressedContent, cancellationToken));
}
private void SetBody(HttpRequestMessage request)
{
// set body if appropriate
if (_body != null)
{
byte[] bodyBytes = null;
try {
bodyBytes = Manager.GetObjectMapper().WriteValueAsBytes(_body).ToArray();
} catch (Exception e) {
Log.To.Sync.E(Tag, "Error serializing body of request", e);
}
HttpContent entity = new ByteArrayContent(bodyBytes);
entity.Headers.ContentType = new MediaTypeHeaderValue("application/json");
if (bodyBytes.Length > 100)
{
entity = new CompressedContent(entity, "gzip");
}
request.Content = entity;
}
else
{
Log.To.Sync.W(Tag, "No body found for this request to {0}", request.RequestUri);
}
}
public static int Main(string[] args)
{
if (!Directory.Exists(CACHE_DIR))
{
Directory.CreateDirectory(CACHE_DIR);
}
var compression = CompressedContent.Default()
.Level(CompressionLevel.Optimal);
var cache = ServerCache.Persistent(CACHE_DIR)
.Invalidate(false);
var project = Project.Create()
.Add(compression)
.Add(cache);
var cachePolicy = ClientCache.Policy()
.Duration(7)
.Predicate((_, r) => r.ContentType?.KnownType != ContentType.TextHtml);
return(Host.Create()
.Handler(project)
#if DEBUG
.Development()
#endif
.Add(cachePolicy)
.Defaults()
.Console()
.Run());
}
private async void Button_Click(object sender, RoutedEventArgs e)
{
String sourceFile = "Assets/xyy.wav";
String targetFile = "xyy.mp3";
try
{
IBuffer waveDates = await ReadWave(sourceFile);
CompressedContent data = await WaveToMp3(waveDates);
byte[] mp3Data = data.Data;
DeleteFile(targetFile);
SaveFile(data.Data, targetFile);
IsolatedStorageFileStream stream = new IsolatedStorageFileStream(targetFile, FileMode.Open, IsolatedStorageFile.GetUserStoreForApplication());
mediaElement.SetSource(stream);
mediaElement.Position = new TimeSpan(0);
mediaElement.Play();
}
catch (Exception ex)
{
String s = ex.Message;
}
}
public async Task CompressedContent_LoadIntoBufferAsync_ExecutesWithoutException()
{
var innerContent = new System.Net.Http.StringContent("Jim Jimmy Jim Jim Jimney");
var compressedContent = new CompressedContent(innerContent, "deflate");
await compressedContent.LoadIntoBufferAsync().ConfigureAwait(false);
//TODO: Apart from no exception thrown, not really sure how to test this.
}
public async Task CompressedContent_ReadAsByteArrayAsync_ReturnsCompressedBytes()
{
var contentString = "Jim Jimmy Jim Jim Jimney";
var innerContent = new System.Net.Http.StringContent(contentString);
var compressedContent = new CompressedContent(innerContent, "deflate");
var result = await compressedContent.ReadAsByteArrayAsync();
Assert.IsNotNull(result);
Assert.IsTrue(result.Length < contentString.Length);
}
public void CompressingObjectContentShouldRetainContentType2()
{
//Arrange
var jsonContent = new ObjectContent<Foo>(new Foo() {Bar = "Hello"}, "application/json");
//Act
var compressedContent = new CompressedContent(jsonContent);
//Assert
Assert.AreEqual("application/json", compressedContent.Headers.ContentType.MediaType);
}
public void CompressingObjectContentShouldRetainContentType()
{
//Arrange
var stringContent = new ObjectContent<string>("Hello World", "text/plain");
//Act
var compressedContent = new CompressedContent(stringContent);
//Assert
Assert.AreEqual("text/plain", compressedContent.Headers.ContentType.MediaType);
}
public void CompressedContent_Constructor_CopiesOriginalHeaders()
{
var innerContent = new System.Net.Http.StringContent("Test");
innerContent.Headers.TryAddWithoutValidation("X-CustomHeader", "123");
var compressedContent = new CompressedContent(innerContent, "deflate");
IEnumerable <string> values;
compressedContent.Headers.TryGetValues("X-CustomHeader", out values);
Assert.AreEqual("123", values.First());
}
public void TestCustomCompression()
{
using var runner = new TestRunner();
runner.Host.Compression(CompressedContent.Default().Add(new CustomAlgorithm())).Start();
var request = runner.GetRequest();
request.Headers.Add("Accept-Encoding", "custom");
using var response = request.GetSafeResponse();
Assert.Equal("custom", response.ContentEncoding);
}
internal async Task <HttpResponseMessage> PostSqlQueryAsync(string sqlQuery, CancellationToken token, ClickHouseParameterCollection parameters = null)
{
var uri = string.Empty;
if (parameters == null)
{
uri = MakeUri();
}
else
{
var httpParametersSupported = await this.SupportsHttpParameters();
var formattedParameters = new Dictionary <string, string>(parameters.Count);
foreach (ClickHouseDbParameter parameter in parameters)
{
var formattedParameter = httpParametersSupported
? HttpParameterFormatter.Format(parameter)
: InlineParameterFormatter.Format(parameter);
formattedParameters.TryAdd(parameter.ParameterName, formattedParameter);
}
if (httpParametersSupported)
{
uri = MakeUri(null, formattedParameters);
}
else
{
sqlQuery = SubstituteParameters(sqlQuery, formattedParameters);
uri = MakeUri();
}
}
using var postMessage = new HttpRequestMessage(HttpMethod.Post, uri);
AddDefaultHttpHeaders(postMessage.Headers);
HttpContent content = new StringContent(sqlQuery);
content.Headers.ContentType = new MediaTypeHeaderValue("text/sql");
if (useCompression)
{
content = new CompressedContent(content, DecompressionMethods.GZip);
}
postMessage.Content = content;
var response = await httpClient.SendAsync(postMessage, HttpCompletionOption.ResponseHeadersRead, token).ConfigureAwait(false);
return(await HandleError(response, sqlQuery).ConfigureAwait(false));
}
public Task WriteAsync(RavenJToken tokenToWrite)
{
writeCalled = true;
return(SendRequestInternal(() =>
{
HttpContent content = new JsonContent(tokenToWrite);
if (!factory.DisableRequestCompression)
{
content = new CompressedContent(content, "gzip");
}
return new HttpRequestMessage(Method, Url)
{
Content = content,
};
}));
}
public Task WriteAsync(RavenJToken tokenToWrite)
{
writeCalled = true;
return(SendRequestInternal(() =>
{
HttpContent content = new JsonContent(tokenToWrite);
content = new CompressedContent(content, "gzip");
return new HttpRequestMessage(Method, Url)
{
Content = content,
Headers =
{
TransferEncodingChunked = !EnvironmentUtils.RunningOnPosix
}
};
}));
}
internal async Task <HttpResponseMessage> PostSqlQueryAsync(string sqlQuery, CancellationToken token)
{
using var postMessage = new HttpRequestMessage(HttpMethod.Post, MakeUri());
AddDefaultHttpHeaders(postMessage.Headers);
HttpContent content = new StringContent(sqlQuery);
content.Headers.ContentType = new MediaTypeHeaderValue("text/sql");
if (useCompression)
{
content = new CompressedContent(content, DecompressionMethods.GZip);
}
postMessage.Content = content;
var response = await httpClient.SendAsync(postMessage, HttpCompletionOption.ResponseHeadersRead, token).ConfigureAwait(false);
return(await HandleError(response, sqlQuery).ConfigureAwait(false));
}
private async void Button_WavePlay_Click(object sender, RoutedEventArgs e)
{
try
{
String sourceFile = "xyy.mp3";
String targetFile = "xyy.wave";
IBuffer waveDates = await ReadWave("Assets/" + sourceFile);
CompressedContent data = await Mp3ToWave(waveDates);
byte[] mp3Data = data.Data;
DeleteFile(targetFile);
SaveFile(data.Data, targetFile);
SoundEffect soudplay = new SoundEffect(mp3Data, 44100, AudioChannels.Stereo);
soudplay.Play();
}
catch (Exception ex)
{
String s = ex.Message;
}
}
/// <summary>
/// Configures the server host with default policies for compression and security.
/// </summary>
/// <param name="host">The host to be configured</param>
/// <param name="compression">Whether responses sent by the server should automatically be compressed</param>
/// <param name="secureUpgrade">Whether the server should automatically upgrade insecure requests</param>
/// <param name="strictTransport">Whether the server should send a strict transport policy</param>
public static IServerHost Defaults(this IServerHost host,
bool compression = true,
bool secureUpgrade = true,
bool strictTransport = true)
{
if (compression)
{
host.Compression(CompressedContent.Default());
}
if (secureUpgrade)
{
host.SecureUpgrade(SecureUpgrade.Force);
}
if (strictTransport)
{
host.StrictTransport(new StrictTransportPolicy(TimeSpan.FromDays(365), true, true));
}
return(host);
}
public async Task <bool> UploadDivesToAPI(List <LogEntryDTO> dives)
{
var json = JsonConvert.SerializeObject(dives);
var stringContent = new StringContent(json, Encoding.UTF8, "application/json");
var compressedContent = new CompressedContent(stringContent, "gzip");
try
{
var response = await _client.PostAsync("api/LogEntries", compressedContent);
if (response.IsSuccessStatusCode)
{
return(true);
}
return(false);
}
catch (Exception ex)
{
throw ex;
}
}
protected async override Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
var response = await base.SendAsync(request, cancellationToken);
if (request.Headers.AcceptEncoding != null && response.Content != null)
{
// As per RFC2616.14.3:
// Ignores encodings with quality == 0
// If multiple content-codings are acceptable, then the acceptable content-coding with the highest non-zero qvalue is preferred.
var compressor = (from encoding in request.Headers.AcceptEncoding
let quality = encoding.Quality ?? 1.0
where quality > 0
join c in Compressors on encoding.Value.ToLowerInvariant() equals c.EncodingType.ToLowerInvariant()
orderby quality descending
select c).FirstOrDefault();
if (compressor != null)
{
response.Content = await CompressedContent.Create(response.Content, compressor);
}
}
return(response);
}
public CustomLevelSelectSection()
{
levelList = new List <CustomLevel>();
isLoading = true;
isLoadingAnimation = 1f;
ThreadPool.UnsafeQueueUserWorkItem(_ => {
JsonParser json = new JsonParser();
try {
string path = PathOp.Combine(DualityApp.DataDirectory, "Episodes", "unknown");
if (DirectoryOp.Exists(path))
{
foreach (string levelPath in DirectoryOp.GetFiles(path))
{
if (api == null)
{
break;
}
if (!levelPath.EndsWith(".level"))
{
continue;
}
IFileSystem levelPackage = new CompressedContent(levelPath);
using (
Stream s = levelPackage.OpenFile(".res", FileAccessMode.Read)) {
string levelToken = PathOp.GetFileNameWithoutExtension(levelPath);
LevelConfigJson config = json.Parse <LevelConfigJson>(s);
string icon = "";
#if DEBUG
if ((config.Description.Flags & LevelFlags.FastCamera) != 0)
{
icon += " Fast";
}
if ((config.Description.Flags & LevelFlags.HasPit) != 0)
{
icon += " Pit";
}
#endif
if ((config.Description.Flags & LevelFlags.Multiplayer) != 0 && (config.Description.Flags & (LevelFlags.MultiplayerRace | LevelFlags.MultiplayerFlags)) == 0)
{
icon += " Battle";
}
if ((config.Description.Flags & LevelFlags.MultiplayerRace) != 0)
{
icon += " Race";
}
if ((config.Description.Flags & LevelFlags.MultiplayerFlags) != 0)
{
icon += " CTF";
}
levelList.Add(new CustomLevel(config.Description.Name, "unknown", levelToken, icon));
}
}
levelList.Sort((x, y) => {
string xs = BitmapFont.StripFormatting(x.DisplayName);
string ys = BitmapFont.StripFormatting(y.DisplayName);
int i = string.Compare(xs, ys, StringComparison.InvariantCulture);
if (i != 0)
{
return(i);
}
return(string.Compare(x.LevelName, y.LevelName, StringComparison.InvariantCulture));
});
}
} catch {
// ToDo: Handle exceptions
} finally {
isLoading = false;
}
}, null);
}
public bool ChangeLevel(string levelName, MultiplayerLevelType levelType)
{
string path = Path.Combine(DualityApp.DataDirectory, "Episodes", levelName + ".level");
if (!File.Exists(path))
{
return(false);
}
IFileSystem levelPackage = new CompressedContent(path);
lock (sync) {
currentLevel = levelName;
currentLevelType = levelType;
// Load new level
using (Stream s = levelPackage.OpenFile(".res", FileAccessMode.Read)) {
// ToDo: Cache parser
JsonParser json = new JsonParser();
LevelHandler.LevelConfigJson config = json.Parse <LevelHandler.LevelConfigJson>(s);
if (config.Version.LayerFormat > LevelHandler.LayerFormatVersion || config.Version.EventSet > LevelHandler.EventSetVersion)
{
throw new NotSupportedException("Version not supported");
}
currentLevelFriendlyName = BitmapFont.StripFormatting(config.Description.Name);
Log.Write(LogType.Info, "Loading level \"" + currentLevelFriendlyName + "\" (" + currentLevelType + ")...");
Point2 tileMapSize;
using (Stream s2 = levelPackage.OpenFile("Sprite.layer", FileAccessMode.Read))
using (BinaryReader r = new BinaryReader(s2)) {
tileMapSize.X = r.ReadInt32();
tileMapSize.Y = r.ReadInt32();
}
levelBounds = new Rect(tileMapSize * /*tileMap.Tileset.TileSize*/ 32);
collisions = new DynamicTreeBroadPhase <ICollisionable>();
// Read events
eventMap = new ServerEventMap(tileMapSize);
if (levelPackage.FileExists("Events.layer"))
{
using (Stream s2 = levelPackage.OpenFile("Events.layer", FileAccessMode.Read)) {
eventMap.ReadEvents(s2, config.Version.LayerFormat);
}
}
}
// Send request to change level to all players
foreach (KeyValuePair <NetConnection, Player> pair in players)
{
pair.Value.State = PlayerState.NotReady;
}
playerConnections.Clear();
foreach (KeyValuePair <NetConnection, Player> pair in players)
{
Send(new LoadLevel {
LevelName = currentLevel,
LevelType = currentLevelType,
AssignedPlayerIndex = pair.Value.Index
}, 64, pair.Key, NetDeliveryMethod.ReliableUnordered, PacketChannels.Main);
}
}
return(true);
}
public void CompressedContent_Constructor_ThrowsOnNullEncoding()
{
var innerContent = new System.Net.Http.StringContent("Test");
var compressedContent = new CompressedContent(innerContent, null);
}
public void CompressedContent_Constructor_ThrowsOnNullContent()
{
var compressedContent = new CompressedContent(null, "gzip");
}
public void CompressedContent_Constructor_ThrowsOnUnsupportedContentType()
{
var innerContent = new System.Net.Http.StringContent("Test");
var compressedContent = new CompressedContent(innerContent, "123");
}
private void PrerenderTexturedBackground()
{
try {
// Try to use "The Secret Files" background
string levelPath = PathOp.Combine(DualityApp.DataDirectory, "Episodes", "secretf", "01_easter1.level");
if (!FileOp.Exists(levelPath))
{
// Try to use "Base Game" background
levelPath = PathOp.Combine(DualityApp.DataDirectory, "Episodes", "prince", "03_carrot1.level");
if (!FileOp.Exists(levelPath))
{
// Try to use "Holiday Hare '98" background
levelPath = PathOp.Combine(DualityApp.DataDirectory, "Episodes", "xmas98", "03_xmas3.level");
if (!FileOp.Exists(levelPath))
{
// Try to use "Christmas Chronicles" background
levelPath = PathOp.Combine(DualityApp.DataDirectory, "Episodes", "xmas99", "03_xmas3.level");
if (!FileOp.Exists(levelPath))
{
// Try to use "Shareware Demo" background;
levelPath = PathOp.Combine(DualityApp.DataDirectory, "Episodes", "share", "02_share2.level");
if (!FileOp.Exists(levelPath))
{
// No usable background found
throw new FileNotFoundException();
}
}
}
}
}
// Load metadata
IFileSystem levelPackage = new CompressedContent(levelPath);
LevelHandler.LevelConfigJson config;
using (Stream s = levelPackage.OpenFile(".res", FileAccessMode.Read)) {
config = ContentResolver.Current.Json.Parse <LevelHandler.LevelConfigJson>(s);
}
LevelHandler.LevelConfigJson.LayerSection layer;
if (config.Layers.TryGetValue("Sky", out layer))
{
if (layer.BackgroundColor != null && layer.BackgroundColor.Count >= 3)
{
horizonColor = new Vector4(layer.BackgroundColor[0] / 255f, layer.BackgroundColor[1] / 255f, layer.BackgroundColor[2] / 255f, 1f);
}
switch ((BackgroundStyle)layer.BackgroundStyle)
{
default:
case BackgroundStyle.Sky:
texturedBackgroundShader = ContentResolver.Current.RequestShader("TexturedBackground");
break;
case BackgroundStyle.Circle:
texturedBackgroundShader = ContentResolver.Current.RequestShader("TexturedBackgroundCircle");
break;
}
}
// Render background layer to texture
TileSet levelTileset = new TileSet(config.Description.DefaultTileset, true, null);
if (!levelTileset.IsValid)
{
throw new InvalidDataException();
}
using (Stream s = levelPackage.OpenFile("Sky.layer", FileAccessMode.Read)) {
using (BinaryReader r = new BinaryReader(s)) {
int width = r.ReadInt32();
int height = r.ReadInt32();
TileMapLayer newLayer = new TileMapLayer();
newLayer.Layout = new LayerTile[width * height];
for (int i = 0; i < newLayer.Layout.Length; i++)
{
ushort tileType = r.ReadUInt16();
byte flags = r.ReadByte();
if (flags == 0)
{
newLayer.Layout[i] = levelTileset.GetDefaultTile(tileType);
continue;
}
bool isFlippedX = (flags & 0x01) > 0;
bool isFlippedY = (flags & 0x02) > 0;
bool isAnimated = (flags & 0x04) > 0;
bool legacyTranslucent = (flags & 0x80) > 0;
// Invalid tile numbers (higher than tileset tile amount) are silently changed to empty tiles
if (tileType >= levelTileset.TileCount && !isAnimated)
{
tileType = 0;
}
LayerTile tile;
// Copy the default tile and do stuff with it
tile = levelTileset.GetDefaultTile(tileType);
tile.IsFlippedX = isFlippedX;
tile.IsFlippedY = isFlippedY;
tile.IsAnimated = isAnimated;
if (legacyTranslucent)
{
tile.MaterialAlpha = /*127*/ 140;
}
newLayer.Layout[i] = tile;
}
newLayer.LayoutWidth = width;
RecreateTexturedBackground(levelTileset, ref newLayer);
}
}
} catch (Exception ex) {
Log.Write(LogType.Warning, "Cannot prerender textured background: " + ex);
cachedTexturedBackground = new Texture(new Pixmap(new PixelData(2, 2, ColorRgba.Black)));
}
}
private void LoadLevel(string level, string episode)
{
string levelPath = PathOp.Combine(DualityApp.DataDirectory, "Episodes", episode, level + ".level");
IFileSystem levelPackage = new CompressedContent(levelPath);
// ToDo: Cache parser, move JSON parsing to ContentResolver
JsonParser jsonParser = new JsonParser();
LevelConfigJson json;
using (Stream s = levelPackage.OpenFile(".res", FileAccessMode.Read)) {
json = jsonParser.Parse <LevelConfigJson>(s);
}
if (json.Version.LayerFormat > LayerFormatVersion || json.Version.EventSet > EventSetVersion)
{
throw new NotSupportedException("Level version not supported");
}
App.Log("Loading level \"" + json.Description.Name + "\"...");
root.Title = BitmapFont.StripFormatting(json.Description.Name);
root.Immersive = false;
defaultNextLevel = json.Description.NextLevel;
defaultSecretLevel = json.Description.SecretLevel;
ambientLightDefault = json.Description.DefaultLight;
ambientLightCurrent = ambientLightTarget = ambientLightDefault * 0.01f;
if (json.Description.DefaultDarkness != null && json.Description.DefaultDarkness.Count >= 4)
{
darknessColor = new Vector4(json.Description.DefaultDarkness[0] / 255f, json.Description.DefaultDarkness[1] / 255f, json.Description.DefaultDarkness[2] / 255f, json.Description.DefaultDarkness[3] / 255f);
}
else
{
darknessColor = new Vector4(0, 0, 0, 1);
}
// Palette
ColorRgba[] tileMapPalette;
if (levelPackage.FileExists("Main.palette"))
{
using (Stream s = levelPackage.OpenFile("Main.palette", FileAccessMode.Read)) {
tileMapPalette = TileSet.LoadPalette(s);
}
}
else
{
tileMapPalette = null;
}
// Tileset
tileMap = new TileMap(this, json.Description.DefaultTileset, tileMapPalette, (json.Description.Flags & LevelFlags.HasPit) != 0);
// Additional tilesets
if (json.Tilesets != null)
{
for (int i = 0; i < json.Tilesets.Count; i++)
{
LevelConfigJson.TilesetSection part = json.Tilesets[i];
tileMap.ReadTilesetPart(part.Name, part.Offset, part.Count);
}
}
// Read all layers
json.Layers.Add("Sprite", new LevelConfigJson.LayerSection {
XSpeed = 1,
YSpeed = 1
});
foreach (var layer in json.Layers.OrderBy(layer => layer.Value.Depth))
{
LayerType type;
if (layer.Key == "Sprite")
{
type = LayerType.Sprite;
}
else if (layer.Key == "Sky")
{
type = LayerType.Sky;
//if (layer.Value.BackgroundStyle != 0 /*Plain*/ && layer.Value.BackgroundColor != null && layer.Value.BackgroundColor.Count >= 3) {
// camera.GetComponent<Camera>().ClearColor = new ColorRgba((byte)layer.Value.BackgroundColor[0], (byte)layer.Value.BackgroundColor[1], (byte)layer.Value.BackgroundColor[2]);
//}
}
else
{
type = LayerType.Other;
}
using (Stream s = levelPackage.OpenFile(layer.Key + ".layer", FileAccessMode.Read)) {
tileMap.ReadLayerConfiguration(type, s, layer.Value);
}
}
// Read animated tiles
if (levelPackage.FileExists("Animated.tiles"))
{
using (Stream s = levelPackage.OpenFile("Animated.tiles", FileAccessMode.Read)) {
tileMap.ReadAnimatedTiles(s);
}
}
levelBounds = new Rect(tileMap.Size * tileMap.Tileset.TileSize);
// Read events
eventMap = new EventMap(this, tileMap.Size);
if (levelPackage.FileExists("Events.layer"))
{
using (Stream s2 = levelPackage.OpenFile("Events.layer", FileAccessMode.Read)) {
eventMap.ReadEvents(s2, json.Version.LayerFormat, difficulty);
}
}
GameObject tilemapHandler = new GameObject();
tilemapHandler.Parent = rootObject;
tilemapHandler.AddComponent(tileMap);
// Load default music
musicPath = PathOp.Combine(DualityApp.DataDirectory, "Music", json.Description.DefaultMusic);
music = new OpenMptStream(musicPath, true);
music.BeginFadeIn(0.5f);
DualityApp.Sound.PlaySound(music);
// Apply weather
if (json.Description.DefaultWeather != WeatherType.None)
{
ApplyWeather(
json.Description.DefaultWeather,
json.Description.DefaultWeatherIntensity,
json.Description.DefaultWeatherOutdoors);
}
// Load level text events
levelTexts = json.TextEvents ?? new List <string>();
if (FileOp.Exists(levelPath + "." + i18n.Language))
{
try {
using (Stream s = FileOp.Open(levelPath + "." + i18n.Language, FileAccessMode.Read)) {
json = jsonParser.Parse <LevelConfigJson>(s);
if (json.TextEvents != null)
{
for (int i = 0; i < json.TextEvents.Count && i < levelTexts.Count; i++)
{
if (json.TextEvents[i] != null)
{
levelTexts[i] = json.TextEvents[i];
}
}
}
}
} catch (Exception ex) {
App.Log("Cannot load i18n for this level: " + ex);
}
}
}
public void RequestTileset(string path, bool applyPalette, ColorRgba[] customPalette, out ContentRef<Material> materialRef, out PixelData mask)
{
IFileSystem tilesetPackage = new CompressedContent(PathOp.Combine(DualityApp.DataDirectory, "Tilesets", path + ".set"));
// Palette
if (applyPalette) {
if (customPalette != null) {
ApplyBasePalette(customPalette);
} else if (tilesetPackage.FileExists("Main.palette")) {
ApplyBasePalette(TileSet.LoadPalette(tilesetPackage.OpenFile("Main.palette", FileAccessMode.Read)));
}
}
// Load textures
PixelData texturePixels;
using (Stream s = tilesetPackage.OpenFile("Diffuse.png", FileAccessMode.Read)) {
texturePixels = new Png(s).GetPixelData();
}
#if !DISABLE_NORMAL_MAPPING
PixelData normalPixels;
if (tilesetPackage.FileExists("Normals.png")) {
using (Stream s = tilesetPackage.OpenFile("Normals.png", FileAccessMode.Read)) {
normalPixels = new Png(s).GetPixelData();
}
} else {
normalPixels = null;
}
#endif
using (Stream s = tilesetPackage.OpenFile("Mask.png", FileAccessMode.Read)) {
mask = new Png(s).GetPixelData();
}
// Apply palette to tileset
ColorRgba[] palette = paletteTexture.Res.BasePixmap.Res.MainLayer.Data;
ColorRgba[] data = texturePixels.Data;
#if !DISABLE_ASYNC
Parallel.ForEach(Partitioner.Create(0, data.Length), range => {
for (int i = range.Item1; i < range.Item2; i++) {
#else
for (int i = 0; i < data.Length; i++) {
#endif
int colorIdx = data[i].R;
data[i] = palette[colorIdx].WithAlpha(palette[colorIdx].A * data[i].A / (255f * 255f));
}
#if !DISABLE_ASYNC
});
#endif
ContentRef<Texture> mainTex = new Texture(new Pixmap(texturePixels));
ContentRef<Texture> normalTex;
#if !DISABLE_NORMAL_MAPPING
if (normalPixels == null) {
normalTex = DefaultNormalMap;
} else {
normalTex = new Texture(new Pixmap(normalPixels));
normalTex.Res.DetachSource();
}
#else
normalTex = DefaultNormalMap;
#endif
// Create material
Material material = new Material(RequestShader("BasicNormal"));
material.SetTexture("mainTex", mainTex);
material.SetTexture("normalTex", normalTex);
material.SetValue("normalMultiplier", Vector2.One);
materialRef = material;
}
public void CompressedContent_Constructor_ConstructsOkWithContentAndDeflateEncoding()
{
var innerContent = new System.Net.Http.StringContent("Test");
var compressedContent = new CompressedContent(innerContent, "deflate");
}
/// <summary>
/// Store takes a batch of RoutedItem, all going to the same share destination, and uploads them as a single operation. This is done to solve the many small files problem.Larger files can go individually.
/// </summary>
/// <param name="batch"></param>
/// <param name="taskID"></param>
/// <param name="connection"></param>
/// <returns></returns>
public async Task store(List <RoutedItem> batch, int taskID, LITEConnection connection)
{
Connection = connection;
var taskInfo = $"task: {taskID} connection: {Connection.name}";
StreamContent streamContent = null;
MultipartContent content = null;
HttpResponseMessage response = null;
string testFile = null;
var firstRecord = batch.First();
try
{
var stopWatch = new Stopwatch();
stopWatch.Start();
//set the URL
//string resourceURL = Connection.URL + "/api/File";
string resourceURL = Connection.URL + FileAgentConstants.BaseUrl;
_logger.Log(LogLevel.Debug, $"{taskInfo} URL: {resourceURL}");
// generate guid for boundary...boundaries cannot be accidentally found in the content
var boundary = Guid.NewGuid();
_logger.Log(LogLevel.Debug, $"{taskInfo} boundary: {boundary}");
// create the content
content = new MultipartContent("related", boundary.ToString());
//add the sharing headers
List <string> shareHeader = new List <string>();
if (Connection.shareDestinations != null)
{
foreach (var connectionSet in firstRecord.toConnections.FindAll(e => e.connectionName.Equals(Connection.name)))
{
if (connectionSet.shareDestinations != null)
{
foreach (var shareDestination in connectionSet.shareDestinations)
{
shareHeader.Add(shareDestination.boxUuid);
_logger.Log(LogLevel.Debug, $"{taskInfo} sharing to: {shareDestination.boxId} {shareDestination.boxName} {shareDestination.groupId} {shareDestination.groupName} {shareDestination.organizationName} {shareDestination.publishableBoxType}");
}
}
}
}
content.Headers.Add("X-Li-Destination", shareHeader);
long fileSize = 0;
var profile = _profileStorage.Current;
var dir = profile.tempPath + Path.DirectorySeparatorChar + Connection.name + Path.DirectorySeparatorChar + "toEGS";
Directory.CreateDirectory(dir);
testFile = dir + Path.DirectorySeparatorChar + Guid.NewGuid() + ".gz";
using (FileStream compressedFileStream = File.Create(testFile))
{
using GZipStream compressionStream = new GZipStream(compressedFileStream, CompressionMode.Compress);
foreach (var routedItem in batch)
{
if (File.Exists(routedItem.sourceFileName))
{
routedItem.stream = File.OpenRead(routedItem.sourceFileName);
if (Connection.calcCompressionStats)
{
routedItem.stream.CopyTo(compressionStream);
}
fileSize += routedItem.length;
streamContent = new StreamContent(routedItem.stream);
streamContent.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment")
{
FileName = routedItem.sourceFileName
};
content.Add(streamContent);
streamContent.Headers.Add("content-type", "application/octet-stream");
}
else
{
_logger.Log(LogLevel.Error, $"{taskInfo} {routedItem.sourceFileName} no longer exists. Increase tempFileRetentionHours for heavy transfer backlogs that may take hours!!");
routedItem.Error = "File no longer exists";
_routedItemManager.Init(routedItem);
_routedItemManager.Dequeue(Connection, Connection.toEGS, nameof(Connection.toEGS), error: true);
}
}
}
if (Connection.calcCompressionStats)
{
FileInfo info = new FileInfo(testFile);
_logger.Log(LogLevel.Information, $"{taskInfo} orgSize: {fileSize} compressedSize: {info.Length} reduction: {(fileSize == 0 ? 0 : (fileSize * 1.0 - info.Length) / (fileSize) * 100)}%");
}
// issue the POST
Task <HttpResponseMessage> task;
var httpClient = _liteHttpClient.GetClient(connection);
if (firstRecord.Compress == true)
{
var compressedContent = new CompressedContent(content, "gzip");
_logger.Log(LogLevel.Debug, $"{taskInfo} compressedContent.Headers {compressedContent.Headers} ");
compressedContent.Headers.Remove("Content-Encoding");
var cookies = _liteHttpClient.GetCookies(resourceURL);
_logger.LogCookies(cookies, taskInfo);
task = httpClient.PostAsync(resourceURL, compressedContent);
}
else
{
_logger.Log(LogLevel.Debug, $"{taskInfo} will send content.Headers {content.Headers}");
var cookies = _liteHttpClient.GetCookies(resourceURL);
_logger.LogCookies(cookies, taskInfo);
task = httpClient.PostAsync(resourceURL, content);
}
response = await task;
// output the result
_logger.LogHttpResponseAndHeaders(response, taskInfo);
_logger.Log(LogLevel.Debug, $"{taskInfo} response.Content.ReadAsStringAsync(): {await response.Content.ReadAsStringAsync()}");
stopWatch.Stop();
_logger.Log(LogLevel.Information, $"{taskInfo} elapsed: {stopWatch.Elapsed} size: {fileSize} rate: {(float)fileSize / stopWatch.Elapsed.TotalMilliseconds * 1000 / 1000000} MB/s");
switch (response.StatusCode)
{
case HttpStatusCode.Created:
//dequeue the work, we're done!
if (streamContent != null)
{
streamContent.Dispose();
}
if (response != null)
{
response.Dispose();
}
if (content != null)
{
content.Dispose();
}
foreach (var ri in batch)
{
_routedItemManager.Init(ri);
_routedItemManager.Dequeue(Connection, Connection.toEGS, nameof(Connection.toEGS));
}
//let EGGS know it's available, or when we convert udt to .net core then perhaps push so no open socket required on client.
//await SendToAllHubs(LITEServicePoint, batch);
break;
case HttpStatusCode.UnprocessableEntity:
//dequeue the work, we're done!
_logger.Log(LogLevel.Warning, $"creation of {firstRecord.sourceFileName} and others in batch failed with {response.StatusCode}");
if (streamContent != null)
{
streamContent.Dispose();
}
if (response != null)
{
response.Dispose();
}
if (content != null)
{
content.Dispose();
}
foreach (var ri in batch)
{
ri.Error = HttpStatusCode.UnprocessableEntity.ToString();
_routedItemManager.Init(ri);
_routedItemManager.Dequeue(Connection, Connection.toEGS, nameof(Connection.toEGS), error: true);
}
break;
default:
if (response.StatusCode == HttpStatusCode.Unauthorized)
{
Connection.loginNeeded = true;
}
_logger.Log(LogLevel.Warning, $"creation of {firstRecord.sourceFileName} and others in batch failed with {response.StatusCode}");
_liteHttpClient.DumpHttpClientDetails();
break;
}
//delete the compression test file
File.Delete(testFile);
}
catch (TaskCanceledException)
{
_logger.Log(LogLevel.Information, $"Task was canceled.");
}
catch (HttpRequestException e)
{
_logger.Log(LogLevel.Warning, $"{taskInfo} Exception: {e.Message} {e.StackTrace}");
if (e.InnerException != null)
{
_logger.Log(LogLevel.Warning, $"Inner Exception: {e.InnerException}");
}
_liteHttpClient.DumpHttpClientDetails();
}
catch (FileNotFoundException e)
{
_logger.Log(LogLevel.Warning, $"{taskInfo} {e.Message} {e.StackTrace}");
}
catch (IOException e)
{
_logger.Log(LogLevel.Warning, $"{taskInfo} {e.Message} {e.StackTrace}");
}
catch (Exception e)
{
_logger.LogFullException(e, taskInfo);
_liteHttpClient.DumpHttpClientDetails();
}
finally
{
try
{
if (streamContent != null)
{
streamContent.Dispose();
}
if (response != null)
{
response.Dispose();
}
if (content != null)
{
content.Dispose();
}
File.Delete(testFile);
_taskManager.Stop($"{Connection.name}.Store");
}
catch (Exception e)
{
_logger.LogFullException(e, taskInfo);
}
}
}
internal async Task <ClientResponseWithObject <T> > SendAsync <T>(HttpMethod method, object body, string urlPart, Dictionary <string, string> queryParameters, Dictionary <string, string> headers, bool useGzip = false)
{
ClientResponseWithObject <T> clientResponse = null;
var messageHandler = new ApiHttpMessageHandler(useGzip);
var jsonSerializerSettings = new JsonSerializerSettings();
jsonSerializerSettings.Converters.Add(new StringEnumConverter());
using (var client = new HttpClient(messageHandler))
{
client.BaseAddress = _configuration.ApiBaseEndpoint;
client.Timeout = _configuration.Timeout;
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
client.DefaultRequestHeaders.TryAddWithoutValidation(Constants.AuthorizationHeader, string.Format("{0} {1}", Constants.AuthorizationMethodSlamby, _configuration.ApiSecret));
client.DefaultRequestHeaders.TryAddWithoutValidation(Constants.SdkVersionHeader, GetType().GetTypeInfo().Assembly.GetName().Version.ToString());
if (_configuration.ParallelLimit > 0)
{
client.DefaultRequestHeaders.TryAddWithoutValidation(Constants.ApiParallelLimitHeader, _configuration.ParallelLimit.ToString());
}
if (useGzip)
{
client.DefaultRequestHeaders.AcceptEncoding.Add(new StringWithQualityHeaderValue("gzip"));
}
if (headers != null)
{
foreach (var header in headers)
{
client.DefaultRequestHeaders.Add(header.Key, header.Value);
}
}
HttpContent content = null;
if (body != null)
{
var json = JsonConvert.SerializeObject(body, jsonSerializerSettings);
content = new StringContent(json, Encoding.UTF8, "application/json");
if (useGzip)
{
content = new CompressedContent(content, "gzip");
}
}
else
{
content = new StringContent(string.Empty, Encoding.UTF8, "application/json");
}
HttpResponseMessage responseMsg = null;
var appendedUri = _appendQueryString(_endpoint, urlPart, queryParameters);
if (method == HttpMethod.Get)
{
responseMsg = await client.GetAsync(appendedUri);
}
else if (method == HttpMethod.Post)
{
responseMsg = await client.PostAsync(appendedUri, content);
}
else if (method == HttpMethod.Delete)
{
responseMsg = await client.DeleteAsync(appendedUri);
}
else if (method == HttpMethod.Put)
{
responseMsg = await client.PutAsync(appendedUri, content);
}
else
{
throw new NotImplementedException();
}
clientResponse = new ClientResponseWithObject <T>
{
HttpStatusCode = responseMsg.StatusCode,
IsSuccessful = responseMsg.IsSuccessStatusCode,
ServerMessage = responseMsg.ReasonPhrase
};
var respString = await responseMsg.Content.ReadAsStringAsync();
try
{
if (!string.IsNullOrEmpty(respString))
{
if (responseMsg.IsSuccessStatusCode)
{
clientResponse.ResponseObject = JsonConvert.DeserializeObject <T>(respString, jsonSerializerSettings);
}
else
{
clientResponse.Errors = JsonConvert.DeserializeObject <ErrorsModel>(respString, jsonSerializerSettings);
}
}
}
catch (JsonSerializationException ex)
{
Debug.WriteLine(ex.Message);
clientResponse.IsSuccessful = false;
clientResponse.Errors = ErrorsModel.Create("Response is not a Valid or Expected Type of JSON:\n" + respString);
}
clientResponse.ApiVersion = responseMsg.Headers.Where(header => string.Equals(header.Key, Constants.ApiVersionHeader, StringComparison.OrdinalIgnoreCase))
.SelectMany(header => header.Value)
.FirstOrDefault() ?? string.Empty;
return(clientResponse);
}
}
public async Task stowAsMultiPart(List <RoutedItem> batch, int taskID, LifeImageCloudConnection Connection, IHttpManager httpManager)
{
Throw.IfNull(Connection);
Throw.IfNull(httpManager);
var taskInfo = $"task: {taskID} connection: {Connection.name}";
StreamContent streamContent = null;
MultipartContent content = null;
HttpResponseMessage response = null;
string testFile = null;
var firstRecord = batch.First();
var httpClient = _liteHttpClient.GetClient(Connection);
try
{
var stopWatch = new Stopwatch();
stopWatch.Start();
//set the URL
//string stowURL = Connection.URL + "/api/agent/v1/stow/studies";
string stowURL = Connection.URL + CloudAgentConstants.StowStudies;
_logger.Log(LogLevel.Debug, $"{taskInfo} stowURL: {stowURL}");
// generate guid for boundary...boundaries cannot be accidentally found in the content
var boundary = Guid.NewGuid();
_logger.Log(LogLevel.Debug, $"{taskInfo} boundary: {boundary}");
// create the content
content = new MultipartContent("related", boundary.ToString());
//add the sharing headers
List <string> shareHeader = new List <string>();
if (Connection.shareDestinations != null)
{
foreach (var connectionSet in firstRecord.toConnections.FindAll(e =>
e.connectionName.Equals(Connection.name)))
{
if (connectionSet.shareDestinations != null)
{
foreach (var shareDestination in connectionSet.shareDestinations)
{
shareHeader.Add(shareDestination.boxUuid);
_logger.Log(LogLevel.Debug,
$"{taskInfo} sharing to: {shareDestination.boxId} {shareDestination.boxName} {shareDestination.groupId} {shareDestination.groupName} {shareDestination.organizationName} {shareDestination.publishableBoxType}");
}
}
}
}
content.Headers.Add("X-Li-Destination", shareHeader);
long fileSize = 0;
var dir = _profileStorage.Current.tempPath + Path.DirectorySeparatorChar + Connection.name + Path.DirectorySeparatorChar + Constants.Dirs.ToCloud;
Directory.CreateDirectory(dir);
testFile = dir + Path.DirectorySeparatorChar + Guid.NewGuid() + ".gz";
using (FileStream compressedFileStream = File.Create(testFile))
{
using GZipStream compressionStream = new GZipStream(compressedFileStream, CompressionMode.Compress);
foreach (var routedItem in batch)
{
if (File.Exists(routedItem.sourceFileName))
{
routedItem.stream = File.OpenRead(routedItem.sourceFileName);
if (Connection.CalcCompressionStats)
{
routedItem.stream.CopyTo(compressionStream);
}
fileSize += routedItem.length;
streamContent = new StreamContent(routedItem.stream);
streamContent.Headers.ContentDisposition =
new ContentDispositionHeaderValue("attachment")
{
FileName = routedItem.sourceFileName
};
content.Add(streamContent);
//shb 2017-11-01 streamcontent (uncompressed) is inside content (can be compressed below) server is complaining so will comment out
//streamContent.Headers.Add("Content-Transfer-Encoding", "gzip");
//shb 2017-11-10 shb added content-type header to solve
//controller.DicomRSControllerBase: Content-Encoding header has value null !!!
//controller.StowRSController: Unable to process part 1 no content-type parameter received
streamContent.Headers.Add("content-type", "application/dicom");
}
else
{
_logger.Log(LogLevel.Error,
$"{taskInfo} {routedItem.sourceFileName} no longer exists. Increase tempFileRetentionHours for heavy transfer backlogs that may take hours!!");
}
}
}
if (Connection.CalcCompressionStats)
{
FileInfo info = new FileInfo(testFile);
_logger.Log(LogLevel.Information, $"{taskInfo} orgSize: {fileSize} compressedSize: {info.Length} reduction: {(fileSize == 0 ? 0 : (fileSize * 1.0 - info.Length) / (fileSize) * 100)}%");
}
// issue the POST
Task <HttpResponseMessage> task;
if (firstRecord.Compress == true)
{
var compressedContent = new CompressedContent(content, "gzip");
_logger.Log(LogLevel.Debug, $"{taskInfo} compressedContent.Headers {compressedContent.Headers} ");
var cookies = _liteHttpClient.GetCookies(stowURL);
_logger.LogCookies(cookies, taskInfo);
task = httpClient.PostAsync(stowURL, compressedContent, _taskManager.cts.Token);
}
else
{
_logger.Log(LogLevel.Debug, $"{taskInfo} will send content.Headers {content.Headers}");
var cookies = _liteHttpClient.GetCookies(stowURL);
_logger.LogCookies(cookies, taskInfo);
task = httpClient.PostAsync(stowURL, content, _taskManager.cts.Token);
}
response = await task;
// output the result
_logger.LogHttpResponseAndHeaders(response, taskInfo);
_logger.Log(LogLevel.Debug, $"{taskInfo} response.Content.ReadAsStringAsync(): {await response.Content.ReadAsStringAsync()}");
stopWatch.Stop();
_logger.Log(LogLevel.Information, $"{taskInfo} elapsed: {stopWatch.Elapsed} size: {fileSize} rate: {(float)fileSize / stopWatch.Elapsed.TotalMilliseconds * 1000 / 1000000} MB/s");
if (!(response.StatusCode == HttpStatusCode.OK ||
response.StatusCode == HttpStatusCode.Accepted))
{
if (response.StatusCode == HttpStatusCode.Unauthorized)
{
httpManager.loginNeeded = true;
}
_logger.Log(LogLevel.Warning,
$"stow of {firstRecord.sourceFileName} and others in batch failed with {response.StatusCode}");
_liteHttpClient.DumpHttpClientDetails();
}
else
{
//dequeue the work, we're done!
if (streamContent != null)
{
streamContent.Dispose();
}
if (response != null)
{
response.Dispose();
}
if (content != null)
{
content.Dispose();
}
foreach (var ri in batch)
{
_routedItemManager.Init(ri);
_routedItemManager.Dequeue(Connection, Connection.toCloud, nameof(Connection.toCloud));
}
}
//delete the compression test file
File.Delete(testFile);
}
catch (TaskCanceledException)
{
_logger.Log(LogLevel.Information, $"{taskInfo} Task was canceled.");
}
catch (HttpRequestException e)
{
_logger.Log(LogLevel.Warning, $"{taskInfo} Exception: {e.Message} {e.StackTrace}");
if (e.InnerException != null)
{
_logger.Log(LogLevel.Warning, $"{taskInfo} Inner Exception: {e.InnerException}");
}
_liteHttpClient.DumpHttpClientDetails();
}
catch (FileNotFoundException e)
{
_logger.Log(LogLevel.Warning, $"{taskInfo} {e.Message} {e.StackTrace}");
}
catch (IOException e)
{
_logger.Log(LogLevel.Warning, $"{taskInfo} {e.Message} {e.StackTrace}");
}
catch (Exception e)
{
_logger.LogFullException(e, taskInfo);
_liteHttpClient.DumpHttpClientDetails();
}
finally
{
try
{
if (streamContent != null)
{
streamContent.Dispose();
}
if (response != null)
{
response.Dispose();
}
if (content != null)
{
content.Dispose();
}
File.Delete(testFile);
_taskManager.Stop($"{Connection.name}.Stow");
}
catch (Exception e)
{
_logger.LogFullException(e, taskInfo);
}
}
}
private void LoadLevel(string level, string episode)
{
string levelPath = PathOp.Combine(DualityApp.DataDirectory, "Episodes", episode, level + ".level");
IFileSystem levelPackage = new CompressedContent(levelPath);
LevelConfigJson json;
using (Stream s = levelPackage.OpenFile(".res", FileAccessMode.Read)) {
json = ContentResolver.Current.Json.Parse <LevelConfigJson>(s);
}
if (json.Version.LayerFormat > LayerFormatVersion || json.Version.EventSet > EventSetVersion)
{
throw new NotSupportedException("Level version not supported");
}
Log.Write(LogType.Info, "Loading level \"" + json.Description.Name + "\"...");
levelFriendlyName = json.Description.Name;
//defaultNextLevel = json.Description.NextLevel;
//defaultSecretLevel = json.Description.SecretLevel;
// Palette
ColorRgba[] tileMapPalette;
if (levelPackage.FileExists("Main.palette"))
{
using (Stream s = levelPackage.OpenFile("Main.palette", FileAccessMode.Read)) {
tileMapPalette = TileSet.LoadPalette(s);
}
}
else
{
tileMapPalette = null;
}
// Tileset
tileMap = new TileMap(this, json.Description.DefaultTileset, tileMapPalette, (json.Description.Flags & LevelFlags.HasPit) != 0);
// Additional tilesets
if (json.Tilesets != null)
{
for (int i = 0; i < json.Tilesets.Count; i++)
{
LevelConfigJson.TilesetSection part = json.Tilesets[i];
tileMap.ReadTilesetPart(part.Name, part.Offset, part.Count);
}
}
// Read all layers
json.Layers.Add("Sprite", new LevelConfigJson.LayerSection {
XSpeed = 1,
YSpeed = 1
});
foreach (var layer in json.Layers.OrderBy(layer => layer.Value.Depth))
{
LayerType type;
if (layer.Key == "Sprite")
{
type = LayerType.Sprite;
}
else if (layer.Key == "Sky")
{
type = LayerType.Sky;
//if (layer.Value.BackgroundStyle != 0 /*Plain*/ && layer.Value.BackgroundColor != null && layer.Value.BackgroundColor.Count >= 3) {
// camera.GetComponent<Camera>().ClearColor = new ColorRgba((byte)layer.Value.BackgroundColor[0], (byte)layer.Value.BackgroundColor[1], (byte)layer.Value.BackgroundColor[2]);
//}
}
else
{
type = LayerType.Other;
}
using (Stream s = levelPackage.OpenFile(layer.Key + ".layer", FileAccessMode.Read)) {
tileMap.ReadLayerConfiguration(type, s, layer.Value);
}
}
// Read animated tiles
if (levelPackage.FileExists("Animated.tiles"))
{
using (Stream s = levelPackage.OpenFile("Animated.tiles", FileAccessMode.Read)) {
tileMap.ReadAnimatedTiles(s);
}
}
levelBounds = new Rect(tileMap.Size * tileMap.Tileset.TileSize);
// Read events
eventMap = new EventMap(this, tileMap.Size);
if (levelPackage.FileExists("Events.layer"))
{
using (Stream s2 = levelPackage.OpenFile("Events.layer", FileAccessMode.Read)) {
eventMap.ReadEvents(s2, json.Version.LayerFormat, difficulty);
}
}
GameObject tilemapHandler = new GameObject();
tilemapHandler.Parent = rootObject;
tilemapHandler.AddComponent(tileMap);
// Apply weather
if (json.Description.DefaultWeather != WeatherType.None)
{
ApplyWeather(
json.Description.DefaultWeather,
json.Description.DefaultWeatherIntensity,
json.Description.DefaultWeatherOutdoors);
}
// Load level text events
levelTexts = json.TextEvents ?? new List <string>();
/*if (FileOp.Exists(levelPath + "." + i18n.Language)) {
* try {
* using (Stream s = FileOp.Open(levelPath + "." + i18n.Language, FileAccessMode.Read)) {
* json = ContentResolver.Current.Json.Parse<LevelConfigJson>(s);
* if (json.TextEvents != null) {
* for (int i = 0; i < json.TextEvents.Count && i < levelTexts.Count; i++) {
* if (json.TextEvents[i] != null) {
* levelTexts[i] = json.TextEvents[i];
* }
* }
* }
* }
* } catch (Exception ex) {
* Log.Write(LogType.Warning, "Cannot load i18n for this level: " + ex);
* }
* }*/
eventMap.ActivateEvents(int.MinValue, int.MinValue, int.MaxValue, int.MaxValue, false);
}
