private static Texture2D FindRoadTexture(string templateName)
{
Texture2D result = null;
BF2FileSystem.BF2FSEntry e = BF2FileSystem.FindEntryFromIngamePath("objects\\roads\\Splines\\" + templateName + ".con");
if (e == null)
{
return(result);
}
byte[] data = BF2FileSystem.GetFileFromZip(e.zipFile, e.inZipPath);
if (data == null)
{
return(result);
}
List <string> lines = new List <string>(Encoding.ASCII.GetString(data).Split('\n'));
string texName = Helper.FindLineStartingWith(lines, "RoadTemplateTexture.SetTextureFile");
if (texName == null)
{
return(result);
}
texName = texName.Split(' ')[1].Replace("\"", "").Trim() + ".dds";
result = engine.textureManager.FindTextureByPath(texName);
if (result == null)
{
result = engine.defaultTexture;
}
return(result);
}
private void importLevelFromToolStripMenuItem_Click(object sender, EventArgs e)
{
if (BF2Level.name == "")
{
MessageBox.Show("Please mount a level first");
return;
}
string target = BF2FileSystem.basepath + "Levels\\" + BF2Level.name + "\\";
OpenFileDialog d = new OpenFileDialog();
d.Filter = "bf2editor.exe|bf2editor.exe";
if (d.ShowDialog() == DialogResult.OK)
{
string source = Path.GetDirectoryName(d.FileName) + "\\mods\\bfp4f\\Levels\\" + BF2Level.name + "\\";
if (!Directory.Exists(source))
{
Log.WriteLine("Cant find source folder \"" + source + "\"");
return;
}
Log.WriteLine("Importing Level from \"" + source + "\" to \"" + target + "\"...");
string[] files = Directory.GetFiles(source, "*.*", SearchOption.AllDirectories);
pb1.Maximum = files.Length;
int count = 0;
foreach (string file in files)
{
pb1.Value = count++;
string shortname = file.Substring(source.Length);
BF2FileSystem.BF2FSEntry entry = BF2FileSystem.FindEntryFromIngamePath(shortname);
if (entry == null)
{
Log.WriteLine("Cant find \"" + shortname + "\"");
continue;
}
if (!entry.zipFile.ToLower().Contains("\\levels\\") || file.ToLower().EndsWith("ambientobjects.con"))
{
Log.WriteLine("Skipping \"" + file + "\"");
continue;
}
byte[] data = File.ReadAllBytes(file);
if (file.ToLower().EndsWith("staticobjects.con"))
{
Log.WriteLine("Processing \"" + shortname + "\"...");
data = ProcessStaticObjects(File.ReadAllLines(file));
}
BF2FileSystem.SetFileFromEntry(entry, data);
Log.WriteLine("Importing \"" + shortname + "\" into \"" + Path.GetFileName(entry.zipFile) + "\"");
}
Log.WriteLine("Done.");
pb1.Value = 0;
}
}
public static void SaveRoadObjects()
{
BF2FileSystem.BF2FSEntry e = BF2FileSystem.FindEntryFromIngamePath("Levels\\" + name + "\\CompiledRoads.con");
if (e == null)
{
return;
}
byte[] data = BF2FileSystem.GetFileFromZip(e.zipFile, e.inZipPath);
if (data == null)
{
return;
}
StringBuilder sb = new StringBuilder();
foreach (BF2LevelObject lo in objects)
{
if (lo.type == BF2LevelObject.BF2LOTYPE.Road)
{
bool foundPosition = false;
foreach (string line in lo.properties)
{
if (line.StartsWith("object.absoluteposition"))
{
string s = "object.absoluteposition ";
s += lo.position.X.ToString().Replace(',', '.') + "/";
s += lo.position.Y.ToString().Replace(',', '.') + "/";
s += lo.position.Z.ToString().Replace(',', '.');
sb.AppendLine(s);
foundPosition = true;
}
else
{
sb.AppendLine(line);
}
}
if (!foundPosition)
{
string s = "object.absoluteposition ";
s += lo.position.X.ToString().Replace(',', '.') + "/";
s += lo.position.Y.ToString().Replace(',', '.') + "/";
s += lo.position.Z.ToString().Replace(',', '.');
sb.AppendLine(s);
}
sb.AppendLine();
}
}
sb.AppendLine();
byte[] dataNew = Encoding.ASCII.GetBytes(sb.ToString());
BF2FileSystem.SetFileFromEntry(e, dataNew);
}
public Texture2D FindTextureByPath(string path)
{
if (loadedTextures.ContainsKey(path))
{
return(loadedTextures[path]);
}
BF2FileSystem.BF2FSEntry e = BF2FileSystem.FindEntryFromIngamePath(path.Replace("/", "\\"));
if (e == null)
{
return(null);
}
byte[] data = BF2FileSystem.GetFileFromZip(e.zipFile, e.inZipPath);
if (data == null)
{
return(null);
}
string ext = Path.GetExtension(e.inFSPath).ToLower();
string tmpfile = "tmp" + ext;
string tmpfile2 = "tmp.png";
if (File.Exists(tmpfile2))
{
File.Delete(tmpfile2);
}
File.WriteAllBytes(tmpfile, data);
Texture2D result = null;
switch (ext)
{
case ".dds":
Helper.ConvertToPNG("tmp.dds");
if (File.Exists(tmpfile2))
{
System.Drawing.Bitmap bmp = Helper.LoadBitmapUnlocked(tmpfile2);
result = CreateTexture2DFromBitmap(engine.device, CreateWICBitmapFromGDI(bmp));
bmp.Dispose();
File.Delete(tmpfile2);
}
break;
}
File.Delete(tmpfile);
if (result != null)
{
Log.WriteLine("[BF2 TM] Loaded texture " + path);
loadedTextures.Add(path, result);
}
return(result);
}
public static void Load(string filename)
{
Log.WriteLine("[BF2 HL] running \"" + filename + "\"...");
BF2FileSystem.BF2FSEntry e = BF2FileSystem.FindEntryFromIngamePath(filename);
if (e == null)
{
return;
}
byte[] data = BF2FileSystem.GetFileFromZip(e.zipFile, e.inZipPath);
if (data == null)
{
Log.WriteLine("[BF2 HL] ERROR file not found!");
return;
}
string basePath = Path.GetDirectoryName(filename) + "\\";
string[] lines = SplitBinText(data);
int count = 0;
foreach (string line in lines)
{
count++;
string[] parts;
string tmp = line.ToLower();
if (tmp.Trim() == "")
{
continue;
}
if (tmp.StartsWith("rem"))
{
continue;
}
if (tmp.StartsWith("run"))
{
parts = line.Split(' ');
Load(basePath + parts[1].Replace("\"", "").Replace("/", "\\"));
}
else if (tmp.StartsWith("hudbuilder"))
{
BF2HUDBuilder.ProcessLine(line, count);
}
else if (tmp.StartsWith("hudmanager"))
{
BF2HUDManager.ProcessLine(line, count);
}
}
}
private static void LoadTerrain()
{
Log.WriteLine("[BF2 LL] Loading terrain...");
BF2FileSystem.BF2FSEntry e = BF2FileSystem.FindEntryFromIngamePath("Levels\\" + name + "\\terraindata.raw");
if (e == null)
{
return;
}
byte[] data = BF2FileSystem.GetFileFromZip(e.zipFile, e.inZipPath);
if (data == null)
{
return;
}
terrain = new BF2Terrain(data);
terrain.ConvertForEngine(engine);
engine.terrain = terrain.ro;
}
private static void LoadRoadObjects()
{
Log.WriteLine("[BF2 LL] Loading roads...");
BF2FileSystem.BF2FSEntry e = BF2FileSystem.FindEntryFromIngamePath("Levels\\" + name + "\\CompiledRoads.con");
if (e == null)
{
return;
}
byte[] data = BF2FileSystem.GetFileFromZip(e.zipFile, e.inZipPath);
if (data == null)
{
return;
}
string[] lines = Encoding.ASCII.GetString(data).Split('\n');
int pos = 0;
int count = 0;
while (pos < lines.Length)
{
Log.SetProgress(0, lines.Length, pos);
List <string> objectInfos = new List <string>();
while (lines[pos].Trim() != "")
{
objectInfos.Add(lines[pos++].Trim());
}
LoadRoadObject(objectInfos);
pos++;
if (count++ > 10)
{
count = 0;
GC.Collect();
}
}
Vector3 center = Vector3.Zero;
foreach (BF2LevelObject lo in objects)
{
center += lo.position;
}
center /= objects.Count();
engine.CamPos = center;
Log.SetProgress(0, lines.Length, 0);
}
private static BF2StaticMesh LoadStaticMesh(List <string> infos, BF2LevelObject lo)
{
string geoTemplate = Helper.FindLineStartingWith(infos, "GeometryTemplate.create");
if (geoTemplate == null)
{
return(null);
}
string[] parts = geoTemplate.Split(' ');
string templateName = parts[2].Trim() + ".staticmesh";
BF2FileSystem.BF2FSEntry entry = BF2FileSystem.FindFirstEntry(templateName);
byte[] data = BF2FileSystem.GetFileFromEntry(entry);
if (data == null)
{
return(null);
}
lo._data = data;
return(new BF2StaticMesh(data));
}
private static void LoadRoadObject(List <string> infos)
{
string objectName = Helper.FindLineStartingWith(infos, "object.create");
if (objectName == null)
{
return;
}
string meshName = Helper.FindLineStartingWith(infos, "object.geometry.loadMesh");
if (meshName == null)
{
return;
}
string position = Helper.FindLineStartingWith(infos, "object.absolutePosition");
Vector3 pos = Vector3.Zero;
Vector3 rot = Vector3.Zero;
if (position != null)
{
pos = Helper.ParseVector3(position.Split(' ')[1]);
}
objectName = objectName.Split(' ')[1];
meshName = meshName.Split(' ')[1];
BF2LevelObject lo = null;
bool foundCached = false;
foreach (BF2LevelObject obj in objects)
{
if (obj._template == meshName && obj.type == BF2LevelObject.BF2LOTYPE.Road)
{
lo = new BF2LevelObject(pos, rot, obj.type);
lo._template = meshName;
lo._name = objectName;
lo._data = obj._data.ToArray();
lo.properties = infos;
switch (obj.type)
{
case BF2LevelObject.BF2LOTYPE.Road:
BF2Mesh mesh = new BF2Mesh(lo._data);
if (mesh == null)
{
return;
}
Texture2D tex = FindRoadTexture(lo._name);
lo.meshes = mesh.ConvertForEngine(engine, tex);
foreach (RenderObject ro in lo.meshes)
{
ro.transform = lo.transform;
}
lo._valid = true;
foundCached = true;
break;
}
break;
}
}
if (!foundCached)
{
lo = new BF2LevelObject(pos, rot, BF2LevelObject.BF2LOTYPE.Road);
BF2FileSystem.BF2FSEntry entry = BF2FileSystem.FindFirstEntry(meshName);
lo._data = BF2FileSystem.GetFileFromEntry(entry);
if (lo._data == null)
{
return;
}
lo._template = meshName;
lo._name = objectName;
lo.properties = infos;
BF2Mesh mesh = new BF2Mesh(lo._data);
if (mesh == null)
{
return;
}
Texture2D tex = FindRoadTexture(lo._name);
lo.meshes = mesh.ConvertForEngine(engine, tex);
foreach (RenderObject ro in lo.meshes)
{
ro.transform = lo.transform;
}
lo._valid = true;
}
if (lo != null && lo._valid)
{
objects.Add(lo);
}
}
private static void LoadStaticObject(List <string> infos)
{
string templateName = Helper.FindLineStartingWith(infos, "Object.create");
if (templateName == null)
{
return;
}
string position = Helper.FindLineStartingWith(infos, "Object.absolutePosition");
string rotation = Helper.FindLineStartingWith(infos, "Object.rotation");
Vector3 pos = Vector3.Zero;
Vector3 rot = Vector3.Zero;
if (position != null)
{
pos = Helper.ParseVector3(position.Split(' ')[1]);
}
if (rotation != null)
{
rot = Helper.ParseVector3(rotation.Split(' ')[1]);
}
templateName = templateName.Split(' ')[1] + ".con";
BF2LevelObject lo = null;
bool foundCached = false;
foreach (BF2LevelObject obj in objects)
{
if (obj._template == templateName && obj.type == BF2LevelObject.BF2LOTYPE.StaticObject)
{
lo = new BF2LevelObject(pos, rot, obj.type);
lo._template = templateName;
lo._name = templateName;
lo._data = obj._data.ToArray();
lo.properties = infos;
switch (obj.type)
{
case BF2LevelObject.BF2LOTYPE.StaticObject:
BF2StaticMesh stm = new BF2StaticMesh(lo._data);
if (stm == null)
{
return;
}
lo.staticMeshes = stm.ConvertForEngine(engine, true, 0);
foreach (RenderObject ro in lo.staticMeshes)
{
ro.transform = lo.transform;
}
lo._valid = true;
foundCached = true;
break;
}
break;
}
}
if (!foundCached)
{
BF2FileSystem.BF2FSEntry entry = BF2FileSystem.FindFirstEntry(templateName);
byte[] data = BF2FileSystem.GetFileFromEntry(entry);
if (data == null)
{
return;
}
List <string> infosObject = new List <string>(Encoding.ASCII.GetString(data).Split('\n'));
string geoTemplate = Helper.FindLineStartingWith(infosObject, "GeometryTemplate.create");
if (geoTemplate == null)
{
return;
}
string[] parts = geoTemplate.Split(' ');
switch (parts[1].ToLower())
{
case "staticmesh":
lo = new BF2LevelObject(pos, rot, BF2LevelObject.BF2LOTYPE.StaticObject);
lo._template = templateName;
lo._name = templateName;
lo.properties = infos;
BF2StaticMesh stm = LoadStaticMesh(infosObject, lo);
if (stm == null)
{
return;
}
lo.staticMeshes = stm.ConvertForEngine(engine, true, 0);
foreach (RenderObject ro in lo.staticMeshes)
{
ro.transform = lo.transform;
}
lo._valid = true;
break;
}
}
if (lo != null && lo._valid)
{
objects.Add(lo);
}
}
