nesdev.com

unsigned char update_buffer [UPDATE_LIST_SIZE*3+1];
unsigned char *ul;

set_vram_update (update_buffer);
while (game_on) {
    ul = update_buffer; // Point to the beginning of the buffer
    ... do your game logic, write to ul, increment ul.
    *ul = NT_UPD_EOF;
    ppu_wait_frame ();
}
set_vram_update (0);
...

*ul ++ = MSB(NTADR_A(1,19))|NT_UPD_HORZ,LSB(NTADR_A(1,19));
*ul ++ = 3;
*ul ++ = 0x74;
*ul ++ = 0x63;
*ul ++ = 0x75;

/**
 * set_door(player, openclose)
 * player = Player 0 (blue) or Player 1 (yellow) door.
 * openclose = 0 for open, 1 for close.
 */
void set_door(unsigned char player, unsigned char openclose)
{
  // Clear the update buffer
  clear_update_buffer();

  // Set the addresses for the two rows of tiles that make up the door
  update_buffer[0]=(player==0?MSB(NTADR_A(1,18))|NT_UPD_HORZ:MSB(NTADR_A(28,18))|NT_UPD_HORZ);
  update_buffer[1]=(player==0?LSB(NTADR_A(1,18)):LSB(NTADR_A(28,18)));
  update_buffer[2]=3;

  update_buffer[6]=(player==0?MSB(NTADR_A(1,19))|NT_UPD_HORZ:MSB(NTADR_A(28,19))|NT_UPD_HORZ);
  update_buffer[7]=(player==0?LSB(NTADR_A(1,19)):LSB(NTADR_A(28,19)));
  update_buffer[8]=3;

  // And then set the tiles for each update depending on desired door state.
  if (openclose==0 && player==0)
    {
      update_buffer[3]=0x65;
      update_buffer[4]=0x00;
      update_buffer[5]=0x00;
      update_buffer[9]=0x65;
      update_buffer[10]=0x00;
      update_buffer[11]=0x00;
    }
  else if (openclose==1 && player==0)
    {
      update_buffer[3]=0x76;
      update_buffer[4]=0x64;
      update_buffer[5]=0x64;
      update_buffer[9]=0x74;
      update_buffer[10]=0x63;
      update_buffer[11]=0x63;
    }
  else if (openclose==0 && player==1)
    {
      update_buffer[3]=0x00;
      update_buffer[4]=0x00;
      update_buffer[5]=0x66;
      update_buffer[9]=0x00;
      update_buffer[10]=0x00;
      update_buffer[11]=0x66;
    }
  else if (openclose==1 && player==1)
    {
      update_buffer[3]=0x64;
      update_buffer[4]=0x64;
      update_buffer[5]=0x77;
      update_buffer[9]=0x63;
      update_buffer[10]=0x63;
      update_buffer[11]=0x75;
    }

}

/**
 * 8 objects on screen, two players and 6 enemies.
 *
 * [0] - Sprite X position
 * [1] - Sprite Y position
 * [2] - Sprite Type - (worrior, burwor, thurwor, gorwor... Bit 7 means empty.)
 * [3] - Dungeon X coordinate
 * [4] - Dungeon Y coordinate
 */

     // VRAM update scheduler

      a=frame_cnt&0x03;
      switch (a)
        {
        case 0:
          update_doors();
          break;
        case 1:
          update_scores();
          break;
        case 2:
          set_teleport(teleport_state);
          break;
        case 3:
          break;
        }

      // End VRAM update scheduler

#define STAMP_NUM_FIELDS     8                    // Number of fields in each stamp slot
#define STAMP_NUM_SLOTS      8                    // Number of slots in stamp structure
#define STAMP_CENTER_BIAS_X  12                   // Offset to apply to box multiply to center sprite (X)
#define STAMP_CENTER_BIAS_Y  10                   // Offset to apply to box multiply to center sprite (Y)
#define STAMP_NUM(x)         (x*STAMP_NUM_FIELDS) // Stamp Number
#define STAMP_X(x)           (STAMP_NUM(x)+0)     // Stamp Field: X pixel position
#define STAMP_Y(x)           (STAMP_NUM(x)+1)     // Stamp Field: Y pixel position
#define STAMP_TYPE(x)        (STAMP_NUM(x)+2)     // Stamp Field: Type
#define STAMP_STATE(x)       (STAMP_NUM(x)+3)     // Stamp Field: state (which frames to use).
#define STAMP_FRAME(x)       (STAMP_NUM(x)+4)     // Stamp Field: Current frame
#define STAMP_DELAY(x)       (STAMP_NUM(x)+5)     // Stamp Field: Delay
#define STAMP_FINE_X(x)      (STAMP_NUM(x)+6)     // Stamp Field: Fine X offset relative to box (not used, will be repurposed)
#define STAMP_FINE_Y(x)      (STAMP_NUM(x)+7)     // Stamp Field: Fine Y offset relative to box (not used, will be repurposed)

#define PIXEL_BOX_X(x)       ((x*24)+STAMP_CENTER_BIAS_X)             // Convert Box X coordinates to pixels
#define PIXEL_BOX_Y(x)       ((x*24)+STAMP_CENTER_BIAS_Y)             // Convert Box Y coordinates to pixels
#define BOX_PIXEL_X(x)       (div24(x-STAMP_CENTER_BIAS_X))           // Convert Stamp X coordinates to Box X
#define BOX_PIXEL_Y(y)       (div24(x-STAMP_CENTER_BIAS_Y))           // Convert Stamp Y coordinates to Box Y

/**
 * move_monsters()
 * Move the monsters
 */
void move_monsters()
{
  for (i=2;i<STAMP_NUM_SLOTS;++i)
    {
      // Get the box in a&b
      a=div24(stamps[STAMP_X(i)]-8);
      b=div24(stamps[STAMP_Y(i)]-8);
      c=(b*10)+a; // C is now the box #
      d=dungeon[c];

      if (stamps[STAMP_STATE(i)] == STATE_MONSTER_RIGHT)
        {
          if (d&1<<4)
            {
              if (stamps[STAMP_X(i)]==PIXEL_BOX_X(a))
                {
                  stamps[STAMP_STATE(i)]=rand8()&0x03;
                }
              else
                {
                  stamps[STAMP_X(i)]++;
                }
            }
          else
            {
              stamps[STAMP_X(i)]++;
            }
        }
      else if (stamps[STAMP_STATE(i)] == STATE_MONSTER_LEFT)
        {
          if (d&1<<6)
            {
              if (stamps[STAMP_X(i)]==PIXEL_BOX_X(a))
                {
                  stamps[STAMP_STATE(i)]=rand8()&0x03;
                }
              else
                {
                  stamps[STAMP_X(i)]--;
                }
            }
          else
            {
              stamps[STAMP_X(i)]--;
            }

        }
      else if (stamps[STAMP_STATE(i)] == STATE_MONSTER_UP)
        {
          if (d&1<<7)
            {
              if (stamps[STAMP_Y(i)]==PIXEL_BOX_Y(b))
                {
                  stamps[STAMP_STATE(i)]=rand8()&0x03;
                }
              else
                {
                  stamps[STAMP_Y(i)]--;
                }
            }
          else
            {
              stamps[STAMP_Y(i)]--;
            }
        }
      else if (stamps[STAMP_STATE(i)] == STATE_MONSTER_DOWN)
        {
          if (d&1<<5)
            {
              if (stamps[STAMP_Y(i)]==PIXEL_BOX_Y(b))
                {
                  stamps[STAMP_STATE(i)]=rand8()&0x03;
                }
              else
                {
                  stamps[STAMP_Y(i)]++;
                }
            }
          else
            {
              stamps[STAMP_Y(i)]++;
            }
        }
    }
}