示例#1
0
        static UnknownBlock ProcessUnknownBlock(Block block)
        {
            var unknownBlock = new UnknownBlock(block.Name);

            unknownBlock.Properties.AddRange(block.Fields.Select(a => new UnknownProperty(a.Name, a.ValueAsString())));

            return(unknownBlock);
        }
示例#2
0
        static UnknownBlock ProcessUnknownBlock(Identifier blockName, ASTNode block)
        {
            var unknownBlock = new UnknownBlock(blockName);

            var allAssignments = block.Children.Skip(1);

            unknownBlock.Properties.AddRange(
                from assignment in allAssignments
                let id                         = GetAssignmentIdentifier(assignment)
                                     let value = ReadRawValue(assignment)
                                                 select new UnknownProperty(id, value));

            return(unknownBlock);
        }
示例#3
0
        public static List <Block> ReadBlocks(ref BinaryReader reader)
        {
            List <Block> blockList = new List <Block>();

            while (reader.BaseStream.Position < reader.BaseStream.Length)
            {
                Block block;

                string blockType = new ASCIIEncoding().GetString(reader.ReadBytes(4));
                switch (blockType)
                {
                default:
                    block = new UnknownBlock(ref reader, blockType);
                    break;
                }
                blockList.Add(block);

                Utils.ReadPadding(ref reader);
            }

            return(blockList);
        }
示例#4
0
        private static int LoadModels(IRegistryManager registryManager, ResourceManager resources,
                                      McResourcePack resourcePack, bool replace,
                                      bool reportMissing, IProgressReceiver progressReceiver)
        {
            long idCounter          = 0;
            var  blockRegistry      = registryManager.GetRegistry <Block>();
            var  blockModelRegistry = registryManager.GetRegistry <BlockModel>();

            var data           = BlockData.FromJson(ResourceManager.ReadStringResource("Alex.Resources.NewBlocks.json"));
            int total          = data.Count;
            int done           = 0;
            int importCounter  = 0;
            int multipartBased = 0;

            uint c = 0;

            foreach (var entry in data)
            {
                double percentage = 100D * ((double)done / (double)total);
                progressReceiver.UpdateProgress((int)percentage, $"Importing block models...", entry.Key);

                var variantMap   = new BlockStateVariantMapper();
                var defaultState = new BlockState
                {
                    Name          = entry.Key,
                    VariantMapper = variantMap
                };

                if (entry.Value.Properties != null)
                {
                    foreach (var property in entry.Value.Properties)
                    {
                        //	if (property.Key.Equals("waterlogged"))
                        //		continue;

                        defaultState = (BlockState)defaultState.WithPropertyNoResolve(property.Key,
                                                                                      property.Value.FirstOrDefault(), false);
                    }
                }

                foreach (var s in entry.Value.States)
                {
                    var id = s.ID;

                    BlockState variantState = (BlockState)(defaultState).CloneSilent();
                    variantState.ID   = id;
                    variantState.Name = entry.Key;

                    if (s.Properties != null)
                    {
                        foreach (var property in s.Properties)
                        {
                            //if (property.Key.Equals("waterlogged"))
                            //		continue;

                            variantState =
                                (Blocks.State.BlockState)variantState.WithPropertyNoResolve(property.Key,
                                                                                            property.Value, false);
                        }
                    }

                    if (!replace && RegisteredBlockStates.TryGetValue(id, out BlockState st))
                    {
                        Log.Warn(
                            $"Duplicate blockstate id (Existing: {st.Name}[{st.ToString()}] | New: {entry.Key}[{variantState.ToString()}]) ");
                        continue;
                    }


                    var cachedBlockModel = GetOrCacheModel(resources, resourcePack, variantState, id, replace);
                    if (cachedBlockModel == null)
                    {
                        if (reportMissing)
                        {
                            Log.Warn($"Missing blockmodel for blockstate {entry.Key}[{variantState.ToString()}]");
                        }

                        cachedBlockModel = UnknownBlockModel;
                    }

                    if (variantState.IsMultiPart)
                    {
                        multipartBased++;
                    }

                    string displayName = entry.Key;
                    IRegistryEntry <Block> registryEntry;

                    if (!blockRegistry.TryGet(entry.Key, out registryEntry))
                    {
                        registryEntry = new UnknownBlock(id);
                        displayName   = $"(MISSING) {displayName}";

                        registryEntry = registryEntry.WithLocation(entry.Key);                         // = entry.Key;
                    }
                    else
                    {
                        registryEntry = registryEntry.WithLocation(entry.Key);
                    }

                    var block = registryEntry.Value;

                    variantState.Model   = cachedBlockModel;
                    variantState.Default = s.Default;

                    if (string.IsNullOrWhiteSpace(block.DisplayName) ||
                        !block.DisplayName.Contains("minet", StringComparison.InvariantCultureIgnoreCase))
                    {
                        block.DisplayName = displayName;
                    }

                    variantState.Block = block;
                    block.BlockState   = variantState;

                    if (variantMap.TryAdd(variantState))
                    {
                        if (!RegisteredBlockStates.TryAdd(variantState.ID, variantState))
                        {
                            if (replace)
                            {
                                RegisteredBlockStates[variantState.ID] = variantState;
                                importCounter++;
                            }
                            else
                            {
                                Log.Warn(
                                    $"Failed to add blockstate (variant), key already exists! ({variantState.ID} - {variantState.Name})");
                            }
                        }
                        else
                        {
                            importCounter++;
                        }
                    }
                    else
                    {
                        Log.Warn(
                            $"Could not add variant to variant map: {variantState.Name}[{variantState.ToString()}]");
                    }
                }

                if (!BlockStateByName.TryAdd(defaultState.Name, variantMap))
                {
                    if (replace)
                    {
                        BlockStateByName[defaultState.Name] = variantMap;
                    }
                    else
                    {
                        Log.Warn($"Failed to add blockstate, key already exists! ({defaultState.Name})");
                    }
                }

                done++;
            }

            Log.Info($"Got {multipartBased} multi-part blockstate variants!");
            return(importCounter);
        }
示例#5
0
        public void SetBlocksDifferent()
        {
            var block = new UnknownBlock((BlockType)Rnd.Next(248));

            World.SetBlock(block, 0, 0, 0);
        }
示例#6
0
        private static int LoadModels(IRegistryManager registryManager,
                                      ResourceManager resources,
                                      bool replace,
                                      bool reportMissing,
                                      IProgressReceiver progressReceiver)
        {
            Stopwatch sw  = Stopwatch.StartNew();
            var       raw = ResourceManager.ReadStringResource("Alex.Resources.blockmap.json");

            var mapping = JsonConvert.DeserializeObject <BlockMap>(raw);

            var blockRegistry = registryManager.GetRegistry <Block>();
            //var blockStateRegistry = registryManager.GetRegistry<BlockState>();

            var data          = BlockData.FromJson(ResourceManager.ReadStringResource("Alex.Resources.NewBlocks.json"));
            int total         = data.Count;
            int done          = 0;
            int importCounter = 0;

            void LoadEntry(KeyValuePair <string, BlockData> entry)
            {
                done++;
                if (!resources.TryGetBlockState(entry.Key, out var blockStateResource))
                {
                    if (reportMissing)
                    {
                        Log.Warn($"Could not find blockstate with key: {entry.Key}");
                    }

                    return;
                }

                //double percentage = 100D * ((double) done / (double) total);blockstate variants
                progressReceiver.UpdateProgress(done, total, $"Importing block models...", entry.Key);

                var location     = new ResourceLocation(entry.Key);
                var variantMap   = new BlockStateVariantMapper();
                var defaultState = new BlockState {
                    Name = entry.Key, VariantMapper = variantMap
                };

                defaultState = defaultState.WithLocation(location).Value;

                if (entry.Value.Properties != null)
                {
                    foreach (var property in entry.Value.Properties)
                    {
                        defaultState = (BlockState)defaultState.WithPropertyNoResolve(property.Key, property.Value.FirstOrDefault(), false);
                    }
                }

                defaultState.ModelData = ResolveVariant(blockStateResource, defaultState);

                variantMap.Model       = ResolveModel(resources, blockStateResource, out bool isMultipartModel);
                variantMap.IsMultiPart = isMultipartModel;

                if (variantMap.Model == null)
                {
                    Log.Warn($"No model found for {entry.Key}[{variantMap.ToString()}]");
                }

                foreach (var s in entry.Value.States)
                {
                    if (!replace && RegisteredBlockStates.TryGetValue(s.ID, out BlockState st))
                    {
                        Log.Warn($"Duplicate blockstate id (Existing: {st.Name}[{st.ToString()}]) ");

                        continue;
                    }

                    BlockState variantState = (BlockState)(defaultState).CloneSilent();
                    variantState.ID   = s.ID;
                    variantState.Name = entry.Key;

                    if (s.Properties != null)
                    {
                        foreach (var property in s.Properties)
                        {
                            //if (property.Key.ToLower() == "waterlogged")continue;
                            variantState = (Blocks.State.BlockState)variantState.WithPropertyNoResolve(property.Key, property.Value, false);
                        }
                    }

                    IRegistryEntry <Block> registryEntry;

                    if (!blockRegistry.TryGet(location, out registryEntry))
                    {
                        registryEntry = new UnknownBlock();
                        registryEntry = registryEntry.WithLocation(location);                         // = entry.Key;
                    }
                    else
                    {
                        registryEntry = registryEntry.WithLocation(location);
                    }

                    var block = registryEntry.Value;

                    if (string.IsNullOrWhiteSpace(block.DisplayName))
                    {
                        block.DisplayName = entry.Key;
                    }

                    variantState.ModelData = ResolveVariant(blockStateResource, variantState);

                    variantState.Block = block.Value;
                    block.BlockState   = variantState;

                    //	if (variantState.IsMultiPart) multipartBased++;

                    variantState.Default = s.Default;

                    if (variantMap.TryAdd(variantState))
                    {
                        if (!RegisteredBlockStates.TryAdd(variantState.ID, variantState))
                        {
                            if (replace)
                            {
                                RegisteredBlockStates[variantState.ID] = variantState;
                                importCounter++;
                            }
                            else
                            {
                                Log.Warn($"Failed to add blockstate (variant), key already exists! ({variantState.ID} - {variantState.Name})");
                            }
                        }
                        else
                        {
                            importCounter++;
                        }
                    }
                    else
                    {
                        Log.Warn($"Could not add variant to variant map: {variantState.Name}[{variantState.ToString()}]");
                    }
                }

                if (!BlockStateByName.TryAdd(location, variantMap))
                {
                    if (replace)
                    {
                        BlockStateByName[location] = variantMap;
                    }
                    else
                    {
                        Log.Warn($"Failed to add blockstate, key already exists! ({defaultState.Name})");
                    }
                }
            }

            if (resources.Asynchronous)
            {
                Parallel.ForEach(data, LoadEntry);
            }
            else
            {
                foreach (var entry in data)
                {
                    LoadEntry(entry);
                }
            }

            var blockStateTime = sw.Elapsed;

            var mappings = mapping.GroupBy(x => x.Value.BedrockIdentifier).ToArray();

            int counter = 1;

            sw.Restart();
            Parallel.ForEach(
                mappings, (m) =>
            {
                progressReceiver?.UpdateProgress(counter, mapping.Count, "Mapping blockstates...", m.Key);

                var mapper = new BlockStateVariantMapper();
                bool first = true;

                foreach (var state in m)
                {
                    var match     = _blockMappingRegex.Match(state.Key);
                    var keyMatch  = match.Groups["key"];
                    var dataMatch = match.Groups["data"];

                    if (!keyMatch.Success)
                    {
                        Log.Warn($"Entry without key!");

                        continue;
                    }

                    BlockState pcVariant = GetBlockState(keyMatch.Value);

                    if (pcVariant != null)
                    {
                        pcVariant = pcVariant.Clone();
                        if (dataMatch.Success)
                        {
                            var properties = BlockState.ParseData(dataMatch.Value);

                            var p = properties.ToArray();

                            for (var i = 0; i < p.Length; i++)
                            {
                                var prop = p[i];

                                if (i == p.Length - 1)
                                {
                                    pcVariant = pcVariant.WithProperty(prop.Key, prop.Value);
                                }
                                else
                                {
                                    pcVariant = pcVariant.WithPropertyNoResolve(prop.Key, prop.Value, false);
                                }
                            }
                        }
                    }

                    if (pcVariant == null)
                    {
                        Log.Warn($"Map failed: {match.Groups["key"].Value} -> {state.Value.BedrockIdentifier}");

                        continue;
                    }

                    pcVariant = pcVariant.CloneSilent();

                    PeBlockState bedrockState  = new PeBlockState(pcVariant);
                    bedrockState.Name          = state.Value.BedrockIdentifier;
                    bedrockState.VariantMapper = mapper;
                    //bedrockState.AppliedModels = pcVariant.AppliedModels;
                    //	bedrockState.IsMultiPart = pcVariant.IsMultiPart;
                    //	bedrockState.MultiPartHelper = pcVariant.MultiPartHelper;
                    //	bedrockState.ResolveModel = pcVariant.ResolveModel;
                    //bedrockState.Model = pcVariant.Model;
                    bedrockState.Block   = pcVariant.Block;
                    bedrockState.ID      = (uint)Interlocked.Increment(ref counter);
                    bedrockState.Default = first;

                    first = false;

                    if (state.Value.BedrockStates != null && state.Value.BedrockStates.Count > 0)
                    {
                        foreach (var bs in state.Value.BedrockStates)
                        {
                            bedrockState.Values[bs.Key] = bs.Value.ToString();
                        }
                    }

                    if (!mapper.TryAdd(bedrockState.WithLocation(bedrockState.Name).Value))
                    {
                        Log.Warn($"Failed to add bedrockstate: {state.Value.BedrockIdentifier}");
                    }
                }

                BedrockStates[m.Key] = mapper;
            });

            //Log.Info($"Loaded {multipartBased} multi-part blockstates!");
            Log.Info($"Loaded {BedrockStates.Count} mappings in {sw.ElapsedMilliseconds}ms...");

            return(importCounter);
        }