Exemplo n.º 1
0
 public void Assemble(int offset)
 {
     Bits.SetShort(rom, offset++, destination);
     Bits.SetBit(rom, offset, 3, showMessage);
     if (exitType == 0)
     {
         Bits.SetBit(rom, offset, 5, true);
     }
     else if (exitType == 1)
     {
         Bits.SetBit(rom, offset, 6, true);
     }
     Bits.SetBit(rom, offset++, 7, width > 0);
     rom[offset] = x;
     Bits.SetBit(rom, offset++, 7, x_half);
     rom[offset] = y;
     Bits.SetBit(rom, offset++, 7, y_half);
     rom[offset] = z;
     Bits.SetBitsByByte(rom, offset++, (byte)(height << 5), true);
     if (exitType == 0)
     {
         rom[offset] = dstX;
         Bits.SetBit(rom, offset++, 7, dstXb7);
         rom[offset] = dstY;
         Bits.SetBit(rom, offset++, 7, dstYb7);
         rom[offset] = dstZ;
         Bits.SetBitsByByte(rom, offset++, (byte)(dstFace << 5), true);
     }
     if (width > 0)
     {
         rom[offset] = width;
         Bits.SetBitsByByte(rom, offset++, (byte)(f << 7), true);
     }
 }
Exemplo n.º 2
0
        public void Assemble()
        {
            int offset = (index * 0x1A) + 0x39C000;

            Bits.SetBit(rom, offset, 7, use[0]);
            Bits.SetBit(rom, offset, 6, use[1]);
            Bits.SetBit(rom, offset, 5, use[2]);
            Bits.SetBit(rom, offset, 4, use[3]);
            Bits.SetBit(rom, offset, 3, use[4]);
            Bits.SetBit(rom, offset, 2, use[5]);
            Bits.SetBit(rom, offset, 1, use[6]);
            Bits.SetBit(rom, offset++, 0, use[7]);
            //
            Bits.SetBit(rom, offset, 7, hide[0]);
            Bits.SetBit(rom, offset, 6, hide[1]);
            Bits.SetBit(rom, offset, 5, hide[2]);
            Bits.SetBit(rom, offset, 4, hide[3]);
            Bits.SetBit(rom, offset, 3, hide[4]);
            Bits.SetBit(rom, offset, 2, hide[5]);
            Bits.SetBit(rom, offset, 1, hide[6]);
            Bits.SetBit(rom, offset++, 0, hide[7]);
            //
            for (int i = 0; i < 8; i++)
            {
                rom[offset++] = monsters[i];
                rom[offset++] = x[i];
                rom[offset++] = y[i];
            }
            //
            offset        = (index * 3) + 0x392AAA;
            rom[offset++] = unknown;
            if (battleEvent == 102)
            {
                rom[offset++] = 0xff;
            }
            else
            {
                rom[offset++] = battleEvent;
            }
            if (music == 8)
            {
                rom[offset] = 0xC0;
            }
            else
            {
                rom[offset] = (byte)(music << 2);
            }
            Bits.SetBitsByByte(rom, offset++, 0x03, cantRun);
        }
Exemplo n.º 3
0
 public void Assemble(byte[] data, int offset)
 {
     Bits.SetShort(data, offset, runEvent); offset++;
     Bits.SetBit(data, offset, 7, width > 0); offset++;
     data[offset] = x;
     Bits.SetBit(data, offset, 7, x_half); offset++;
     data[offset] = y;
     Bits.SetBit(data, offset, 7, y_half); offset++;
     data[offset] = z;
     Bits.SetBitsByByte(data, offset, (byte)(height << 5), true); offset++;
     if (width > 0)
     {
         data[offset] = width;
         Bits.SetBitsByByte(data, offset, (byte)(f << 7), true); offset++;
     }
 }
Exemplo n.º 4
0
 public void Assemble(ref int offset, int engageType)
 {
     rom[offset] = propertyA;
     if (engageType == 0)
     {
         Bits.SetBitsByByte(rom, offset, (byte)(propertyB << 5), true);
     }
     else if (engageType == 2)
     {
         Bits.SetBitsByByte(rom, offset, (byte)(propertyB << 4), true);
     }
     if (engageType == 0)
     {
         Bits.SetBitsByByte(rom, offset, (byte)(propertyC << 3), true);
     }
     offset++;
     //
     rom[offset] = x;
     Bits.SetBit(rom, offset, 7, xb7); offset++;
     rom[offset] = y;
     Bits.SetBit(rom, offset, 7, yb7); offset++;
     rom[offset] = z;
     Bits.SetBitsByByte(rom, offset, (byte)(f << 5), true); offset++;
 }
Exemplo n.º 5
0
 public void Assemble(ref int offset)
 {
     rom[offset] = cloneAmount;
     Bits.SetBitsByByte(rom, offset++, (byte)(engageType << 4), true);
     //
     rom[offset] = speedPlus;
     Bits.SetBit(rom, offset, 3, b2b3);
     Bits.SetBit(rom, offset, 4, b2b4);
     Bits.SetBit(rom, offset, 5, b2b5);
     Bits.SetBit(rom, offset, 6, b2b6);
     Bits.SetBit(rom, offset++, 7, b2b7);
     //
     Bits.SetBit(rom, offset, 0, b3b0);
     Bits.SetBit(rom, offset, 1, b3b1);
     Bits.SetBit(rom, offset, 2, b3b2);
     Bits.SetBit(rom, offset, 3, b3b3);
     Bits.SetBit(rom, offset, 4, b3b4);
     Bits.SetBit(rom, offset, 5, b3b5);
     Bits.SetBit(rom, offset, 6, b3b6);
     Bits.SetBit(rom, offset++, 7, b3b7);
     //
     Bits.SetShort(rom, offset, (ushort)(npcID << 2));
     Bits.SetBit(rom, offset, 0, b4b0);
     Bits.SetBit(rom, offset++, 1, b4b1);
     //
     Bits.SetBitsByByte(rom, offset++, (byte)((movement << 4) & 0xF0), true); // lower 4 bits
     rom[offset] = (byte)(movement >> 4);                                     // lower 6 bits
     Bits.SetBit(rom, offset, 6, b7b6);
     Bits.SetBit(rom, offset++, 7, b7b7);
     //
     if (engageType == 2) // if pack (1 byte)
     {
         rom[offset] = (byte)eventORpack;
     }
     else //if event (1 short)
     {
         Bits.SetShort(rom, offset, eventORpack);
     }
     offset++;
     //
     rom[offset] &= 0x0F;
     rom[offset] |= (byte)(engageTrigger << 4);
     if (engageType == 2)
     {
         rom[offset] &= 0xF0;
         rom[offset] |= (byte)(afterBattle << 1);
     }
     offset++;
     //
     rom[offset] = propertyA;
     if (engageType == 0)
     {
         Bits.SetBitsByByte(rom, offset, (byte)(propertyB << 5), true);
     }
     else if (engageType == 2)
     {
         Bits.SetBitsByByte(rom, offset, (byte)(propertyB << 4), true);
     }
     if (engageType == 0)
     {
         Bits.SetBitsByByte(rom, offset, (byte)(propertyC << 3), true);
     }
     offset++;
     //
     rom[offset] = x;
     Bits.SetBit(rom, offset++, 7, xb7);
     rom[offset] = y;
     Bits.SetBit(rom, offset++, 7, yb7);
     rom[offset] = z;
     Bits.SetBitsByByte(rom, offset++, (byte)(f << 5), true);
     //
     for (int i = 0; i < cloneAmount; i++)
     {
         this.CurrentClone = i;
         clone.Assemble(ref offset, engageType);
     }
 }
Exemplo n.º 6
0
        public void Assemble()
        {
            int offset = 0;

            offset      = (index * 18) + 0x1D0040; offset++;
            rom[offset] = messageBox != 0 ? (byte)((messageBox - 1) << 1) : (byte)0xFE;
            offset++;
            rom[offset] = maskLowX;
            Bits.SetBit(rom, offset, 7, maskLock); offset++;
            rom[offset] = maskLowY; offset++;
            rom[offset] = maskHighX; offset++;
            rom[offset] = maskHighY; offset++;
            rom[offset] = xNegL2; offset++;
            rom[offset] = yNegL2; offset++;
            rom[offset] = xNegL3; offset++;
            rom[offset] = yNegL3;
            Bits.SetBit(rom, offset, 7, infiniteScrolling); offset++;
            Bits.SetBit(rom, offset, 0, scrollWrapL1_HZ);
            Bits.SetBit(rom, offset, 1, scrollWrapL1_VT);
            Bits.SetBit(rom, offset, 2, culexA);
            Bits.SetBit(rom, offset, 3, scrollWrapL2_HZ);
            Bits.SetBit(rom, offset, 4, scrollWrapL2_VT);
            Bits.SetBit(rom, offset, 5, culexB);
            Bits.SetBit(rom, offset, 6, scrollWrapL3_HZ);
            Bits.SetBit(rom, offset, 7, scrollWrapL3_VT);
            offset++;
            rom[offset] = 0;
            switch (syncL2_HZ)
            {
            case 0: Bits.SetBitsByByte(rom, offset, 0x03, false); break;

            case 1: Bits.SetBitsByByte(rom, offset, 0x02, true); break;

            case 2: Bits.SetBitsByByte(rom, offset, 0x03, true); break;

            case 3: Bits.SetBitsByByte(rom, offset, 0x01, true); break;
            }
            switch (syncL2_VT)
            {
            case 0: Bits.SetBitsByByte(rom, offset, 0x0C, false); break;

            case 1: Bits.SetBitsByByte(rom, offset, 0x08, true); break;

            case 2: Bits.SetBitsByByte(rom, offset, 0x0C, true); break;

            case 3: Bits.SetBitsByByte(rom, offset, 0x04, true); break;
            }
            switch (syncL3_HZ)
            {
            case 0: Bits.SetBitsByByte(rom, offset, 0x30, false); break;

            case 1: Bits.SetBitsByByte(rom, offset, 0x20, true); break;

            case 2: Bits.SetBitsByByte(rom, offset, 0x30, true); break;

            case 3: Bits.SetBitsByByte(rom, offset, 0x10, true); break;
            }
            switch (syncL3_VT)
            {
            case 0: Bits.SetBitsByByte(rom, offset, 0xC0, false); break;

            case 1: Bits.SetBitsByByte(rom, offset, 0x80, true); break;

            case 2: Bits.SetBitsByByte(rom, offset, 0xC0, true); break;

            case 3: Bits.SetBitsByByte(rom, offset, 0x40, true); break;
            }
            offset++;
            switch (scrollDirectionL2)
            {
            case 0: rom[offset] = 0x00; break;

            case 1: rom[offset] = 0x08; break;

            case 2: rom[offset] = 0x10; break;

            case 3: rom[offset] = 0x18; break;

            case 4: rom[offset] = 0x20; break;

            case 5: rom[offset] = 0x28; break;

            case 6: rom[offset] = 0x30; break;

            case 7: rom[offset] = 0x38; break;
            }
            switch (scrollSpeedL2)
            {
            case 0: Bits.SetBitsByByte(rom, offset, 0x00, true); break;

            case 4: Bits.SetBitsByByte(rom, offset, 0x01, true); break;

            case 2: Bits.SetBitsByByte(rom, offset, 0x02, true); break;

            case 1: Bits.SetBitsByByte(rom, offset, 0x03, true); break;

            case 3: Bits.SetBitsByByte(rom, offset, 0x04, true); break;

            case 5: Bits.SetBitsByByte(rom, offset, 0x05, true); break;

            case 6: Bits.SetBitsByByte(rom, offset, 0x07, true); break;
            }
            Bits.SetBit(rom, offset, 7, scrollL2Bit7);
            offset++;
            switch (scrollDirectionL3)
            {
            case 0: rom[offset] = 0x00; break;

            case 1: rom[offset] = 0x08; break;

            case 2: rom[offset] = 0x10; break;

            case 3: rom[offset] = 0x18; break;

            case 4: rom[offset] = 0x20; break;

            case 5: rom[offset] = 0x28; break;

            case 6: rom[offset] = 0x30; break;

            case 7: rom[offset] = 0x38; break;
            }
            switch (scrollSpeedL3)
            {
            case 0: Bits.SetBitsByByte(rom, offset, 0x00, true); break;

            case 4: Bits.SetBitsByByte(rom, offset, 0x01, true); break;

            case 2: Bits.SetBitsByByte(rom, offset, 0x02, true); break;

            case 1: Bits.SetBitsByByte(rom, offset, 0x03, true); break;

            case 3: Bits.SetBitsByByte(rom, offset, 0x04, true); break;

            case 5: Bits.SetBitsByByte(rom, offset, 0x05, true); break;

            case 6: Bits.SetBitsByByte(rom, offset, 0x07, true); break;
            }
            Bits.SetBit(rom, offset, 7, scrollL3Bit7);
            offset++;
            rom[offset] = 0;
            Bits.SetBit(rom, offset, 4, ripplingWater);
            Bits.SetBitsByByte(rom, offset, prioritySet, true);
            offset++;
            switch (effectsL3)
            {
            case 0: rom[offset] = 0x00; break;

            case 1: rom[offset] = 0x01; break;

            case 2: rom[offset] = 0x02; break;

            case 3: rom[offset] = 0x03; break;

            case 4: rom[offset] = 0x05; break;

            case 5: rom[offset] = 0x06; break;

            case 6: rom[offset] = 0x07; break;

            case 7: rom[offset] = 0x08; break;

            case 8: rom[offset] = 0x09; break;

            case 9: rom[offset] = 0x0A; break;

            case 10: rom[offset] = 0x0B; break;

            case 11: rom[offset] = 0x0C; break;

            case 12: rom[offset] = 0x0D; break;

            case 13: rom[offset] = 0x0E; break;

            case 14: rom[offset] = 0x0F; break;

            case 15: rom[offset] = 0x10; break;

            case 16: rom[offset] = 0x11; break;

            case 17: rom[offset] = 0x12; break;

            case 18: rom[offset] = 0x14; break;

            case 19: rom[offset] = 0x15; break;

            case 20: rom[offset] = 0x16; break;

            case 21: rom[offset] = 0x17; break;

            case 22: rom[offset] = 0x18; break;
            }
            offset++;
            switch (effectsNPC)
            {
            case 0: rom[offset] = 0x00; break;

            case 1: rom[offset] = 0x05; break;

            case 2: rom[offset] = 0x06; break;

            case 3: rom[offset] = 0x07; break;

            case 4: rom[offset] = 0x0A; break;

            case 5: rom[offset] = 0x0B; break;

            case 6: rom[offset] = 0x0C; break;

            case 7: rom[offset] = 0x0D; break;

            case 8: rom[offset] = 0x0F; break;

            case 9: rom[offset] = 0x10; break;

            case 10: rom[offset] = 0x12; break;

            case 11: rom[offset] = 0x13; break;

            case 12: rom[offset] = 0x15; break;

            case 13: rom[offset] = 0x16; break;

            case 14: rom[offset] = 0x17; break;

            case 15: rom[offset] = 0x18; break;

            case 16: rom[offset] = 0x19; break;

            case 17: rom[offset] = 0x1A; break;

            case 18: rom[offset] = 0x1B; break;

            case 19: rom[offset] = 0x1D; break;

            case 20: rom[offset] = 0x1E; break;

            case 21: rom[offset] = 0x1F; break;

            case 22: rom[offset] = 0x20; break;

            case 23: rom[offset] = 0x21; break;

            case 24: rom[offset] = 0x22; break;
            }
        }