Ejemplo n.º 1
0
 public static Location StringToLocation(string input)
 {
     return(Location.FromString(input));
 }
Ejemplo n.º 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;
            }
        }