public string GetText(FileHandler Files, params string[] pathAndVars)
{
if (pathAndVars.Length < 2)
{
return GetText(Files, "voxalia", "common.languages.badinput");
}
string category = pathAndVars[0].ToLowerFast();
string defPath = pathAndVars[1].ToLowerFast();
FDSSection lang = GetLangDoc(category, Files);
FDSSection langen = GetLangDoc(category, Files, "en_us", EnglishDocuments);
string str = null;
if (lang != null)
{
str = lang.GetString(defPath, null);
if (str != null)
{
return Handle(str, pathAndVars);
}
}
if (langen != null)
{
str = langen.GetString(defPath, null);
if (str != null)
{
return Handle(str, pathAndVars);
}
}
if (defPath == badkey)
{
return "((Invalid key!))";
}
return GetText(Files, "voxalia", badkey);
}
public FDSSection GetLangDoc(string id, FileHandler Files, string lang = null, Dictionary<string, FDSSection> confs = null)
{
if (lang == null)
{
lang = CurrentLanguage;
}
if (confs == null)
{
confs = LanguageDocuments;
}
string idlow = id.ToLowerFast();
FDSSection doc;
if (LanguageDocuments.TryGetValue(idlow, out doc))
{
return doc;
}
string path = "info/text/" + idlow + "_" + lang + ".fds";
if (Files.Exists(path))
{
try
{
string dat = Files.ReadText(path);
doc = new FDSSection(dat);
LanguageDocuments[idlow] = doc;
return doc;
}
catch (Exception ex)
{
Utilities.CheckException(ex);
SysConsole.Output("Reading language documents", ex);
}
}
LanguageDocuments[idlow] = null;
return null;
}
public static void Init()
{
FileHandler files = new FileHandler();
files.Init();
MaterialHelpers.Populate(files); // TODO: Non-static material helper data?!
BlockShapeRegistry.Init();
FullChunkObject.RegisterMe();
}
public SingleAnimation GetAnimation(string name, FileHandler Files)
{
string namelow = name.ToLowerFast();
SingleAnimation sa;
if (Animations.TryGetValue(namelow, out sa))
{
return sa;
}
try
{
sa = LoadAnimation(namelow, Files);
Animations.Add(sa.Name, sa);
return sa;
}
catch (Exception ex)
{
SysConsole.Output(OutputType.ERROR, "Loading an animation: " + ex.ToString());
sa = new SingleAnimation() { Name = namelow, Length = 1, Engine = this };
Animations.Add(sa.Name, sa);
return sa;
}
}
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;
}
}
SingleAnimation LoadAnimation(string name, FileHandler Files)
{
if (Files.Exists("animations/" + name + ".anim"))
{
SingleAnimation created = new SingleAnimation();
created.Name = name;
string[] data = Files.ReadText("animations/" + name + ".anim").SplitFast('\n');
int entr = 0;
for (int i = 0; i < data.Length; i++)
{
if (data[i].StartsWith("//"))
{
continue;
}
string type = data[i];
if (data.Length <= i + 1 || data[i + 1] != "{")
{
break;
}
List<KeyValuePair<string, string>> entries = new List<KeyValuePair<string, string>>();
for (i += 2; i < data.Length; i++)
{
if (data[i].Trim().StartsWith("//"))
{
continue;
}
if (data[i] == "}")
{
break;
}
string[] dat = data[i].SplitFast(':');
if (dat.Length <= 1)
{
SysConsole.Output(OutputType.WARNING, "Invalid key dat: " + dat[0]);
}
else
{
string key = dat[0].Trim();
string value = dat[1].Substring(0, dat[1].Length - 1).Trim();
entries.Add(new KeyValuePair<string, string>(key, value));
}
}
bool isgeneral = type == "general" && entr == 0;
SingleAnimationNode node = null;
if (!isgeneral)
{
node = new SingleAnimationNode();
node.Name = type.ToLowerFast();
}
foreach (KeyValuePair<string, string> entry in entries)
{
if (isgeneral)
{
if (entry.Key == "length")
{
created.Length = Utilities.StringToDouble(entry.Value);
}
else
{
SysConsole.Output(OutputType.WARNING, "Unknown GENERAL key: " + entry.Key);
}
}
else
{
if (entry.Key == "positions")
{
string[] poses = entry.Value.SplitFast(' ');
for (int x = 0; x < poses.Length; x++)
{
if (poses[x].Length > 0)
{
string[] posdata = poses[x].SplitFast('=');
node.PosTimes.Add(Utilities.StringToDouble(posdata[0]));
node.Positions.Add(new Location(Utilities.StringToFloat(posdata[1]),
Utilities.StringToFloat(posdata[2]), Utilities.StringToFloat(posdata[3])));
}
}
}
else if (entry.Key == "rotations")
{
string[] rots = entry.Value.SplitFast(' ');
for (int x = 0; x < rots.Length; x++)
{
if (rots[x].Length > 0)
{
string[] posdata = rots[x].SplitFast('=');
node.RotTimes.Add(Utilities.StringToDouble(posdata[0]));
node.Rotations.Add(new Quaternion(Utilities.StringToFloat(posdata[1]), Utilities.StringToFloat(posdata[2]),
Utilities.StringToFloat(posdata[3]), Utilities.StringToFloat(posdata[4])));
}
}
}
else if (entry.Key == "parent")
{
node.ParentName = entry.Value.ToLowerFast();
}
else if (entry.Key == "offset")
{
string[] posdata = entry.Value.SplitFast('=');
node.Offset = new Location(Utilities.StringToFloat(posdata[0]),
Utilities.StringToFloat(posdata[1]), Utilities.StringToFloat(posdata[2]));
}
else
{
SysConsole.Output(OutputType.WARNING, "Unknown NODE key: " + entry.Key);
}
}
}
if (!isgeneral)
{
created.Nodes.Add(node);
created.node_map.Add(node.Name, node);
}
entr++;
}
foreach (SingleAnimationNode node in created.Nodes)
{
for (int i = 0; i < created.Nodes.Count; i++)
{
if (created.Nodes[i].Name == node.ParentName)
{
node.Parent = created.Nodes[i];
break;
}
}
}
created.Engine = this;
return created;
}
else
{
throw new Exception("Invalid animation file - file not found: animations/" + name + ".anim");
}
}
