public static BlockStateModel[] GetModels(BlockState blockState, BlockStateResource resource)
{
List <BlockStateModel> resultingModels = new List <BlockStateModel>(resource.Parts.Length);
foreach (var s in resource.Parts)
{
if (s.When == null)
{
resultingModels.AddRange(s.Apply);
}
else if (s.When.Length > 0)
{
bool passes = true;
foreach (var rule in s.When)
{
if (!PassesMultiPartRule(rule, blockState))
{
passes = false;
break;
}
}
if (passes)
{
resultingModels.AddRange(s.Apply);
}
}
}
return(resultingModels.ToArray());
}
public bool TryGetBlockState(string modelName, out BlockStateResource stateResource)
{
if (_blockStates.TryGetValue(modelName, out stateResource))
{
return(true);
}
stateResource = null;
return(false);
}
public bool TryGetBlockState(string location, out BlockStateResource resource)
{
resource = null;
foreach (var resourcePack in ActiveResourcePacks.Reverse())
{
if (resourcePack.TryGetBlockState(location, out resource))
{
return(true);
}
}
return(false);
}
private static BlockStateVariant ResolveVariant(BlockStateResource blockStateResource, BlockState state)
{
if (state.VariantMapper.IsMultiPart)
{
return(new BlockStateVariant(MultiPartModelHelper.GetModels(state, blockStateResource)));
}
int closestMatch = -1;
KeyValuePair <string, BlockStateVariant> closest = default(KeyValuePair <string, BlockStateVariant>);
foreach (var v in blockStateResource.Variants)
{
int matches = 0;
//var variantBlockState = Blocks.State.BlockState.FromString(v.Key);
var variant = Blocks.State.BlockState.ParseData(v.Key);
foreach (var kv in state)
{
if (variant.TryGetValue(kv.Key, out string vValue))
{
if (vValue.Equals(kv.Value, StringComparison.OrdinalIgnoreCase))
{
matches++;
}
else
{
break;
}
}
else
{
break;
}
}
if (matches > closestMatch)
{
closestMatch = matches;
closest = v;
if (matches == state.Count)
{
break;
}
}
}
return(closest.Value);
}
//private BoundingBox[] Boxes { get; set; }
//private bool UseRandomizer { get; set; }
//private int WeightSum { get; }
public ResourcePackBlockModel(ResourceManager resources, BlockStateResource blockStateResource)
{
Resources = resources;
//Models = models.Where(x => x != null).ToArray();
//Models = models;
// UseRandomizer = useRandomizer;
//WeightSum = Models.Sum(x => x.BlockStateModel.Weight);
//Boxes = CalculateBoundingBoxes(Models);
/*
* Boxes = new BoundingBox[] {new BoundingBox(new Vector3(0f), new Vector3(1f))};
* for (int i = 0; i < Boxes.Length; i++)
* {
* var box = Boxes[i];
* var dimensions = box.GetDimensions();
*
* if (dimensions.X < 0.015f)
* {
* var diff = (0.015f - dimensions.X) / 2f;
* box.Min.X -= diff;
* box.Max.X += diff;
* //box.Inflate(new Vector3(0.015f - dimensions.X, 0f, 0f));
* }
*
* if (dimensions.Y < 0.015f)
* {
* var diff = (0.015f - dimensions.Y) / 2f;
* box.Min.Y -= diff;
* box.Max.Y += diff;
* //box.Inflate(new Vector3(0f, 0.015f - dimensions.Y, 0f));
* }
*
* if (dimensions.Z < 0.015f)
* {
* var diff = (0.015f - dimensions.Z) / 2f;
* box.Min.Z -= diff;
* box.Max.Z += diff;
* //box.Inflate(new Vector3(0f, 0f, 0.015f - dimensions.Z));
* }
*
* Boxes[i] = box;
* }
*/
}
public static BlockState GetBlockState(IBlockAccess world, Vector3 position, BlockState blockState,
BlockStateResource blockStateModel)
{
/*var clone = blockState.Clone();
* var models = GetBlockStateModels(world, position, blockState, blockStateModel, out Dictionary<string, string> properties);
* clone.AppliedModels = models.Select(x => x.ModelName).ToArray();
* clone.Model = new ResourcePackBlockModel(resourceManager, models);
* clone.Block.BlockState = clone;
* clone.Values = properties;
* //clone.WithPropertyNoResolve()
* return clone;*/
var blockStateCopy = blockState.VariantMapper.GetDefaultState().CloneSilent();
foreach (var s in blockStateModel.Parts)
{
if (s.When == null)
{
//resultingModels.AddRange(s.Apply);
}
else if (s.When.Length > 0)
{
bool passes = true;
foreach (var rule in s.When)
{
if (PassesMultiPartRule(world, position, rule, blockState, out var result))
{
foreach (var kv in result.KeyValues)
{
blockStateCopy = blockStateCopy.WithProperty(kv.Key, kv.Value, false);
}
}
passes = false;
break;
}
if (passes)
{
//resultingModels.AddRange(s.Apply);
}
}
}
return(blockStateCopy);
}
private BlockStateResource ProcessBlockState(BlockStateResource blockStateResource)
{
if (blockStateResource.Parts.Length > 0)
{
foreach (var part in blockStateResource.Parts)
{
foreach (var sVariant in part.Apply)
{
sVariant.ResourcePack = this;
if (!TryGetBlockModel(sVariant.ModelName, out var model))
{
Log.Debug($"Could not get multipart blockmodel! Variant: {blockStateResource} Model: {sVariant.ModelName}");
continue;
}
sVariant.Model = model;
}
}
}
else
{
foreach (var variant in blockStateResource.Variants)
{
foreach (var sVariant in variant.Value)
{
sVariant.ResourcePack = this;
if (!TryGetBlockModel(sVariant.ModelName, out var model))
{
Log.Debug($"Could not get blockmodel for variant! Variant: {variant.Key} Model: {sVariant.ModelName}");
continue;
}
sVariant.Model = model;
}
}
}
return(blockStateResource);
}
public static BlockState GetBlockState(IBlockAccess world, Vector3 position, BlockState blockState,
BlockStateResource blockStateModel)
{
var blockStateCopy = blockState;
foreach (var s in blockStateModel.Parts)
{
if (s.When == null)
{
//resultingModels.AddRange(s.Apply);
}
else if (s.When.Length > 0)
{
bool passes = true;
foreach (var rule in s.When)
{
if (PassesMultiPartRule(world, position, rule, blockState, out var result))
{
foreach (var kv in result.KeyValues)
{
blockStateCopy = blockStateCopy.WithProperty(kv.Key, kv.Value, false);
}
}
passes = false;
break;
}
if (passes)
{
//resultingModels.AddRange(s.Apply);
}
}
}
return(blockStateCopy);
}
public static BlockStateModel[] GetBlockStateModels(World world, Vector3 position, BlockState blockState, BlockStateResource blockStateModel)
{
List <BlockStateModel> resultingModels = new List <BlockStateModel>(blockStateModel.Parts.Length);
foreach (var s in blockStateModel.Parts)
{
if (s.When == null)
{
resultingModels.AddRange(s.Apply);
}
else if (s.When.Length > 0)
{
bool passes = true;
foreach (var rule in s.When)
{
if (!PassesMultiPartRule(world, position, rule, blockState, out _))
{
passes = false;
break;
}
}
if (passes)
{
resultingModels.AddRange(s.Apply);
}
}
}
return(resultingModels.ToArray());
}
public static BlockStateModel[] GetBlockStateModels(IBlockAccess world, Vector3 position, BlockState blockState, BlockStateResource blockStateModel, out Dictionary <string, string> properties)
{
properties = new Dictionary <string, string>();
List <BlockStateModel> resultingModels = new List <BlockStateModel>(blockStateModel.Parts.Length);
// List<MultiPartRule> passedRules = new List<MultiPartRule>();
foreach (var s in blockStateModel.Parts)
{
if (s.When == null)
{
resultingModels.AddRange(s.Apply);
}
else if (s.When.Length > 0)
{
List <MultiPartRule> pass = new List <MultiPartRule>();
bool passes = true;
foreach (var rule in s.When)
{
if (!PassesMultiPartRule(world, position, rule, blockState, out var rulePassed))
{
passes = false;
break;
}
pass.Add(rulePassed);
}
if (passes)
{
resultingModels.AddRange(s.Apply);
foreach (var r in pass)
{
foreach (var kv in r.KeyValues)
{
properties[kv.Key] = kv.Value;
}
}
}
}
}
return(resultingModels.ToArray());
}
private static BlockModel ResolveModel(ResourceManager resources,
BlockStateResource blockStateResource, out bool isMultipartModel)
{
isMultipartModel = blockStateResource.Parts.Any(x => x.When != null && x.When.Length > 0);
string name = blockStateResource.Name;
if (string.IsNullOrWhiteSpace(name))
{
Log.Warn($"State name is null!");
return(null);
}
if (name.Contains("water"))
{
return(new LiquidBlockModel()
{
IsLava = false
});
}
if (name.Contains("lava"))
{
return(new LiquidBlockModel()
{
IsLava = true
});
}
// isMultipartModel = blockStateResource.Parts.Length > 0;
/*if (blockStateResource != null && blockStateResource.Parts != null && blockStateResource.Parts.Length > 0)
* {
* var models = MultiPartModelHelper.GetModels(state, blockStateResource);
* BlockStateModelWrapper[] modelWrappers = new BlockStateModelWrapper[models.Length];
*
* for (var index = 0; index < models.Length; index++)
* {
* var model = models[index];
*
* if (resources.BlockModelRegistry.TryGet(model.ModelName, out var registryEntry))
* {
* modelWrappers[index] = new BlockStateModelWrapper(model, registryEntry.Value);
* }
* }
*
* // state.MultiPartHelper = blockStateResource;
* isMultipartModel = blockStateResource.Parts.Any(x => x.When != null && x.When.Length > 0);
* //state.AppliedModels = models.Select(x => x.ModelName).ToArray();
*
* return new ResourcePackBlockModel(resources, modelWrappers);
* }
*/
//if (blockStateResource?.Variants == null || blockStateResource.Variants.Count == 0)
//{
// return null;
//}
/*if (blockStateResource.Variants.Count == 1)
* {
* var v = blockStateResource.Variants.FirstOrDefault();
*
* if (v.Value == null)
* {
* return null;
* }
*
* var models =
* v.Value.ToArray(); //.Where(x => x.Model?.Elements != null && x.Model.Elements.Length > 0).ToArray();
*
* if (models.Length == 0)
* {
* return null;
* }
*
* return new ResourcePackBlockModel(resources, models.ToArray(), v.Value.ToArray().Length > 1);
* }*/
//BlockStateVariant blockStateVariant = null;
//var data = state.ToDictionary();
/*
* int closestMatch = 0;
* KeyValuePair<string, BlockStateVariant> closest = default(KeyValuePair<string, BlockStateVariant>);
*
* foreach (var v in blockStateResource.Variants)
* {
* int matches = 0;
* //var variantBlockState = Blocks.State.BlockState.FromString(v.Key);
* var variant = Blocks.State.BlockState.ParseData(v.Key);
* foreach (var kv in state)
* {
* if (variant.TryGetValue(kv.Key, out string vValue))
* {
* if (vValue.Equals(kv.Value, StringComparison.OrdinalIgnoreCase))
* {
* matches++;
* }
* else
* {
* break;
* }
* }
* else
* {
* break;
* }
* }
*
* if (matches > closestMatch)
* {
* closestMatch = matches;
* closest = v;
*
* if (matches == state.Count)
* break;
* }
* }
*/
/*blockStateVariant = closest.Value;
*
* if (blockStateVariant == null)
* {
* var a = blockStateResource.Variants.FirstOrDefault();
* blockStateVariant = a.Value;
* }
*
* /*var asArray = blockStateVariant.ToArray();
*
* if (asArray.Length == 0)
* {
* Log.Info($"No elements");
*
* return null;
* }*/
/*BlockStateModelWrapper[] wrappers = new BlockStateModelWrapper[asArray.Length];
*
* for (var index = 0; index < asArray.Length; index++)
* {
* var model = asArray[index];
*
* if (resources.BlockModelRegistry.TryGet(model.ModelName, out var registryEntry))
* {
* wrappers[index] = new BlockStateModelWrapper(model, registryEntry.Value);
* }
* }*/
return(new ResourcePackBlockModel(resources, blockStateResource));
}
