Example #1
0
        public static void Populate(FileHandler files)
        {
            List <string>       fileList = files.ListFiles("info/blocks/");
            List <MaterialInfo> allmats  = new List <MaterialInfo>((int)Material.NUM_DEFAULT);

            foreach (string file in fileList)
            {
                string f = file.ToLowerFast().After("/blocks/").Before(".blk");
                if (TryGetFromNameOrNumber(allmats, f, out Material mat))
                {
                    continue;
                }
                mat = (Material)Enum.Parse(typeof(Material), f.ToUpperInvariant());
                string       data  = files.ReadText("info/blocks/" + f + ".blk");
                string[]     split = data.Replace("\r", "").Split('\n');
                MaterialInfo inf   = new MaterialInfo((int)mat);
                for (int i = 0; i < split.Length; i++)
                {
                    if (split[i].StartsWith("//") || !split[i].Contains("="))
                    {
                        continue;
                    }
                    string[] opt = split[i].SplitFast('=', 1);
                    switch (opt[0].ToLowerFast())
                    {
                    case "name":
                        inf.SetName(opt[1]);
                        break;

                    case "plant":
                        inf.Plant = opt[1];
                        break;

                    case "plantscale":
                        inf.PlantScale = float.Parse(opt[1]);
                        break;

                    case "plantmultiplier":
                        inf.PlantMultiplier        = float.Parse(opt[1]);
                        inf.InversePlantMultiplier = 1.0f / inf.PlantMultiplier;
                        break;

                    case "sound":
                        inf.Sound = (MaterialSound)Enum.Parse(typeof(MaterialSound), opt[1].ToUpperInvariant());
                        break;

                    case "solidity":
                        inf.Solidity = (MaterialSolidity)Enum.Parse(typeof(MaterialSolidity), opt[1].ToUpperInvariant());
                        break;

                    case "speedmod":
                        inf.SpeedMod = double.Parse(opt[1]);
                        break;

                    case "frictionmod":
                        inf.FrictionMod = double.Parse(opt[1]);
                        break;

                    case "lightdamage":
                        inf.LightDamage = double.Parse(opt[1]);
                        break;

                    case "lightemitrange":
                        inf.LightEmitRange = double.Parse(opt[1]);
                        break;

                    case "lightemit":
                        inf.LightEmit = Location.FromString(opt[1]);
                        break;

                    case "fogalpha":
                        inf.FogAlpha = double.Parse(opt[1]);
                        break;

                    case "opaque":
                        inf.Opaque = opt[1].ToLowerFast() == "true";
                        break;

                    case "spreads":
                        inf.Spreads = opt[1].ToLowerFast() == "true";
                        break;

                    case "rendersatall":
                        inf.RendersAtAll = opt[1].ToLowerFast() == "true";
                        break;

                    case "breaksfromothertools":
                        inf.BreaksFromOtherTools = opt[1].ToLowerFast() == "true";
                        break;

                    case "fogcolor":
                        inf.FogColor = Location.FromString(opt[1]);
                        break;

                    case "canrenderagainstself":
                        inf.CanRenderAgainstSelf = opt[1].ToLowerFast() == "true";
                        break;

                    case "anyopaque":
                        inf.AnyOpaque = opt[1].ToLowerFast() == "true";
                        break;

                    case "spawntype":
                        inf.SpawnType = (MaterialSpawnType)Enum.Parse(typeof(MaterialSpawnType), opt[1].ToUpperInvariant());
                        break;

                    case "hardness":
                        inf.Hardness = double.Parse(opt[1]);
                        break;

                    case "breaktime":
                        inf.BreakTime = opt[1].ToLowerFast() == "infinity" ? double.PositiveInfinity : double.Parse(opt[1]);
                        break;

                    case "breaker":
                        inf.Breaker = (MaterialBreaker)Enum.Parse(typeof(MaterialBreaker), opt[1].ToUpperInvariant());
                        break;

                    case "breaksinto":
                        inf.BreaksInto = (Material)Enum.Parse(typeof(Material), opt[1].ToUpperInvariant());
                        break;

                    case "solidifiesinto":
                        inf.SolidifiesInto = (Material)Enum.Parse(typeof(Material), opt[1].ToUpperInvariant());
                        break;

                    case "bigspreadsas":
                        inf.BigSpreadsAs = (Material)Enum.Parse(typeof(Material), opt[1].ToUpperInvariant());
                        break;

                    case "texturebasic":
                        for (int t = 0; t < (int)MaterialSide.COUNT; t++)
                        {
                            if (inf.Texture[t] == null)
                            {
                                inf.Texture[t] = new List <string>()
                                {
                                    opt[1].ToLowerFast()
                                };
                            }
                        }
                        break;

                    case "texture_top":
                        inf.Texture[(int)MaterialSide.TOP] = new List <string>()
                        {
                            opt[1].ToLowerFast()
                        };
                        break;

                    case "texture_bottom":
                        inf.Texture[(int)MaterialSide.BOTTOM] = new List <string>()
                        {
                            opt[1].ToLowerFast()
                        };
                        break;

                    case "texture_xp":
                        inf.Texture[(int)MaterialSide.XP] = new List <string>()
                        {
                            opt[1].ToLowerFast()
                        };
                        break;

                    case "texture_xm":
                        inf.Texture[(int)MaterialSide.XM] = new List <string>()
                        {
                            opt[1].ToLowerFast()
                        };
                        break;

                    case "texture_yp":
                        inf.Texture[(int)MaterialSide.YP] = new List <string>()
                        {
                            opt[1].ToLowerFast()
                        };
                        break;

                    case "texture_ym":
                        inf.Texture[(int)MaterialSide.YM] = new List <string>()
                        {
                            opt[1].ToLowerFast()
                        };
                        break;

                    case "texturebasic_add":
                        for (int t = 0; t < (int)MaterialSide.COUNT; t++)
                        {
                            inf.Texture[t].Add(opt[1].ToLowerFast());
                        }
                        break;

                    case "texture_top_add":
                        inf.Texture[(int)MaterialSide.TOP].Add(opt[1].ToLowerFast());
                        break;

                    case "texture_bottom_add":
                        inf.Texture[(int)MaterialSide.BOTTOM].Add(opt[1].ToLowerFast());
                        break;

                    case "texture_xp_add":
                        inf.Texture[(int)MaterialSide.XP].Add(opt[1].ToLowerFast());
                        break;

                    case "texture_xm_add":
                        inf.Texture[(int)MaterialSide.XM].Add(opt[1].ToLowerFast());
                        break;

                    case "texture_yp_add":
                        inf.Texture[(int)MaterialSide.YP].Add(opt[1].ToLowerFast());
                        break;

                    case "texture_ym_add":
                        inf.Texture[(int)MaterialSide.YM].Add(opt[1].ToLowerFast());
                        break;

                    default:
                        SysConsole.Output(OutputType.WARNING, "Invalid material option: " + opt[0]);
                        break;
                    }
                }
                while (allmats.Count <= (int)mat)
                {
                    MaterialInfo place = new MaterialInfo(allmats.Count);
                    place.SetName("errno_" + allmats.Count);
                    for (int t = 0; t < (int)MaterialSide.COUNT; t++)
                    {
                        place.Texture[t] = null;
                    }
                    allmats.Add(place);
                }
                allmats[(int)mat] = inf;
            }
            int c = 0;
            Dictionary <string, int> TexturesToIDs = new Dictionary <string, int>();

            for (int i = 0; i < allmats.Count; i++)
            {
                for (int t = 0; t < (int)MaterialSide.COUNT; t++)
                {
                    if (allmats[i].Texture[t] == null)
                    {
                        allmats[i].Texture[t] = new List <string>()
                        {
                            "white"
                        };
                        SysConsole.Output(OutputType.WARNING, "Texture unset for " + ((Material)i) + " side " + ((MaterialSide)t));
                    }
                    List <string> tex = allmats[i].Texture[t];
                    allmats[i].TID[t] = new int[tex.Count];
                    for (int x = 0; x < tex.Count; x++)
                    {
                        int res;
                        if (TexturesToIDs.ContainsKey(tex[x]))
                        {
                            res = TexturesToIDs[tex[x]];
                        }
                        else
                        {
                            TexturesToIDs[tex[x]] = c;
                            res = c;
                            c++;
                        }
                        (allmats[i].TID[t])[x] = res;
                    }
                }
            }
            Textures = new string[c];
            foreach (KeyValuePair <string, int> val in TexturesToIDs)
            {
                Textures[val.Value] = val.Key;
            }
            lock (ALL_MATS)
            {
                SysConsole.Output(OutputType.INIT, "Loaded: " + allmats.Count + " materials!");
                ALL_MATS = allmats;
            }
        }
Example #2
0
 public static void Populate(FileHandler files)
 {
     List<string> fileList = files.ListFiles("info/blocks/");
     List<MaterialInfo> allmats = new List<MaterialInfo>((int)Material.NUM_DEFAULT);
     foreach (string file in fileList)
     {
         string f = file.ToLowerFast().After("/blocks/").Before(".blk");
         Material mat;
         if (TryGetFromNameOrNumber(allmats, f, out mat))
         {
             continue;
         }
         mat = (Material)Enum.Parse(typeof(Material), f.ToUpperInvariant());
         string data = files.ReadText("info/blocks/" + f + ".blk");
         string[] split = data.Replace("\r", "").Split('\n');
         MaterialInfo inf = new MaterialInfo((int)mat);
         for (int i = 0; i < split.Length; i++)
         {
             if (split[i].StartsWith("//") || !split[i].Contains("="))
             {
                 continue;
             }
             string[] opt = split[i].SplitFast('=', 1);
             switch (opt[0].ToLowerFast())
             {
                 case "name":
                     inf.SetName(opt[1]);
                     break;
                 case "plant":
                     inf.Plant = opt[1];
                     break;
                 case "sound":
                     inf.Sound = (MaterialSound)Enum.Parse(typeof(MaterialSound), opt[1].ToUpperInvariant());
                     break;
                 case "solidity":
                     inf.Solidity = (MaterialSolidity)Enum.Parse(typeof(MaterialSolidity), opt[1].ToUpperInvariant());
                     break;
                 case "speedmod":
                     inf.SpeedMod = double.Parse(opt[1]);
                     break;
                 case "frictionmod":
                     inf.FrictionMod = double.Parse(opt[1]);
                     break;
                 case "lightdamage":
                     inf.LightDamage = double.Parse(opt[1]);
                     break;
                 case "lightemitrange":
                     inf.LightEmitRange = double.Parse(opt[1]);
                     break;
                 case "lightemit":
                     inf.LightEmit = Location.FromString(opt[1]);
                     break;
                 case "fogalpha":
                     inf.FogAlpha = double.Parse(opt[1]);
                     break;
                 case "opaque":
                     inf.Opaque = opt[1].ToLowerFast() == "true";
                     break;
                 case "spreads":
                     inf.Spreads = opt[1].ToLowerFast() == "true";
                     break;
                 case "rendersatall":
                     inf.RendersAtAll = opt[1].ToLowerFast() == "true";
                     break;
                 case "breaksfromothertools":
                     inf.BreaksFromOtherTools = opt[1].ToLowerFast() == "true";
                     break;
                 case "fogcolor":
                     inf.FogColor = Location.FromString(opt[1]);
                     break;
                 case "canrenderagainstself":
                     inf.CanRenderAgainstSelf = opt[1].ToLowerFast() == "true";
                     break;
                 case "spawntype":
                     inf.SpawnType = (MaterialSpawnType)Enum.Parse(typeof(MaterialSpawnType), opt[1].ToUpperInvariant());
                     break;
                 case "hardness":
                     inf.Hardness = double.Parse(opt[1]);
                     break;
                 case "breaktime":
                     inf.BreakTime = opt[1].ToLowerFast() == "infinity" ? double.PositiveInfinity : double.Parse(opt[1]);
                     break;
                 case "breaker":
                     inf.Breaker = (MaterialBreaker)Enum.Parse(typeof(MaterialBreaker), opt[1].ToUpperInvariant());
                     break;
                 case "breaksinto":
                     inf.BreaksInto = (Material)Enum.Parse(typeof(Material), opt[1].ToUpperInvariant());
                     break;
                 case "solidifiesinto":
                     inf.SolidifiesInto = (Material)Enum.Parse(typeof(Material), opt[1].ToUpperInvariant());
                     break;
                 case "bigspreadsas":
                     inf.BigSpreadsAs = (Material)Enum.Parse(typeof(Material), opt[1].ToUpperInvariant());
                     break;
                 case "texturebasic":
                     for (int t = 0; t < (int)MaterialSide.COUNT; t++)
                     {
                         if (inf.Texture[t] == null)
                         {
                             inf.Texture[t] = opt[1].ToLowerFast();
                         }
                     }
                     break;
                 case "texture_top":
                     inf.Texture[(int)MaterialSide.TOP] = opt[1].ToLowerFast();
                     break;
                 case "texture_bottom":
                     inf.Texture[(int)MaterialSide.BOTTOM] = opt[1].ToLowerFast();
                     break;
                 case "texture_xp":
                     inf.Texture[(int)MaterialSide.XP] = opt[1].ToLowerFast();
                     break;
                 case "texture_xm":
                     inf.Texture[(int)MaterialSide.XM] = opt[1].ToLowerFast();
                     break;
                 case "texture_yp":
                     inf.Texture[(int)MaterialSide.YP] = opt[1].ToLowerFast();
                     break;
                 case "texture_ym":
                     inf.Texture[(int)MaterialSide.YM] = opt[1].ToLowerFast();
                     break;
                 default:
                     SysConsole.Output(OutputType.WARNING, "Invalid material option: " + opt[0]);
                     break;
             }
         }
         while (allmats.Count <= (int)mat)
         {
             allmats.Add(null);
         }
         allmats[(int)mat] = inf;
     }
     int c = 0;
     Dictionary<string, int> TexturesToIDs = new Dictionary<string, int>();
     for (int i = 0; i < allmats.Count; i++)
     {
         for (int t = 0; t < (int)MaterialSide.COUNT; t++)
         {
             string tex = allmats[i].Texture[t];
             int res;
             if (TexturesToIDs.ContainsKey(tex))
             {
                 res = TexturesToIDs[tex];
             }
             else
             {
                 TexturesToIDs[tex] = c;
                 res = c;
                 c++;
             }
             allmats[i].TID[t] = res;
         }
     }
     Textures = new string[c];
     foreach (KeyValuePair<string, int> val in TexturesToIDs)
     {
         Textures[val.Value] = val.Key;
     }
     lock (ALL_MATS)
     {
         SysConsole.Output(OutputType.INIT, "Loaded: " + allmats.Count + " materials!");
         ALL_MATS = allmats;
     }
 }