private void RecursiveAddChunkNode(TreeNodeCollection xiNodes, int xiIndex, Chunk xiChunk)
{
TreeNode lNode = xiNodes.Insert(xiIndex, xiChunk.Name);
//record the mapping on the two objects, for easy reference later
//no doubt, this will play merry hell with the GC if you load lots
//of different levels...
lNode.Tag = xiChunk;
xiChunk.TreeNode = lNode;
//recurse
foreach (Chunk child in xiChunk.GetChildren())
{
RecursiveAddChunkNode(lNode.Nodes, child);
}
}
///========================================================================
/// Method : GetDifferences
///
/// <summary>
/// Produce a list of differences between this chunk and another.
///
/// Subclasses should override this method to produce a customised list
/// of differences for themselves, but call the base implementation
/// which will handle collecting data from their children.
/// </summary>
/// <param name="xiChunk"></param>
/// <returns></returns>
/// <remarks>
/// This is a brute force method of comparing differences. An alternative
/// would be to record the actual actions taken in the UI - this would
/// produce cleaner results, although it would be more work to implement.
/// </remarks>
///========================================================================
public virtual List<string> GetDifferences(Chunk xiChunk)
{
//=======================================================================
// Get a list of all the children of this chunk, by type
//=======================================================================
Dictionary<Type, List<Chunk>> lMyChildren = new Dictionary<Type, List<Chunk>>();
foreach (Chunk lChunk in GetChildren())
{
List<Chunk> lChunksOfType;
if (!lMyChildren.TryGetValue(lChunk.GetType(), out lChunksOfType))
{
lChunksOfType = new List<Chunk>();
lMyChildren[lChunk.GetType()] = lChunksOfType;
}
lChunksOfType.Add(lChunk);
}
//=======================================================================
// Get a list of all the children of the old chunk, by type
//=======================================================================
Dictionary<Type, List<Chunk>> lOldChildren = new Dictionary<Type, List<Chunk>>();
foreach (Chunk lChunk in xiChunk.GetChildren())
{
List<Chunk> lChunksOfType;
if (!lOldChildren.TryGetValue(lChunk.GetType(), out lChunksOfType))
{
lChunksOfType = new List<Chunk>();
lOldChildren[lChunk.GetType()] = lChunksOfType;
}
lChunksOfType.Add(lChunk);
}
//=======================================================================
// Generate the list of differences
//=======================================================================
List<string> lDifferences = new List<string>();
foreach (Type lChunkType in lMyChildren.Keys)
{
List<Chunk> lMine = lMyChildren[lChunkType];
if (!lOldChildren.ContainsKey(lChunkType))
{
lDifferences.Add(string.Format(" Added {0} {1}(s)", lMine.Count, lChunkType));
continue;
}
List<Chunk> lOld = lOldChildren[lChunkType];
for (int ii = 0; ii < Math.Min(lMine.Count, lOld.Count); ii++)
{
List<string> lChildDifferences = lMine[ii].GetDifferences(lOld[ii]);
if (lChildDifferences.Count > 0)
{
lDifferences.AddRange(
lChildDifferences.ConvertAll<string>(
new Converter<string, string>(delegate(string xiDifference)
{ return " " + xiDifference; })));
}
}
if (lMine.Count > lOld.Count)
{
lDifferences.Add(string.Format(" Added {0} {1}(s)", lMine.Count - lOld.Count, lChunkType));
}
else if (lOld.Count > lMine.Count)
{
lDifferences.Add(string.Format(" Removed {0} {1}(s)", lOld.Count - lMine.Count, lChunkType));
}
lOldChildren.Remove(lChunkType);
}
foreach (Type lChunkType in lOldChildren.Keys)
{
List<Chunk> lOld = lOldChildren[lChunkType];
lDifferences.Add(string.Format(" Removed {0} {1}(s)", lOld.Count, lChunkType));
}
if (lDifferences.Count > 0)
{
lDifferences.Insert(0, string.Format("On {0}:", Name));
}
return lDifferences;
}
///========================================================================
/// Method : GetDifferences
///
/// <summary>
/// Produce a list of differences between this chunk and another.
///
/// Subclasses should override this method to produce a customised list
/// of differences for themselves, but call the base implementation
/// which will handle collecting data from their children.
/// </summary>
/// <param name="xiChunk"></param>
/// <returns></returns>
/// <remarks>
/// This is a brute force method of comparing differences. An alternative
/// would be to record the actual actions taken in the UI - this would
/// produce cleaner results, although it would be more work to implement.
/// </remarks>
///========================================================================
public virtual List <string> GetDifferences(Chunk xiChunk)
{
//=======================================================================
// Get a list of all the children of this chunk, by type
//=======================================================================
Dictionary <Type, List <Chunk> > lMyChildren = new Dictionary <Type, List <Chunk> >();
foreach (Chunk lChunk in GetChildren())
{
List <Chunk> lChunksOfType;
if (!lMyChildren.TryGetValue(lChunk.GetType(), out lChunksOfType))
{
lChunksOfType = new List <Chunk>();
lMyChildren[lChunk.GetType()] = lChunksOfType;
}
lChunksOfType.Add(lChunk);
}
//=======================================================================
// Get a list of all the children of the old chunk, by type
//=======================================================================
Dictionary <Type, List <Chunk> > lOldChildren = new Dictionary <Type, List <Chunk> >();
foreach (Chunk lChunk in xiChunk.GetChildren())
{
List <Chunk> lChunksOfType;
if (!lOldChildren.TryGetValue(lChunk.GetType(), out lChunksOfType))
{
lChunksOfType = new List <Chunk>();
lOldChildren[lChunk.GetType()] = lChunksOfType;
}
lChunksOfType.Add(lChunk);
}
//=======================================================================
// Generate the list of differences
//=======================================================================
List <string> lDifferences = new List <string>();
foreach (Type lChunkType in lMyChildren.Keys)
{
List <Chunk> lMine = lMyChildren[lChunkType];
if (!lOldChildren.ContainsKey(lChunkType))
{
lDifferences.Add(string.Format(" Added {0} {1}(s)", lMine.Count, lChunkType));
continue;
}
List <Chunk> lOld = lOldChildren[lChunkType];
for (int ii = 0; ii < Math.Min(lMine.Count, lOld.Count); ii++)
{
List <string> lChildDifferences = lMine[ii].GetDifferences(lOld[ii]);
if (lChildDifferences.Count > 0)
{
lDifferences.AddRange(
lChildDifferences.ConvertAll <string>(
new Converter <string, string>(delegate(string xiDifference)
{ return(" " + xiDifference); })));
}
}
if (lMine.Count > lOld.Count)
{
lDifferences.Add(string.Format(" Added {0} {1}(s)", lMine.Count - lOld.Count, lChunkType));
}
else if (lOld.Count > lMine.Count)
{
lDifferences.Add(string.Format(" Removed {0} {1}(s)", lOld.Count - lMine.Count, lChunkType));
}
lOldChildren.Remove(lChunkType);
}
foreach (Type lChunkType in lOldChildren.Keys)
{
List <Chunk> lOld = lOldChildren[lChunkType];
lDifferences.Add(string.Format(" Removed {0} {1}(s)", lOld.Count, lChunkType));
}
if (lDifferences.Count > 0)
{
lDifferences.Insert(0, string.Format("On {0}:", Name));
}
return(lDifferences);
}
private static void AddChunkToImage(Chunk xiChunk, Bitmap xiBmp, int[,] xiPixelUsageMap)
{
if (xiChunk is TIMChunk)
{
try
{
TIMChunk c = (TIMChunk)xiChunk;
Bitmap lTIMImage = c.ToBitmap();
int lPixelsPerTwoBytes;
switch (c.BPP)
{
case TIMChunk.TimBPP._4BPP:
lPixelsPerTwoBytes = 4;
break;
case TIMChunk.TimBPP._8BPP:
lPixelsPerTwoBytes = 2;
break;
case TIMChunk.TimBPP._16BPP:
lPixelsPerTwoBytes = 1;
break;
default: throw new Exception("Can't deal with this BPP");
}
Rectangle lDestRect = new Rectangle(
WIDTH_SCALE * c.ImageOrgX,
c.ImageOrgY,
c.ImageWidth * WIDTH_SCALE / lPixelsPerTwoBytes,
c.ImageHeight);
int lWidthScale = WIDTH_SCALE / lPixelsPerTwoBytes;
for (int y = lDestRect.Top; y < lDestRect.Bottom; y++)
{
for (int x = lDestRect.Left; x < lDestRect.Right; x++)
{
Color lFromTIM = lTIMImage.GetPixel((x - lDestRect.Left) * lWidthScale, y - lDestRect.Top);
SetPixel(xiBmp, x, y, lFromTIM, xiPixelUsageMap);
}
}
if (c.Palette != null)
{
if (c.ClutCount != 1) throw new Exception("Don't know what to do with multi-CLUT TIMs");
for (int palIdx = 0; palIdx < c.Palette.Length; palIdx++)
{
Color col = Color.FromArgb(Utils.PS16bitColorToARGB(c.Palette[palIdx]));
for (int x = 0; x < WIDTH_SCALE; x++)
{
SetPixel(xiBmp, WIDTH_SCALE * (c.PaletteOrgX + palIdx) + x, c.PaletteOrgY, col, xiPixelUsageMap);
}
}
}
}
catch (Exception e)
{
Console.Error.WriteLine("Error: {0}\nSkipping this TIM", e);
}
}
else
{
foreach (Chunk c in xiChunk.GetChildren())
{
AddChunkToImage(c, xiBmp, xiPixelUsageMap);
}
}
}
private void RecursiveAddChunkNode(TreeNodeCollection xiNodes, int xiIndex, Chunk xiChunk)
{
TreeNode lNode = xiNodes.Insert(xiIndex, xiChunk.Name);
//record the mapping on the two objects, for easy reference later
//no doubt, this will play merry hell with the GC if you load lots
//of different levels...
lNode.Tag = xiChunk;
xiChunk.TreeNode = lNode;
//recurse
foreach (Chunk child in xiChunk.GetChildren())
{
RecursiveAddChunkNode(lNode.Nodes, child);
}
}
private void AddChunkToImage(Chunk c, Graphics g)
{
if (c is TIMChunk) AddChunkToImage((TIMChunk)c, g);
foreach (Chunk child in c.GetChildren())
{
if (child is TIMChunk)
{
AddChunkToImage((TIMChunk)child, g);
}
else
{
AddChunkToImage(child, g);
}
}
}