public Map PrepareMap(string uid)
{
if (LoadScreen != null)
{
LoadScreen.Display();
}
if (MapCache[uid].Status != MapStatus.Available)
{
throw new InvalidDataException("Invalid map uid: {0}".F(uid));
}
// Operate on a copy of the map to avoid gameplay state leaking into the cache
var map = new Map(MapCache[uid].Map.Path);
LoadTranslations(map);
// Reinit all our assets
InitializeLoaders();
GlobalFileSystem.LoadFromManifest(Manifest);
// Mount map package so custom assets can be used. TODO: check priority.
GlobalFileSystem.Mount(GlobalFileSystem.OpenPackage(map.Path, null, int.MaxValue));
using (new Support.PerfTimer("Map.PreloadRules"))
map.PreloadRules();
using (new Support.PerfTimer("Map.SequenceProvider.Preload"))
map.SequenceProvider.Preload();
VoxelProvider.Initialize(Manifest.VoxelSequences, map.VoxelSequenceDefinitions);
VoxelLoader.Finish();
return(map);
}
public static void RemapShp(string[] args)
{
var remap = new Dictionary <int, int>();
/* the first 4 entries are fixed */
for (var i = 0; i < 4; i++)
{
remap[i] = i;
}
var srcMod = args[1].Split(':')[0];
Game.modData = new ModData(srcMod);
GlobalFileSystem.LoadFromManifest(Game.modData.Manifest);
var srcRules = Game.modData.RulesetCache.LoadDefaultRules();
var srcPaletteInfo = srcRules.Actors["player"].Traits.Get <PlayerColorPaletteInfo>();
int[] srcRemapIndex = srcPaletteInfo.RemapIndex;
var destMod = args[2].Split(':')[0];
Game.modData = new ModData(destMod);
GlobalFileSystem.LoadFromManifest(Game.modData.Manifest);
var destRules = Game.modData.RulesetCache.LoadDefaultRules();
var destPaletteInfo = destRules.Actors["player"].Traits.Get <PlayerColorPaletteInfo>();
var destRemapIndex = destPaletteInfo.RemapIndex;
var shadowIndex = new int[] { };
// the remap range is always 16 entries, but their location and order changes
for (var i = 0; i < 16; i++)
{
remap[PlayerColorRemap.GetRemapIndex(srcRemapIndex, i)]
= PlayerColorRemap.GetRemapIndex(destRemapIndex, i);
}
// map everything else to the best match based on channel-wise distance
var srcPalette = Palette.Load(args[1].Split(':')[1], shadowIndex);
var destPalette = Palette.Load(args[2].Split(':')[1], shadowIndex);
var fullIndexRange = Exts.MakeArray <int>(256, x => x);
for (var i = 0; i < 256; i++)
{
if (!remap.ContainsKey(i))
{
remap[i] = fullIndexRange
.Where(a => !remap.ContainsValue(a))
.OrderBy(a => ColorDistance(destPalette.Values[a], srcPalette.Values[i]))
.First();
}
}
var srcImage = ShpReader.Load(args[3]);
using (var destStream = File.Create(args[4]))
ShpReader.Write(destStream, srcImage.Size,
srcImage.Frames.Select(im => im.Data.Select(px => (byte)remap[px]).ToArray()));
}
public void Run(ModData modData, string[] args)
{
var remap = new Dictionary <int, int>();
/* the first 4 entries are fixed */
for (var i = 0; i < 4; i++)
{
remap[i] = i;
}
var srcMod = args[1].Split(':')[0];
Game.ModData = new ModData(srcMod);
GlobalFileSystem.LoadFromManifest(Game.ModData.Manifest);
var srcRules = Game.ModData.RulesetCache.Load();
var srcPaletteInfo = srcRules.Actors["player"].Traits.Get <PlayerColorPaletteInfo>();
var srcRemapIndex = srcPaletteInfo.RemapIndex;
var destMod = args[2].Split(':')[0];
Game.ModData = new ModData(destMod);
GlobalFileSystem.LoadFromManifest(Game.ModData.Manifest);
var destRules = Game.ModData.RulesetCache.Load();
var destPaletteInfo = destRules.Actors["player"].Traits.Get <PlayerColorPaletteInfo>();
var destRemapIndex = destPaletteInfo.RemapIndex;
var shadowIndex = new int[] { };
// the remap range is always 16 entries, but their location and order changes
for (var i = 0; i < 16; i++)
{
remap[PlayerColorRemap.GetRemapIndex(srcRemapIndex, i)]
= PlayerColorRemap.GetRemapIndex(destRemapIndex, i);
}
// map everything else to the best match based on channel-wise distance
var srcPalette = new ImmutablePalette(args[1].Split(':')[1], shadowIndex);
var destPalette = new ImmutablePalette(args[2].Split(':')[1], shadowIndex);
for (var i = 0; i < Palette.Size; i++)
{
if (!remap.ContainsKey(i))
{
remap[i] = Enumerable.Range(0, Palette.Size)
.Where(a => !remap.ContainsValue(a))
.MinBy(a => ColorDistance(destPalette[a], srcPalette[i]));
}
}
using (var s = File.OpenRead(args[3]))
using (var destStream = File.Create(args[4]))
{
var srcImage = new ShpTDSprite(s);
ShpTDSprite.Write(destStream, srcImage.Size,
srcImage.Frames.Select(im => im.Data.Select(px => (byte)remap[px]).ToArray()));
}
}
public Form1(string[] args)
{
InitializeComponent();
AppDomain.CurrentDomain.AssemblyResolve += GlobalFileSystem.ResolveAssembly;
currentMod = args.FirstOrDefault() ?? "ra";
toolStripComboBox1.Items.AddRange(ModMetadata.AllMods.Keys.ToArray());
toolStripComboBox1.SelectedIndexChanged += (_, e) =>
{
tilePalette.SuspendLayout();
actorPalette.SuspendLayout();
resourcePalette.SuspendLayout();
tilePalette.Controls.Clear();
actorPalette.Controls.Clear();
resourcePalette.Controls.Clear();
tilePalette.ResumeLayout();
actorPalette.ResumeLayout();
resourcePalette.ResumeLayout();
surface1.Bind(null, null, null, null, null);
miniMapBox.Image = null;
currentMod = toolStripComboBox1.SelectedItem as string;
Game.InitializeSettings(Arguments.Empty);
Game.ModData = new ModData(currentMod);
GlobalFileSystem.LoadFromManifest(Game.ModData.Manifest);
Program.Rules = Game.ModData.RulesetCache.LoadDefaultRules();
var mod = Game.ModData.Manifest.Mod;
Text = "{0} Mod Version: {1} - OpenRA Editor".F(mod.Title, mod.Version);
loadedMapName = null;
};
toolStripComboBox1.SelectedItem = currentMod;
surface1.AfterChange += OnMapChanged;
surface1.MousePositionChanged += s => toolStripStatusLabelMousePosition.Text = s;
surface1.ActorDoubleClicked += ActorDoubleClicked;
if (args.Length >= 2)
{
LoadMap(args[1]);
}
}
public void Run(ModData modData, string[] args)
{
var files = args.Skip(1);
GlobalFileSystem.LoadFromManifest(modData.Manifest);
foreach (var f in files)
{
var src = GlobalFileSystem.Open(f);
if (src == null)
{
throw new InvalidOperationException("File not found: {0}".F(f));
}
var data = src.ReadAllBytes();
File.WriteAllBytes(f, data);
Console.WriteLine(f + " saved.");
}
}
public static void ExtractFiles(string[] args)
{
var mod = args[1];
var files = args.Skip(2);
var manifest = new Manifest(mod);
GlobalFileSystem.LoadFromManifest(manifest);
foreach (var f in files)
{
var src = GlobalFileSystem.Open(f);
if (src == null)
{
throw new InvalidOperationException("File not found: {0}".F(f));
}
var data = src.ReadAllBytes();
File.WriteAllBytes(f, data);
Console.WriteLine(f + " saved.");
}
}
public void Run(ModData modData, string[] args)
{
// HACK: The engine code assumes that Game.modData is set.
Game.ModData = modData;
GlobalFileSystem.LoadFromManifest(Game.ModData.Manifest);
Game.ModData.SpriteSequenceLoader.OnMissingSpriteError = s => Console.WriteLine("\t" + s);
foreach (var t in Game.ModData.Manifest.TileSets)
{
var ts = new TileSet(Game.ModData, t);
Console.WriteLine("Tileset: " + ts.Name);
var sc = new SpriteCache(modData.SpriteLoaders, new SheetBuilder(SheetType.Indexed));
var sequenceFiles = modData.Manifest.Sequences;
var nodes = sequenceFiles
.Select(s => MiniYaml.FromFile(s))
.Aggregate(MiniYaml.MergeLiberal);
foreach (var n in nodes)
{
Game.ModData.SpriteSequenceLoader.ParseSequences(Game.ModData, ts, sc, n);
}
}
}
public void MountFiles()
{
GlobalFileSystem.LoadFromManifest(Manifest);
}
public void Run(ModData modData, string[] args)
{
// HACK: The engine code assumes that Game.modData is set.
Game.modData = modData;
GlobalFileSystem.LoadFromManifest(Game.modData.Manifest);
var file = new IniFile(File.Open(args[1], FileMode.Open));
var templateIndex = 0;
var extension = "tem";
var terrainTypes = new Dictionary <int, string>()
{
{ 1, "Clear" }, // Desert sand(?)
{ 5, "Road" }, // Paved road
{ 6, "Rail" }, // Monorail track
{ 7, "Impassable" }, // Building
{ 9, "Water" }, // Deep water(?)
{ 10, "Water" }, // Shallow water
{ 11, "Road" }, // Paved road (again?)
{ 12, "DirtRoad" }, // Dirt road
{ 13, "Clear" }, // Regular clear terrain
{ 14, "Rough" }, // Rough terrain (cracks etc)
{ 15, "Cliff" }, // Cliffs
};
// Loop over template sets
try
{
for (var tilesetGroupIndex = 0; ; tilesetGroupIndex++)
{
var section = file.GetSection("TileSet{0:D4}".F(tilesetGroupIndex));
var sectionCount = int.Parse(section.GetValue("TilesInSet", "1"));
var sectionFilename = section.GetValue("FileName", "");
var sectionCategory = section.GetValue("SetName", "");
// Loop over templates
for (var i = 1; i <= sectionCount; i++, templateIndex++)
{
var templateFilename = "{0}{1:D2}.{2}".F(sectionFilename, i, extension);
if (!GlobalFileSystem.Exists(templateFilename))
{
continue;
}
using (var s = GlobalFileSystem.Open(templateFilename))
{
Console.WriteLine("\tTemplate@{0}:", templateIndex);
Console.WriteLine("\t\tCategory: {0}", sectionCategory);
Console.WriteLine("\t\tId: {0}", templateIndex);
Console.WriteLine("\t\tImage: {0}{1:D2}", sectionFilename, i);
var templateWidth = s.ReadUInt32();
var templateHeight = s.ReadUInt32();
/* var tileWidth = */ s.ReadInt32();
/* var tileHeight = */ s.ReadInt32();
var offsets = new uint[templateWidth * templateHeight];
for (var j = 0; j < offsets.Length; j++)
{
offsets[j] = s.ReadUInt32();
}
Console.WriteLine("\t\tSize: {0}, {1}", templateWidth, templateHeight);
Console.WriteLine("\t\tTiles:");
for (var j = 0; j < offsets.Length; j++)
{
if (offsets[j] == 0)
{
continue;
}
s.Position = offsets[j] + 40;
/* var height = */ s.ReadUInt8();
var terrainType = s.ReadUInt8();
/* var rampType = */ s.ReadUInt8();
/* var height = */ s.ReadUInt8();
if (!terrainTypes.ContainsKey(terrainType))
{
throw new InvalidDataException("Unknown terrain type {0} in {1}".F(terrainType, templateFilename));
}
Console.WriteLine("\t\t\t{0}: {1}", j, terrainTypes[terrainType]);
// Console.WriteLine("\t\t\t\tHeight: {0}", height);
// Console.WriteLine("\t\t\t\tTerrainType: {0}", terrainType);
// Console.WriteLine("\t\t\t\tRampType: {0}", rampType);
// Console.WriteLine("\t\t\t\tLeftColor: {0},{1},{2}", s.ReadUInt8(), s.ReadUInt8(), s.ReadUInt8());
// Console.WriteLine("\t\t\t\tRightColor: {0},{1},{2}", s.ReadUInt8(), s.ReadUInt8(), s.ReadUInt8());
}
}
}
}
}
catch (InvalidOperationException)
{
// GetSection will throw when we run out of sections to import
}
}
public void Run(ModData modData, string[] args)
{
// HACK: The engine code assumes that Game.modData is set.
Game.ModData = modData;
GlobalFileSystem.LoadFromManifest(Game.ModData.Manifest);
var imageField = typeof(TerrainTemplateInfo).GetField("Image");
var pickAnyField = typeof(TerrainTemplateInfo).GetField("PickAny");
var tileInfoField = typeof(TerrainTemplateInfo).GetField("tileInfo", BindingFlags.NonPublic | BindingFlags.Instance);
var terrainTypeField = typeof(TerrainTileInfo).GetField("TerrainType");
var terrainLeftColorField = typeof(TerrainTileInfo).GetField("LeftColor");
var terrainRightColorField = typeof(TerrainTileInfo).GetField("RightColor");
var empty = new Size(0, 0);
var single = new int2(1, 1);
var exts = new[] { "" }.Concat(args[1].Split(','));
foreach (var t in Game.ModData.Manifest.TileSets)
{
var ts = new TileSet(Game.ModData, t);
var frameCache = new FrameCache(Game.ModData.SpriteLoaders);
Console.WriteLine("Tileset: " + ts.Name);
foreach (var template in ts.Templates.Values)
{
// Find the sprite associated with this template
foreach (var ext in exts)
{
Stream s;
if (!GlobalFileSystem.TryOpen(template.Images[0] + ext, out s))
{
continue;
}
// Rewrite the template image (normally readonly) using reflection
imageField.SetValue(template, template.Images[0] + ext);
// Fetch the private tileInfo array so that we can write new entries
var tileInfo = (TerrainTileInfo[])tileInfoField.GetValue(template);
// Open the file and search for any implicit frames
var allFrames = frameCache[template.Images[0]];
var frames = template.Frames != null?template.Frames.Select(f => allFrames[f]).ToArray() : allFrames;
// Resize array for new entries
if (frames.Length > template.TilesCount)
{
var ti = new TerrainTileInfo[frames.Length];
Array.Copy(tileInfo, ti, template.TilesCount);
tileInfoField.SetValue(template, ti);
tileInfo = ti;
}
for (var i = 0; i < template.TilesCount; i++)
{
if (template[i] == null && frames[i] != null && frames[i].Size != empty)
{
tileInfo[i] = new TerrainTileInfo();
var ti = ts.GetTerrainIndex("Clear");
terrainTypeField.SetValue(tileInfo[i], ti);
terrainLeftColorField.SetValue(tileInfo[i], ts[ti].Color);
terrainRightColorField.SetValue(tileInfo[i], ts[ti].Color);
Console.WriteLine("Fixing entry for {0}:{1}", template.Images[0], i);
}
}
if (template.TilesCount > 1 && template.Size == single)
{
pickAnyField.SetValue(template, true);
}
s.Dispose();
}
}
ts.Save(t);
}
}
public void Run(ModData modData, string[] args)
{
// HACK: The engine code assumes that Game.modData is set.
Game.ModData = modData;
GlobalFileSystem.LoadFromManifest(Game.ModData.Manifest);
var file = new IniFile(File.Open(args[1], FileMode.Open));
var extension = args[2];
var templateIndex = 0;
var terrainTypes = new string[]
{
"Clear",
"Clear", // Note: sometimes "Ice"
"Ice",
"Ice",
"Ice",
"Road", // TS defines this as "Tunnel", but we don't need this
"Rail",
"Impassable", // TS defines this as "Rock", but also uses it for buildings
"Impassable",
"Water",
"Water", // TS defines this as "Beach", but uses it for water...?
"Road",
"DirtRoad", // TS defines this as "Road", but we may want different speeds
"Clear",
"Rough",
"Cliff" // TS defines this as "Rock"
};
// Loop over template sets
try
{
for (var tilesetGroupIndex = 0;; tilesetGroupIndex++)
{
var section = file.GetSection("TileSet{0:D4}".F(tilesetGroupIndex));
var sectionCount = int.Parse(section.GetValue("TilesInSet", "1"));
var sectionFilename = section.GetValue("FileName", "");
var sectionCategory = section.GetValue("SetName", "");
// Loop over templates
for (var i = 1; i <= sectionCount; i++, templateIndex++)
{
var templateFilename = "{0}{1:D2}.{2}".F(sectionFilename, i, extension);
if (!GlobalFileSystem.Exists(templateFilename))
{
continue;
}
using (var s = GlobalFileSystem.Open(templateFilename))
{
Console.WriteLine("\tTemplate@{0}:", templateIndex);
Console.WriteLine("\t\tCategory: {0}", sectionCategory);
Console.WriteLine("\t\tId: {0}", templateIndex);
var images = new List <string>();
images.Add("{0}{1:D2}.{2}".F(sectionFilename, i, extension));
for (var v = 'a'; v <= 'z'; v++)
{
var variant = "{0}{1:D2}{2}.{3}".F(sectionFilename, i, v, extension);
if (GlobalFileSystem.Exists(variant))
{
images.Add(variant);
}
}
Console.WriteLine("\t\tImage: {0}", images.JoinWith(", "));
var templateWidth = s.ReadUInt32();
var templateHeight = s.ReadUInt32();
/* var tileWidth = */ s.ReadInt32();
/* var tileHeight = */ s.ReadInt32();
var offsets = new uint[templateWidth * templateHeight];
for (var j = 0; j < offsets.Length; j++)
{
offsets[j] = s.ReadUInt32();
}
Console.WriteLine("\t\tSize: {0}, {1}", templateWidth, templateHeight);
Console.WriteLine("\t\tTiles:");
for (var j = 0; j < offsets.Length; j++)
{
if (offsets[j] == 0)
{
continue;
}
s.Position = offsets[j] + 40;
var height = s.ReadUInt8();
var terrainType = s.ReadUInt8();
var rampType = s.ReadUInt8();
if (terrainType >= terrainTypes.Length)
{
throw new InvalidDataException("Unknown terrain type {0} in {1}".F(terrainType, templateFilename));
}
Console.WriteLine("\t\t\t{0}: {1}", j, terrainTypes[terrainType]);
if (height != 0)
{
Console.WriteLine("\t\t\t\tHeight: {0}", height);
}
if (rampType != 0)
{
Console.WriteLine("\t\t\t\tRampType: {0}", rampType);
}
Console.WriteLine("\t\t\t\tLeftColor: {0},{1},{2}", s.ReadUInt8(), s.ReadUInt8(), s.ReadUInt8());
Console.WriteLine("\t\t\t\tRightColor: {0},{1},{2}", s.ReadUInt8(), s.ReadUInt8(), s.ReadUInt8());
}
}
}
}
}
catch (InvalidOperationException)
{
// GetSection will throw when we run out of sections to import
}
}