コード例 #1
0
 public void movePointers(int newAddress)
 {
     if (!isConnPatched)
     {
         if (ROM.IsEmpty(newAddress, size))
         {
             if (AddressLoROM.PcToSnes_Hi(newAddress) == AddressLoROM.PcToSnes_Bank(primaryPointer))
             {
                 ROM.Swap(secondaryPointer, newAddress, size);
                 byte[] b = new byte[]
                 {
                     (byte)(AddressLoROM.PcToSnes_Lo(newAddress)),
                     (byte)(AddressLoROM.PcToSnes_Hi(newAddress + 1)),
                 };
                 ROM.Write(primaryPointer, b.Length, b);
                 updatePointers();
             }
             else
             {
                 throw new Exception("Address must be within the bank.");
             }
         }
         else
         {
             throw new Exception(TextAndTranslationManager.GetString(Dungeon.moveError));
         }
     }
     else
     {
         throw new NotImplementedException();
     }
 }
コード例 #2
0
 public static byte[] GeneratePointer2(int address)
 {
     return(new byte[]
     {
         (byte)AddressLoROM.PcToSnes_Lo(address),
         (byte)AddressLoROM.PcToSnes_Hi(address),
     });
 }
コード例 #3
0
    public void writeAllSprites(SortedList <ushort, List <i_sprite> > allSprites)
    {
        int[]     pointers = new int[roomPointers.Length];
        const int blah     = 2; //inspired by HM source code

        int lowestPointer = int.MaxValue;

        foreach (int i in roomPointers)
        {
            lowestPointer = Math.Min(lowestPointer, i);
        }

        List <byte> data = new List <byte>();

        for (ushort i = 0; i < roomPointers.Length; i++)
        {
            if (!allSprites.ContainsKey(i))
            {
                allSprites.Add(i, new List <i_sprite>());
            }
        }

        foreach (ushort i in allSprites.Keys)
        {
            if (allSprites[i].Count == 0)
            {
                pointers[i] = lowestPointer + sizeOfData - blah;
            }
            else
            {
                List <byte> data2 = new List <byte>();

                byte byteSortByte = 0x0;
                bool first        = true;
                foreach (i_sprite s in allSprites[i])
                {
                    byte[] b = null;
                    if (first)
                    {
                        b     = s.getBytes(out byteSortByte);
                        first = false;
                        data2.Add(byteSortByte);
                    }
                    else
                    {
                        b = s.getBytes(out byte temp);

                        if (temp != byteSortByte)
                        {
                            throw new Exception();
                        }
                    }

                    data2 = data2.Concat(b).ToList();
                }
                data2.Add(sprite_delim);

                pointers[i] = lowestPointer + data.Count;
                data        = data.Concat(data2).ToList();
            }
        }

        if (data.Count > sizeOfData - blah)
        {
            throw new Exception();
        }

        while (data.Count < sizeOfData - blah)
        {
            data.Add(sprite_delim);
        }

        data.Add(0xAA);
        data.Add(sprite_delim);

        List <byte> pointerData = new List <byte>();

        foreach (int address in pointers)
        {
            byte[] d = new byte[]
            {
                (byte)AddressLoROM.PcToSnes_Lo(address),
                (byte)AddressLoROM.PcToSnes_Hi(address)
            };

            pointerData = pointerData.Concat(d).ToList();
        }

        ROM.Write(secondaryPointer, size, pointerData.ToArray());
        ROM.Write(lowestPointer, sizeOfData, data.ToArray());
        updatePointers();
    }