private void SavePatchXML()
{
List <AsmPatch> patches = GetAllSelectedPatches();
foreach (AsmPatch patch in patches)
{
patch.Update(AsmUtility);
}
FreeSpaceMode mode = FreeSpace.GetMode(AsmUtility);
string xml = PatchXmlReader.CreatePatchXML(patches, mode);
SaveFileDialog saveFileDialog = new SaveFileDialog();
saveFileDialog.Filter = "XML file (*.xml)|*.xml";
saveFileDialog.FileName = string.Empty;
saveFileDialog.CheckFileExists = false;
if (saveFileDialog.ShowDialog(this) == DialogResult.OK)
{
btn_SavePatchXML.Enabled = false;
System.IO.File.WriteAllText(saveFileDialog.FileName, xml, Encoding.UTF8);
PatcherLib.MyMessageBox.Show(this, "Complete!", "Complete!", MessageBoxButtons.OK);
Close();
}
}
private void btn_OpenConflictChecker_Click(object sender, EventArgs e)
{
FreeSpaceMode mode = FreeSpace.GetMode(asmUtility);
ConflictCheckerForm conflictCheckerForm = new ConflictCheckerForm(GetCurrentFilePatches(), mode);
conflictCheckerForm.Show();
}
public ConflictCheckerForm(IList <AsmPatch> patchList, FreeSpaceMode mode)
{
InitializeComponent();
this.origPatchList = patchList;
this.conflictPatchData = ConflictHelper.CheckConflicts(patchList, mode);
FindPatchColors(this.conflictPatchData.PatchList);
ShowPatches(this.conflictPatchData);
}
public FreeSpaceForm(List <AsmPatch> patchList, ASMEncoding.ASMEncodingUtility asmUtility)
{
InitializeComponent();
FreeSpaceMode mode = (asmUtility.EncodingMode == ASMEncoding.ASMEncodingMode.PSP) ? FreeSpaceMode.PSP : FreeSpaceMode.PSX;
InitFiles(mode);
Init(patchList, asmUtility, mode);
}
public string CreateXML(FreeSpaceMode mode)
{
Context context = (mode == FreeSpaceMode.PSP) ? Context.US_PSP : Context.US_PSX;
System.Text.StringBuilder sb = new System.Text.StringBuilder();
sb.AppendFormat(" <Patch name=\"{0}\">{1}", Name, Environment.NewLine);
if (!string.IsNullOrEmpty(Description))
{
sb.AppendFormat(" <Description> {0} </Description>{1}", Description, Environment.NewLine);
}
sb.Append(PatcherLib.Utilities.Utilities.CreatePatchXML(innerList, context));
foreach (VariableType variable in Variables)
{
int value = variable.ByteArray.ToIntLE();
System.Text.StringBuilder sbSpecific = new System.Text.StringBuilder();
int patchCount = variable.Content.Count;
for (int index = 0; index < patchCount; index++)
{
PatchedByteArray patchedByteArray = variable.Content[index];
//string file = Enum.GetName(typeof(PatcherLib.Iso.PsxIso.Sectors), patchedByteArray.Sector);
//string file = PatcherLib.Iso.PsxIso.GetSectorName(patchedByteArray.Sector);
/*
* Type sectorType = (mode == FreeSpaceMode.PSP) ? typeof(PatcherLib.Iso.PspIso.Sectors) : typeof(PatcherLib.Iso.PsxIso.Sectors);
* Enum sector = (Enum)Enum.ToObject(sectorType, patchedByteArray.Sector);
* string file = (mode == FreeSpaceMode.PSP)
* ? PatcherLib.Iso.PspIso.GetSectorName((PatcherLib.Iso.PspIso.Sectors)sector)
* : PatcherLib.Iso.PsxIso.GetSectorName((PatcherLib.Iso.PsxIso.Sectors)sector);
*/
string file = ISOHelper.GetSectorName(patchedByteArray.SectorEnum);
sbSpecific.AppendFormat("{0}:{1}{2}", file, patchedByteArray.Offset.ToString("X"), ((index < (patchCount - 1)) ? "," : ""));
}
string strVariableReference = "";
if (variable.IsReference)
{
strVariableReference = String.Format(" reference=\"{0}\" operator=\"{1}\" operand=\"{2}\"", variable.Reference.Name, variable.Reference.Operand, variable.Reference.OperatorSymbol);
}
string strDefault = variable.IsReference ? "" : String.Format(" default=\"{0}\"", value.ToString("X"));
string strSpecific = sbSpecific.ToString();
string strContent = string.IsNullOrEmpty(strSpecific) ? "symbol=\"true\"" : String.Format("specific=\"{0}\"", strSpecific);
sb.AppendFormat(" <Variable name=\"{0}\" {1} bytes=\"{2}\"{3}{4} />{5}",
variable.Name, strContent, variable.NumBytes, strDefault, strVariableReference, Environment.NewLine);
}
sb.AppendLine(" </Patch>");
return(sb.ToString());
}
public static bool IsContainedWithinFreeSpace(PatchRange range, FreeSpaceMode mode)
{
foreach (PatchRange freeSpaceRange in GetRanges(mode))
{
if (range.IsContainedWithin(freeSpaceRange))
{
return(true);
}
}
return(false);
}
public static bool HasFreeSpaceOverlap(PatchRange range, FreeSpaceMode mode)
{
foreach (PatchRange freeSpaceRange in GetRanges(mode))
{
if (range.HasOverlap(freeSpaceRange))
{
return(true);
}
}
return(false);
}
public static string CreatePatchXML(IEnumerable <AsmPatch> patches, FreeSpaceMode mode)
{
StringBuilder sb = new StringBuilder();
sb.AppendLine("<?xml version=\"1.0\" encoding=\"utf-8\" ?>");
sb.AppendLine("<Patches>");
foreach (AsmPatch patch in patches)
{
sb.Append(patch.CreateXML(mode));
}
sb.AppendLine("</Patches>");
return(sb.ToString());
}
public static FreeSpaceMaps GetFreeSpaceMaps(IEnumerable <AsmPatch> patches, FreeSpaceMode mode)
{
Dictionary <PatchedByteArray, AsmPatch> innerPatchMap = new Dictionary <PatchedByteArray, AsmPatch>();
Dictionary <PatchRange, List <PatchedByteArray> > patchRangeMap = new Dictionary <PatchRange, List <PatchedByteArray> >();
Dictionary <PatchRange, HashSet <AsmPatch> > outerPatchRangeMap = new Dictionary <PatchRange, HashSet <AsmPatch> >();
PatchRange[] ranges = GetRanges(mode);
foreach (AsmPatch patch in patches)
{
List <PatchedByteArray> combinedPatchList = patch.GetCombinedPatchList();
foreach (PatchedByteArray patchedByteArray in combinedPatchList)
{
if (patchedByteArray is InputFilePatch)
{
continue;
}
if (patchedByteArray.SectorEnum.GetType() == typeof(FFTPack.Files))
{
continue;
}
if (!innerPatchMap.ContainsKey(patchedByteArray))
{
innerPatchMap.Add(patchedByteArray, patch);
}
//long patchedByteArrayEndOffset = patchedByteArray.Offset + patchedByteArray.GetBytes().Length - 1;
foreach (PatchRange range in ranges)
{
//long positionEndOffset = position.StartLocation + position.Length - 1;
//if ((((PsxIso.Sectors)patchedByteArray.Sector) == position.Sector) && (patchedByteArrayEndOffset >= position.StartLocation) && (patchedByteArray.Offset <= positionEndOffset))
if (range.HasOverlap(patchedByteArray))
{
if (patchRangeMap.ContainsKey(range))
{
patchRangeMap[range].Add(patchedByteArray);
}
else
{
patchRangeMap.Add(range, new List <PatchedByteArray>()
{
patchedByteArray
});
}
if (outerPatchRangeMap.ContainsKey(range))
{
outerPatchRangeMap[range].Add(patch);
}
else
{
outerPatchRangeMap.Add(range, new HashSet <AsmPatch>()
{
patch
});
}
}
}
}
foreach (PatchRange range in ranges)
{
if (patchRangeMap.ContainsKey(range))
{
patchRangeMap[range].Sort(
delegate(PatchedByteArray patchedByteArray1, PatchedByteArray patchedByteArray2)
{
return(patchedByteArray1.Offset.CompareTo(patchedByteArray2.Offset));
}
);
}
}
}
return(new FreeSpaceMaps
{
InnerPatchMap = innerPatchMap,
PatchRangeMap = patchRangeMap,
OuterPatchRangeMap = outerPatchRangeMap
});
}
public static Context GetContext(FreeSpaceMode mode)
{
return((mode == FreeSpaceMode.PSP) ? Context.US_PSP : Context.US_PSX);
}
private void Init(List <AsmPatch> patchList, ASMEncoding.ASMEncodingUtility asmUtility, FreeSpaceMode mode)
{
this.patchList = patchList;
this.asmUtility = asmUtility;
this.freeSpaceMaps = FreeSpace.GetFreeSpaceMaps(patchList, mode);
}
public static ConflictCheckResult CheckConflicts(IList <AsmPatch> patchList, FreeSpaceMode mode)
{
List <AsmPatch> resultPatchList = new List <AsmPatch>();
Dictionary <AsmPatch, List <PatchRangeConflict> > conflictMap = new Dictionary <AsmPatch, List <PatchRangeConflict> >();
Dictionary <AsmPatch, List <PatchedByteArray> > combinedPatchListMap = new Dictionary <AsmPatch, List <PatchedByteArray> >();
foreach (AsmPatch patch in patchList)
{
combinedPatchListMap[patch] = patch.GetCombinedPatchList();
}
for (int patchIndex = 0; patchIndex < patchList.Count; patchIndex++)
{
AsmPatch patch = patchList[patchIndex];
List <PatchedByteArray> combinedPatchList = combinedPatchListMap[patch];
foreach (PatchedByteArray patchedByteArray in combinedPatchList)
{
if (patchedByteArray is InputFilePatch)
{
continue;
}
PatchRange range = new PatchRange(patchedByteArray);
for (int conflictPatchIndex = patchIndex + 1; conflictPatchIndex < patchList.Count; conflictPatchIndex++)
{
AsmPatch conflictPatch = patchList[conflictPatchIndex];
List <PatchedByteArray> conflictCombinedPatchList = combinedPatchListMap[conflictPatch];
foreach (PatchedByteArray conflictPatchedByteArray in conflictCombinedPatchList)
{
if (conflictPatchedByteArray is InputFilePatch)
{
continue;
}
//if (patchedByteArray.IsPatchEqual(conflictPatchedByteArray))
if (!patchedByteArray.HasConflict(conflictPatchedByteArray))
{
continue;
}
PatchRange conflictRange = new PatchRange(conflictPatchedByteArray);
if (range.HasOverlap(conflictRange))
{
bool isInFreeSpace = FreeSpace.IsContainedWithinFreeSpace(range, mode);
PatchRangeConflict patchConflict = new PatchRangeConflict(range, conflictPatch, conflictRange, isInFreeSpace);
PatchRangeConflict reversePatchConflict = new PatchRangeConflict(conflictRange, patch, range, isInFreeSpace);
if (conflictMap.ContainsKey(patch))
{
conflictMap[patch].Add(patchConflict);
}
else
{
conflictMap.Add(patch, new List <PatchRangeConflict> {
patchConflict
});
}
if (conflictMap.ContainsKey(conflictPatch))
{
conflictMap[conflictPatch].Add(reversePatchConflict);
}
else
{
conflictMap.Add(conflictPatch, new List <PatchRangeConflict> {
reversePatchConflict
});
}
}
}
}
}
if (conflictMap.ContainsKey(patch))
{
resultPatchList.Add(patch);
}
}
return(new ConflictCheckResult(resultPatchList, conflictMap));
}
public void MoveBlocks(ASMEncoding.ASMEncodingUtility utility, IEnumerable <MovePatchRange> movePatchRanges)
{
/*
* Dictionary<PatchRange, bool> isSequentialAdd = new Dictionary<PatchRange, bool>();
* foreach (KeyValuePair<PatchRange, uint> blockMove in blockMoves)
* {
* isSequentialAdd[blockMove.Key] = false;
* }
*/
List <ASMEncoding.Helpers.BlockMove> blockMoves = new List <ASMEncoding.Helpers.BlockMove>();
foreach (MovePatchRange patchRange in movePatchRanges)
{
//PatchRange patchRange = movePair.Key;
//uint fileToRamOffset = PatcherLib.Iso.PsxIso.GetRamOffset(patchRange.Sector, true);
FreeSpaceMode mode = FreeSpace.GetMode(utility);
Type sectorType = (mode == FreeSpaceMode.PSP) ? typeof(PatcherLib.Iso.PspIso.Sectors) : typeof(PatcherLib.Iso.PsxIso.Sectors);
Enum sector = (Enum)Enum.ToObject(sectorType, patchRange.Sector);
uint fileToRamOffset = (mode == FreeSpaceMode.PSP)
? PatcherLib.Iso.PspIso.GetRamOffsetUnsigned((PatcherLib.Iso.PspIso.Sectors)sector)
: PatcherLib.Iso.PsxIso.GetRamOffset((PatcherLib.Iso.PsxIso.Sectors)sector, true);
ASMEncoding.Helpers.BlockMove blockMove = new ASMEncoding.Helpers.BlockMove();
blockMove.Location = (uint)patchRange.StartOffset + fileToRamOffset;
blockMove.EndLocation = (uint)patchRange.EndOffset + fileToRamOffset;
blockMove.Offset = patchRange.MoveOffset;
blockMoves.Add(blockMove);
}
List <PatchedByteArray> allPatchList = GetAllPatches();
//foreach (PatchedByteArray patchedByteArray in innerList)
foreach (PatchedByteArray patchedByteArray in allPatchList)
{
if (patchedByteArray is InputFilePatch)
{
continue;
}
byte[] bytes = patchedByteArray.GetBytes();
foreach (MovePatchRange patchRange in movePatchRanges)
{
//PatchRange patchRange = movePair.Key;
//uint offset = movePair.Value;
//if ((patchedByteArray.RamOffset == blockMove.Location) && ((patchedByteArray.RamOffset + bytes.Length) == blockMove.EndLocation))
//if (patchedByteArray.RamOffset == blockMove.Location)
//PatchRange patchRange = new PatchRange(patchedByteArray);
//PatchRange patchRange2 = new PatchRange(
//if (
//if (blockMove.Key
if (patchRange.HasOverlap(patchedByteArray))
{
patchedByteArray.Offset += patchRange.MoveOffset; // offset;
patchedByteArray.RamOffset += patchRange.MoveOffset; // offset;
//isSequentialAdd[patchRange] = true;
}
/*
* else if ((isSequentialAdd[patchRange]) && (patchedByteArray.IsSequentialOffset))
* {
* patchedByteArray.Offset += offset;
* patchedByteArray.RamOffset += offset;
* //patchRange.EndOffset += (uint)bytes.Length;
* }
* else
* {
* isSequentialAdd[patchRange] = false;
* }
*/
}
if ((patchedByteArray.IsCheckedAsm) && (!patchedByteArray.IsMoveSimple))
{
byte[] newBytes = utility.UpdateBlockReferences(bytes, (uint)patchedByteArray.RamOffset, true, blockMoves);
patchedByteArray.SetBytes(newBytes);
}
}
foreach (ASMEncoding.Helpers.BlockMove blockMove in blockMoves)
{
bool isAlreadyPresent = false;
foreach (ASMEncoding.Helpers.BlockMove listBlockMove in blockMoveList)
{
if (blockMove.IsEqual(listBlockMove))
{
isAlreadyPresent = true;
break;
}
}
if (!isAlreadyPresent)
{
blockMoveList.Add(blockMove);
}
}
}
public static ConflictResolveResult ResolveConflicts(IList <AsmPatch> patchList, ASMEncoding.ASMEncodingUtility asmUtility, int maxConflictResolveAttempts = MaxConflictResolveAttempts)
{
List <AsmPatch> resultPatchList = new List <AsmPatch>();
Dictionary <AsmPatch, int> patchIndexMap = new Dictionary <AsmPatch, int>();
StringBuilder sbMessage = new StringBuilder();
bool hasConflicts = false;
for (int index = 0; index < patchList.Count; index++)
{
resultPatchList.Add(patchList[index]);
patchIndexMap.Add(patchList[index], index);
}
Context context = (asmUtility.EncodingMode == ASMEncoding.ASMEncodingMode.PSP) ? Context.US_PSP : Context.US_PSX;
FreeSpaceMode mode = FreeSpace.GetMode(context);
FreeSpaceMaps freeSpaceMaps = FreeSpace.GetFreeSpaceMaps(resultPatchList, mode);
foreach (PatchRange freeSpaceRange in freeSpaceMaps.PatchRangeMap.Keys)
{
List <PatchedByteArray> innerPatches = freeSpaceMaps.PatchRangeMap[freeSpaceRange];
FreeSpaceAnalyzeResult analyzeResult = FreeSpace.Analyze(innerPatches, freeSpaceRange, true);
int conflictResolveAttempts = 0;
/*
* Type sectorType = ISOHelper.GetSectorType(context);
* Enum sector = (Enum)Enum.ToObject(sectorType, freeSpaceRange.Sector);
* string strSector = (mode == FreeSpaceMode.PSP) ? PspIso.GetSectorName((PspIso.Sectors)sector) : PsxIso.GetSectorName((PsxIso.Sectors)sector);
*/
string strSector = ISOHelper.GetSectorName(freeSpaceRange.Sector, context);
while ((analyzeResult.HasConflicts) && (conflictResolveAttempts < maxConflictResolveAttempts))
{
bool isStatic = false;
bool stayStatic = false;
int endIndex = innerPatches.Count - 1;
for (int index = 0; index < endIndex; index++)
{
PatchedByteArray innerPatch = innerPatches[index];
isStatic = innerPatch.IsStatic || stayStatic;
stayStatic = (innerPatch.IsStatic) && (innerPatch.IsPatchEqual(innerPatches[index + 1]));
if ((analyzeResult.ConflictIndexes.Contains(index)) && (!isStatic))
{
long moveOffset = analyzeResult.LargestGapOffset - innerPatch.Offset;
MovePatchRange movePatchRange = new MovePatchRange(new PatchRange(innerPatch), moveOffset);
AsmPatch asmPatch = freeSpaceMaps.InnerPatchMap[innerPatch];
int resultPatchIndex = patchIndexMap[asmPatch];
patchIndexMap.Remove(asmPatch);
asmPatch = asmPatch.Copy();
resultPatchList[resultPatchIndex] = asmPatch;
patchIndexMap.Add(asmPatch, resultPatchIndex);
asmPatch.MoveBlock(asmUtility, movePatchRange);
asmPatch.Update(asmUtility);
sbMessage.AppendLine("Conflict resolved by moving segment of patch \"" + asmPatch.Name + "\" in sector " + strSector + " from offset "
+ innerPatch.Offset.ToString("X") + " to " + analyzeResult.LargestGapOffset.ToString("X") + ".");
freeSpaceMaps = FreeSpace.GetFreeSpaceMaps(resultPatchList, mode);
innerPatches = freeSpaceMaps.PatchRangeMap[freeSpaceRange];
analyzeResult = FreeSpace.Analyze(innerPatches, freeSpaceRange, false);
conflictResolveAttempts++;
break;
}
}
}
if (analyzeResult.HasConflicts)
{
hasConflicts = true;
int endIndex = innerPatches.Count - 1;
for (int index = 0; index < endIndex; index++)
{
if (analyzeResult.ConflictIndexes.Contains(index))
{
sbMessage.Length = 0;
sbMessage.AppendLine("Conflict in sector " + strSector + " at offset " + innerPatches[index].Offset.ToString("X") + "!");
break;
}
}
}
}
return(new ConflictResolveResult(resultPatchList, hasConflicts, sbMessage.ToString()));
}
public static string[] GetRangeNames(FreeSpaceMode mode)
{
return(RangeNames[(int)mode]);
}
public static PatchRange[] GetRanges(FreeSpaceMode mode)
{
return(Ranges[(int)mode]);
}
private void InitFiles(FreeSpaceMode mode)
{
this.Filelistbox.Items.Clear();
this.Filelistbox.Items.AddRange(FreeSpace.GetRangeNames(mode));
}
