private void LoadBlockStates()
{
var idMapping = new Dictionary <uint, string>();
using (var idMappingJsonFile =
typeof(MinecraftResourcePack).Assembly.GetManifestResourceStream(
typeof(MinecraftResourcePack).Namespace + ".blockstate-ids.json"))
{
using (var reader = new StreamReader(idMappingJsonFile))
{
var json = reader.ReadToEnd();
idMapping = MCJsonConvert.DeserializeObject <Dictionary <uint, string> >(json);
}
}
foreach (var kvp in idMapping)
{
_blockStateIds.Add(kvp.Key, kvp.Value);
}
var jsonFiles = _archive.Entries
.Where(e => e.FullName.StartsWith("assets/minecraft/blockstates/") && e.FullName.EndsWith(".json")).ToArray();
foreach (var jsonFile in jsonFiles)
{
using (var r = new StreamReader(jsonFile.Open()))
{
var blockState = MCJsonConvert.DeserializeObject <BlockState>(r.ReadToEnd());
ProcessBlockState(blockState);
_blockStates[jsonFile.Name.Replace(".json", "")] = blockState;
}
}
}
private void LoadBlockState(ZipArchiveEntry entry, Match match)
{
try
{
string name = match.Groups["filename"].Value;
string nameSpace = match.Groups["namespace"].Value;
string key = $"{nameSpace}:{name}";
using (var stream = entry.Open())
{
var json = Encoding.UTF8.GetString(stream.ReadToSpan(entry.Length));
var blockState = MCJsonConvert.DeserializeObject <BlockStateResource>(json);
blockState.Name = name;
blockState.Namespace = nameSpace;
_blockStates[key] = blockState;
//return blockState;
}
}
catch (Exception ex)
{
Log.Warn($"Could not load {entry.Name}!", ex);
// return null;
}
}
private BlockModel LoadBlockModel(ZipArchiveEntry entry, Match match)
{
try
{
string name = match.Groups["filename"].Value.Replace("\\", "/");
string nameSpace = match.Groups["namespace"].Value;
using (var stream = entry.Open())
{
var blockModel = MCJsonConvert.DeserializeObject <BlockModel>(Encoding.UTF8.GetString(stream.ReadToSpan(entry.Length)));
blockModel.Name = name; // name.Replace("block/", "");
blockModel.Namespace = nameSpace;
if (blockModel.ParentName != null)
{
//blockModel.ParentName = blockModel.ParentName.Replace("block/", "");
}
//blockModel = ProcessBlockModel(blockModel);
//_blockModels[$"{nameSpace}:{name}"] = blockModel;
return(blockModel);
}
}
catch (Exception ex)
{
Log.Error(ex, $"Error loading blockmodel.");
return(null);
}
}
private bool TryGetBlockModel(string modelName, out BlockModel model)
{
model = null;
var modelFile =
_archive.Entries.FirstOrDefault(e => e.FullName.Equals("assets/minecraft/models/" + modelName + ".json"));
if (modelFile == null)
{
Debug.WriteLine("Failed to load Block Model: File Not Found (" + "assets/minecraft/models/" + modelName + ".json)");
return(false);
}
using (var r = new StreamReader(modelFile.Open()))
{
var json = r.ReadToEnd();
try
{
var blockModel = MCJsonConvert.DeserializeObject <BlockModel>(json);
blockModel.Name = modelName;
ProcessBlockModel(blockModel);
_blockModelsCache[modelName] = blockModel;
model = blockModel;
return(true);
}
catch (JsonException ex)
{
Debug.WriteLine("Failed to load Block Model: " + modelName);
throw;
}
}
}
private void LoadBlockState(ZipArchiveEntry entry, Match match)
{
try
{
string name = match.Groups["filename"].Value;
string nameSpace = match.Groups["namespace"].Value;
using (var r = new StreamReader(entry.Open()))
{
var json = r.ReadToEnd();
var blockState = MCJsonConvert.DeserializeObject <BlockStateResource>(json);
blockState.Name = name;
blockState.Namespace = nameSpace;
_blockStates[$"{nameSpace}:{name}"] = blockState;
//return blockState;
}
}
catch (Exception ex)
{
Log.Warn($"Could not load {entry.Name}!", ex);
// return null;
}
}
private void LoadLocalization(ZipArchiveEntry entry, Match match)
{
string name = match.Groups["filename"].Value;
string nameSpace = match.Groups["namespace"].Value;
bool isJson = match.Groups["filetype"].Value.Equals("json", StringComparison.InvariantCultureIgnoreCase);
using (var stream = entry.Open())
{
var text = Encoding.UTF8.GetString(stream.ReadToSpan(entry.Length));
LanguageResource lang;
if (isJson)
{
lang = MCJsonConvert.DeserializeObject <LanguageResource>(text);
}
else
{
lang = LanguageResource.ParseLangFile(text);
}
lang.CultureName = name;
lang.Namespace = nameSpace;
_languageCache[$"{nameSpace}:{name}"] = lang;
}
}
private void ProcessBlockModel(BlockModel model)
{
if (model.ParentName != null)
{
BlockModel parent;
if (TryGetBlockModel(model.ParentName, out parent))
{
model.Parent = parent;
if (model.Elements.Length == 0 && parent.Elements.Length > 0)
{
model.Elements = MCJsonConvert.DeserializeObject <BlockModelElement[]>(MCJsonConvert.SerializeObject(parent.Elements));
}
foreach (var kvp in parent.TextureDefinitions)
{
if (!model.TextureDefinitions.ContainsKey(kvp.Key))
{
model.TextureDefinitions.Add(kvp.Key, kvp.Value);
}
}
foreach (var kvp in parent.Textures)
{
if (!model.Textures.ContainsKey(kvp.Key))
{
model.Textures.Add(kvp.Key, kvp.Value);
}
}
}
}
foreach (var textureDef in model.TextureDefinitions.OrderBy(e => e.Value.StartsWith("#")).ToArray())
{
//Debug.WriteLine("Lookup Texture {2}: {0} {1}", textureDef.Key, textureDef.Value, model.Name);
if (!model.Textures.ContainsKey(textureDef.Key))
{
Bitmap texture;
if (TryGetTexture(model, textureDef.Value, out texture))
{
model.Textures[textureDef.Key] = texture;
}
}
}
foreach (var element in model.Elements)
{
foreach (var face in element.Faces)
{
face.Value.Texture = GetBitmapFromBlockModel(model, face.Value.TextureName);
if (face.Value.Texture == null)
{
//Debug.WriteLine("Failed to find texture for face {0} on block {1}", face.Key, model.Name);
}
}
}
}
private void Load(ZipArchive archive)
{
var manifestEntry = archive.GetEntry("manifest.json");
var contentEntry = archive.GetEntry("content.zipe");
if (manifestEntry == null)
{
throw new InvalidMCPackException("No manifest found!");
}
Manifest = MCJsonConvert.DeserializeObject <McPackManifest>(manifestEntry.ReadAsString());
if (contentEntry == null)
{
throw new InvalidMCPackException($"No content found for MCPack: {Manifest.Header.Name}");
}
List <MCPackModule> modules = new List <MCPackModule>();
foreach (var module in Manifest.Modules)
{
switch (module.Type.ToLower())
{
case "skin_pack":
try
{
MCSkinPack skinPack = new MCSkinPack(contentEntry);
modules.Add(skinPack);
}
catch
{
}
break;
}
}
List <MCPackModule> toRemove = new List <MCPackModule>();
foreach (var module in modules)
{
try
{
module.Load();
}
catch (Exception ex)
{
Log.Error(ex, $"Failed to load MCPack module: {module.Name} from {Manifest.Header.Name}: {ex}");
toRemove.Add(module);
}
}
foreach (var rm in toRemove)
{
modules.Remove(rm);
}
Modules = modules.ToArray();
}
/// <inheritdoc />
internal override bool Load()
{
try
{
List <LoadedSkin> skins = new List <LoadedSkin>();
using (var archive = new ZipFileSystem(Entry.Open(), Entry.Name))
{
var skinsEntry = archive.GetEntry("skins.json");
Info = MCJsonConvert.DeserializeObject <MCPackSkins>(skinsEntry.ReadAsString());
var geometryEntry = archive.GetEntry("geometry.json");
Dictionary <string, EntityModel> models =
MCJsonConvert.DeserializeObject <Dictionary <string, EntityModel> >(geometryEntry.ReadAsString());
foreach (var skin in Info.Skins)
{
EntityModel model;
if (!models.TryGetValue(skin.Geometry, out model))
{
continue;
}
var textureEntry = archive.GetEntry(skin.Texture);
if (textureEntry == null)
{
continue;
}
Image <Rgba32> img;
using (var s = textureEntry.Open())
{
//img = new Bitmap(s);
img = Image.Load <Rgba32>(s.ReadToSpan(textureEntry.Length), PngDecoder);
}
LoadedSkin loaded = new LoadedSkin(skin.LocalizationName, model, img);
skins.Add(loaded);
//skin.
}
}
Skins = skins.ToArray();
return(true);
}
catch (InvalidDataException ex)
{
Log.Debug(ex, $"Could not load module.");
}
return(false);
}
private Tag LoadTag(ZipArchiveEntry entry)
{
string nameSpace = entry.FullName.Split('/')[1];
string name = Path.GetFileNameWithoutExtension(entry.FullName);
using (var r = new StreamReader(entry.Open()))
{
var blockModel = MCJsonConvert.DeserializeObject <Tag>(r.ReadToEnd());
blockModel.Name = name;
blockModel.Namespace = nameSpace;
blockModel = ProcessTag(blockModel);
return(blockModel);
}
}
protected static ResourcePackManifest GetManifest(ZipArchive archive, ResourcePackType type)
{
if (type == ResourcePackType.Java)
{
var entry = archive.GetEntry("pack.mcmeta");
if (entry != null)
{
ResourcePackInfo info;
using (TextReader reader = new StreamReader(entry.Open()))
{
ResourcePackInfoWrapper wrap = MCJsonConvert.DeserializeObject <ResourcePackInfoWrapper>(reader.ReadToEnd());
info = wrap.pack;
}
try
{
var imgEntry = archive.GetEntry("pack.png");
if (imgEntry != null)
{
// Bitmap bmp = new Bitmap(imgEntry.Open());
using (var stream = imgEntry.Open())
{
var bmp = Image.Load <Rgba32>(stream.ReadToSpan(entry.Length));
return(new ResourcePackManifest(bmp, "", info.Description));
}
}
}
catch (Exception ex)
{
Log.Warn(ex, $"Could not read resourcepack logo: {archive.ToString()}");
}
return(new ResourcePackManifest("", info.Description));
}
else
{
throw new InvalidResourcePackException();
}
}
else if (type == ResourcePackType.Bedrock)
{
}
return(null);
}
private ResourcePackItem LoadItemModel(ZipArchiveEntry entry, Match match)
{
string name = match.Groups["filename"].Value.Replace("\\", "/");
string nameSpace = match.Groups["namespace"].Value;
using (var stream = entry.Open())
{
var blockModel = MCJsonConvert.DeserializeObject <ResourcePackItem>(Encoding.UTF8.GetString(stream.ReadToSpan(entry.Length)));
blockModel.Name = name; //name.Replace("item/", "");
blockModel.Namespace = nameSpace;
if (blockModel.ParentName != null)
{
// blockModel.ParentName = blockModel.ParentName.Replace("item/", "");
}
return(blockModel);
}
}
private ResourcePackItem LoadItemModel(ZipArchiveEntry entry, Match match)
{
string name = match.Groups["filename"].Value;
string nameSpace = match.Groups["namespace"].Value;
using (var r = new StreamReader(entry.Open()))
{
var blockModel = MCJsonConvert.DeserializeObject <ResourcePackItem>(r.ReadToEnd());
blockModel.Name = name; //name.Replace("item/", "");
blockModel.Namespace = nameSpace;
if (blockModel.ParentName != null)
{
// blockModel.ParentName = blockModel.ParentName.Replace("item/", "");
}
return(blockModel);
}
}
/// <inheritdoc />
internal override void Load()
{
List <LoadedSkin> skins = new List <LoadedSkin>();
using (var archive = new ZipArchive(Entry.Open(), ZipArchiveMode.Read))
{
var skinsEntry = archive.GetEntry("skins.json");
Info = MCJsonConvert.DeserializeObject <MCPackSkins>(skinsEntry.ReadAsString());
var geometryEntry = archive.GetEntry("geometry.json");
Dictionary <string, EntityModel> models =
MCJsonConvert.DeserializeObject <Dictionary <string, EntityModel> >(geometryEntry.ReadAsString());
foreach (var skin in Info.Skins)
{
EntityModel model;
if (!models.TryGetValue(skin.Geometry, out model))
{
continue;
}
var textureEntry = archive.GetEntry(skin.Texture);
if (textureEntry == null)
{
continue;
}
Image <Rgba32> img;
using (var s = textureEntry.Open())
{
//img = new Bitmap(s);
img = Image.Load <Rgba32>(s.ReadToSpan(textureEntry.Length), PngDecoder);
}
LoadedSkin loaded = new LoadedSkin(skin.LocalizationName, model, img);
skins.Add(loaded);
//skin.
}
}
Skins = skins.ToArray();
}
private ResourcePackModelBase ReadModel(ZipArchiveEntry entry, ResourceLocation location)
{
try
{
using (var stream = entry.Open())
{
var model = MCJsonConvert.DeserializeObject <ResourcePackModelBase>(Encoding.UTF8.GetString(stream.ReadToSpan(entry.Length)));
model.Type = location.Path.Contains("block/", StringComparison.InvariantCultureIgnoreCase) ?
ModelType.Block : ModelType.Item;
return(model);
}
}
catch (Exception ex)
{
Log.Error(ex, $"Error loading model.");
return(null);
}
}
private void LoadMeta(ZipArchive archive)
{
ResourcePackInfo info;
var entry = archive.GetEntry("pack.mcmeta");
if (entry == null)
{
info = new ResourcePackInfo();
}
else
{
using (TextReader reader = new StreamReader(entry.Open()))
{
ResourcePackInfoWrapper wrap = MCJsonConvert.DeserializeObject <ResourcePackInfoWrapper>(reader.ReadToEnd());
info = wrap.pack;
}
}
Info = info;
}
private void LoadMeta(ZipArchive archive)
{
ResourcePackInfo info;
var entry = archive.GetEntry("pack.mcmeta");
if (entry == null)
{
info = new ResourcePackInfo();
}
else
{
using (var stream = entry.Open())
{
ResourcePackInfoWrapper wrap =
MCJsonConvert.DeserializeObject <ResourcePackInfoWrapper>(
Encoding.UTF8.GetString(stream.ReadToSpan(entry.Length)));
info = wrap.pack;
}
}
Info = info;
}
protected static ResourcePackManifest GetManifest(ZipArchive archive, ResourcePackType type)
{
if (type == ResourcePackType.Java)
{
var entry = archive.GetEntry("pack.mcmeta");
if (entry != null)
{
ResourcePackInfo info;
using (TextReader reader = new StreamReader(entry.Open()))
{
ResourcePackInfoWrapper wrap = MCJsonConvert.DeserializeObject <ResourcePackInfoWrapper>(reader.ReadToEnd());
info = wrap.pack;
}
var imgEntry = archive.GetEntry("pack.png");
if (imgEntry != null)
{
// Bitmap bmp = new Bitmap(imgEntry.Open());
var bmp = Image.Load <Rgba32>(imgEntry.Open());
return(new ResourcePackManifest(bmp, "", info.Description));
}
else
{
return(new ResourcePackManifest("", info.Description));
}
}
else
{
throw new InvalidResourcePackException();
}
}
else if (type == ResourcePackType.Bedrock)
{
}
return(null);
}
private void InitializeGame(IProgressReceiver progressReceiver)
{
progressReceiver.UpdateProgress(0, "Initializing...");
API.Extensions.Init(GraphicsDevice);
MCPacketFactory.Load();
//ConfigureServices();
var eventDispatcher = Services.GetRequiredService <IEventDispatcher>() as EventDispatcher;
foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
{
eventDispatcher.LoadFrom(assembly);
}
//var options = Services.GetService<IOptionsProvider>();
// Log.Info($"Loading resources...");
if (!Resources.CheckResources(GraphicsDevice, progressReceiver,
OnResourcePackPreLoadCompleted))
{
Console.WriteLine("Press enter to exit...");
Console.ReadLine();
Exit();
return;
}
var profileManager = Services.GetService <ProfileManager>();
profileManager.LoadProfiles(progressReceiver);
//GuiRenderer.LoadResourcePack(Resources.ResourcePack, null);
AnvilWorldProvider.LoadBlockConverter();
PluginManager.EnablePlugins();
var storage = Services.GetRequiredService <IStorageSystem>();
if (storage.TryReadString("skin.json", out var str, Encoding.UTF8))
{
//var entries = new Dictionary<string, EntityModel>();
//EntityModel.GetEntries(str, entries);
var geometryModel =
MCJsonConvert.DeserializeObject <GeometryModel>(str);
var model = geometryModel.FindGeometry("geometry.humanoid.custom");
if (model == null)
{
model = geometryModel.FindGeometry("geometry.humanoid.customSlim");
}
if (model != null)
{
PlayerModel = model;
}
}
if (PlayerModel == null)
{
if (ModelFactory.TryGetModel("geometry.humanoid.customSlim", out var model))
{
model.Name = "geometry.humanoid.customSlim";
PlayerModel = model;
}
}
if (PlayerModel != null)
{
Log.Info($"Player model loaded...");
}
if (storage.TryReadBytes("skin.png", out byte[] skinBytes))
public static ResourcePackManifest GetManifest(IFilesystem archive)
{
//if (archive.GetEntry("pack.mcmeta") != null)
var entry = archive.GetEntry("pack.mcmeta");
if (entry != null)
{
ResourcePackInfo info;
using (TextReader reader = new StreamReader(entry.Open()))
{
ResourcePackInfoWrapper wrap =
MCJsonConvert.DeserializeObject <ResourcePackInfoWrapper>(reader.ReadToEnd());
info = wrap.pack;
}
try
{
var imgEntry = archive.GetEntry("pack.png");
if (imgEntry != null && imgEntry.Length > 0)
{
// Bitmap bmp = new Bitmap(imgEntry.Open());
using (var stream = imgEntry.Open())
{
//var data = stream.ReadToSpan(entry.Length);
var bmp = Image.Load(stream).CloneAs <Rgba32>();
return(new ResourcePackManifest(bmp, "", info.Description, ResourcePackType.Java));
}
}
}
catch (Exception ex)
{
Log.Warn(ex, $"Could not read resourcepack logo: {archive.ToString()}");
}
return(new ResourcePackManifest("", info.Description, ResourcePackType.Java));
}
entry = archive.GetEntry("manifest.json");
if (entry != null)
{
//Load bedrock meta
McPackManifest info;
using (TextReader reader = new StreamReader(entry.Open()))
{
info =
MCJsonConvert.DeserializeObject <McPackManifest>(reader.ReadToEnd());
//info = new ResourcePackInfo() {Description = wrap.Header.Description};
//info = wrap.pack;
}
try
{
var imgEntry = archive.GetEntry("pack_icon.png");
if (imgEntry != null && imgEntry.Length > 0)
{
// Bitmap bmp = new Bitmap(imgEntry.Open());
using (var stream = imgEntry.Open())
{
//var data = stream.ReadToSpan(entry.Length);
var bmp = Image.Load(stream).CloneAs <Rgba32>();
return(new ResourcePackManifest(bmp, info.Header.Name, info.Header.Description, ResourcePackType.Bedrock));
}
}
}
catch (Exception ex)
{
Log.Warn(ex, $"Could not read resourcepack logo: {archive.ToString()}");
}
return(new ResourcePackManifest(info.Header.Name, info.Header.Description, ResourcePackType.Bedrock));
}
return(null);
}
