/**
  nescoundrel.c: a NES port of the Scoundrel roguelike card game
  using the official ruleset only
  Created by Luxferre in 2026, released into public domain
*/

#include <nes.h>
#include <joystick.h>
#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/* Constants section */

#define SCREEN_WIDTH  32
#define SCREEN_HEIGHT 28
#define SCREEN_CENTER_X (SCREEN_WIDTH >> 1)
#define SCREEN_CENTER_Y (SCREEN_HEIGHT >> 1)

#define KEY_UP 1
#define KEY_DN 2
#define KEY_LT 3
#define KEY_RT 4
#define KEY_A  5
#define KEY_B  6
#define KEY_SL 7
#define KEY_ST 8

#define GAME_WHITE 0
#define GAME_RED 1
#define GAME_YELLOW 2
#define GAME_GREEN 3

/* Graphics section */

void ppu_off() {
  PPU.mask &= 0xE7;
}

void ppu_on() {
  waitvsync();
  PPU.scroll = 0;
  PPU.mask |= 0x1A;
}

int joy_input_wait() {
  unsigned char last_joy = 0, joy, pressed;
  /* wait until the previous key is released */
  while(joy_read(JOY_1));
  /* wait for a new press */
  while(1) {
    joy = joy_read(JOY_1);
    pressed = joy & ~last_joy;
    if(pressed & JOY_UP_MASK) return KEY_UP;
    if(pressed & JOY_DOWN_MASK) return KEY_DN;
    if(pressed & JOY_LEFT_MASK) return KEY_LT;
    if(pressed & JOY_RIGHT_MASK) return KEY_RT;
    if(pressed & JOY_BTN_1_MASK) return KEY_A;
    if(pressed & JOY_BTN_2_MASK) return KEY_B;
    if(pressed & JOY_BTN_3_MASK) return KEY_SL;
    if(pressed & JOY_BTN_4_MASK) return KEY_ST;
    last_joy = joy;
    waitvsync();
  }
}

/* palette loader */
void init_palette() {
  unsigned char i;
  const unsigned char my_palette[16] = {
    0x0f, 0, 0, 0x30, /* white */
    0x0f, 0, 0, 0x15, /* red */
    0x0f, 0, 0, 0x28, /* yellow */
    0x0f, 0, 0, 0x2A  /* green */
  };
  PPU.vram.address = 0x3F;
  PPU.vram.address = 0;
  for(i=0; i<16; i++) PPU.vram.data = my_palette[i];
}

/* 4x4 char block colorization method (palette is 0 to 3) */
void colorxy(unsigned char x, unsigned char y, unsigned char palette) {
  unsigned int addr;
  unsigned char attr_byte;
  addr = 0x23C0 + ((y >> 2) << 3) + (x >> 2);
  attr_byte = palette | (palette << 2) | (palette << 4) | (palette << 6);
  waitvsync();
  PPU.vram.address = (unsigned char) (addr >> 8);
  PPU.vram.address = (unsigned char) (addr & 255);
  PPU.vram.data = attr_byte;
}

/* Sound section */

#define CPU 1789773 /* NTSC */

unsigned int get_timer(int freq) {
  return (unsigned int) ((CPU / 16 / freq) - 1);
}

void play_pulse(unsigned char idx, unsigned int freq, unsigned char len) {
  unsigned int tm = get_timer(freq);
  if(len > 31) len = 31;
  if(idx > 1) idx = 0;
  APU.pulse[idx].period_low = tm & 255;
  APU.pulse[idx].len_period_high = (tm >> 8) | (len << 3);
}

void play_jingle(unsigned int n1f1,
  unsigned int n1f2,
  unsigned int n2f1,
  unsigned int n2f2,
  unsigned int n3f1,
  unsigned int n3f2) {
  unsigned int i, dl = 2000;
  play_pulse(0, n1f1, 2);
  play_pulse(1, n1f2, 2);
  for(i=0;i<dl;++i);
  play_pulse(0, n2f1, 2);
  play_pulse(1, n2f2, 2);
  for(i=0;i<dl;++i);
  play_pulse(0, n3f1, 2);
  play_pulse(1, n3f2, 2);
}

void init_sound() {
  APU.status = 3;
  APU.pulse[0].ramp = 0x8;
  APU.pulse[1].ramp = 0x8;
  APU.pulse[0].control = 0x9F;
  APU.pulse[1].control = 0x9F;
  waitvsync();
}

void beep_start() {
  play_jingle(220, 440, 440, 660, 660, 880);
}
void beep_interact() {
  play_jingle(440, 660, 220, 880, 440, 660);
}
void beep_enemy() {
  play_jingle(440, 220, 220, 110, 110, 55);
}
void beep_weapon() {
  play_jingle(660, 990, 440, 880, 660, 990);
}
void beep_potion() {
  play_jingle(440, 660, 660, 990, 660, 880);
}
void beep_run() {
  play_jingle(660, 880, 440, 660, 220, 440);
}
void beep_win() {
  unsigned short i;
  play_jingle(55, 110, 110, 220, 220, 440);
  for(i=0;i<4000;++i);
  play_jingle(440, 660, 660, 880, 880, 1760);
  for(i=0;i<4000;++i);
  play_jingle(880, 660, 660, 880, 880, 1760);
}
void beep_lose() {
  unsigned short i;
  play_jingle(110, 55, 220, 110, 110, 55);
  for(i=0;i<4000;++i);
  play_jingle(110, 55, 110, 55, 110, 55);
}
void beep_err() {
  play_jingle(330, 220, 330, 220, 330, 220);
}

/* Main game logic */

void game_startup() {
  unsigned int entropy;
  unsigned char joy, i, j;
#ifdef _randomize
  _randomize();
#endif
  entropy = rand();
  init_sound();
  bgcolor(COLOR_BLACK);
  textcolor(0);
  init_palette();
  clrscr();
  ppu_off();
  for(j=0;j<24;j+=4)
    for(i=3;i<32;i+=4)
      colorxy(i, j, 1 + ((++entropy) % 3));
  gotoxy(0, 2);
  cputs( \
"    _______ _______ _______ \r\n"  \
"   |   _   |   _   |   _   |\r\n" \
"   |   1___|.  1___|.  |   |\r\n" \
"   |____   |.  |___|.  |   |\r\n" \
"   |:  1   |:  1   |:  1   |\r\n" \
"   |::.. . |::.. . |::.. . |\r\n" \
"   `-------`-------`-------'\r\n");
  cputs( \
"    ___ ___ ______  ______\r\n" \
"   |   Y   |   _  \\|   _  \\ \r\n" \
"   |.  |   |.  |   |.  |   \\ \r\n" \
"   |.  |   |.  |   |.  |    \\\r\n" \
"   |:  1   |:  |   |:  1    /\r\n" \
"   |::.. . |::.|   |::.. . / \r\n" \
"   `-------`--- ---`------'  \r\n");
  cputs( \
"    _______ _______ ___     \r\n" \
"   |   _   |   _   |   |    \r\n" \
"   |.  l   |.  1___|.  |    \r\n" \
"   |.  _   |.  __)_|.  |___ \r\n" \
"   |:  |   |:  1   |:  1   |\r\n" \
"   |::.|:. |::.. . |::.. . |\r\n" \
"   `--- ---`-------`-------'");
  cputsxy(SCREEN_CENTER_X - 6, SCREEN_HEIGHT - 4, "Press Start");
  cputsxy(1, SCREEN_HEIGHT - 2, "Luxferre");
  cputsxy(SCREEN_WIDTH-5, SCREEN_HEIGHT - 2, "2026");
  joy_install(joy_static_stddrv);
  ppu_on();
  while(1) {
    ++entropy;
    joy = joy_read(JOY_1);
    if(JOY_START(joy)) break;
    waitvsync();
  }
  srand(entropy);
  beep_start();
  clrscr();
}

/* Win screen display */
void win_screen(int score) {
  unsigned char i, j;
  clrscr();
  ppu_off();
  for(j=0;j<12;j+=4)
    for(i=3;i<32;i+=4)
      colorxy(i, j, 1 + (rand() % 3));
  cputsxy(0, 3, "      ___ ___ ___ ______  \r\n" \
"     |   Y   |   |   _  \\ \r\n" \
"     |.  |   |.  |.  |   |\r\n" \
"     |. / \\  |.  |.  |   |\r\n" \
"     |:      |:  |:  |   |\r\n" \
"     |::.|:. |::.|::.|   |\r\n" \
"     `--- ---`---`--- ---'");
  cputsxy(0, 12, "  Congratulations! You made it\r\n     through the dangerous\r\n        dungeon alive!\r\n\r\n");
  cprintf("        Your score: %d\r\n\r\n", score);
  chlinexy(0, 17, SCREEN_WIDTH);
  cputs("Created by Luxferre in 2026\r\nReleased into public domain\r\n");
  cputs("\r\nOriginal concept by Zach Gage\r\nand Kurt Bieg, 2011");
  chlinexy(0, 23, SCREEN_WIDTH);
  cputsxy(10, 25, "Press Start");
  ppu_on();
  waitvsync();
  beep_win();
  while(joy_input_wait() != KEY_ST);
}

/* UI choices */
#define CH1 0
#define CH2 1
#define CH3 2
#define CH4 3
#define CH_R 4
#define CH_Q 5
#define CH_INVAL 6

/**
Deck/room representation:
0 is empty (this value cannot be in the deck, only in the room),
1 to 13 is a monster,
14 to 22 is a weapon,
23 to 31 is a potion

Monster level: x + 1
Weapon level: x - 12
Potion level: x - 21
*/

/* Game stats */

/* main deck and room */
static char deck[44], room[] = {0, 0, 0, 0};

/* status message */
static char status_msg[(SCREEN_WIDTH-1)];

/* tracking variables */
static short deck_idx = 0, hp = 20, rooms_cleared = 0,
  weapon = 0, durability = 0, can_run = 1,
  engaged = 0, potion_drank = 0, last_potion_val = 0;

/* Input method */
/* up 1, left 2, right 3, down 4, a run, start quit */
char get_choice() {
  switch(joy_input_wait()) {
    case KEY_UP: return CH1;
    case KEY_LT: return CH2;
    case KEY_RT: return CH3;
    case KEY_DN: return CH4;
    case KEY_ST: return CH_Q;
    default: return CH_R;
  }
}

/* Draw a room character according to the index and value */
void render_room_item(short i, short v) {
  unsigned char color,
        topleft_x, topleft_y,
        topright_x, bottomleft_y,
        text_x, text_y, cheight=7, cwidth=8, left_offset = 9;
  if(i == 0) {
    topleft_x = 8;
    topleft_y = 0;
  } else if(i == 1) {
    topleft_x = 0;
    topleft_y = 8;
  } else if(i == 2) {
    topleft_x = 16;
    topleft_y = 8;
  } else if(i == 3) {
    topleft_x = 8;
    topleft_y = 16;
  }
  topright_x = topleft_x + cwidth - 1;
  bottomleft_y = topleft_y + cheight - 1;
  text_x = topleft_x + 1;
  text_y = topleft_y + 2;
  if(v == 0) {} /* don't render anything */
  else {
    if(v < 14) {
      color = GAME_RED;
    } else if(v < 23) {
      color = GAME_YELLOW;
    } else {
      color = GAME_GREEN;
    }
    colorxy(topleft_x, topleft_y, color);
    colorxy(topleft_x+4, topleft_y, color);
    colorxy(topleft_x, topleft_y+4, color);
    colorxy(topleft_x+4, topleft_y+4, color);
    /* draw the rectangle */
    chlinexy(topleft_x + 1, topleft_y, cwidth - 2);
    chlinexy(topleft_x + 1, bottomleft_y, cwidth - 2);
    cvlinexy(topleft_x, topleft_y + 1, cheight - 2);
    cvlinexy(topright_x, topleft_y + 1, cheight - 2);
    /* draw text */
    gotoxy(text_x, text_y);
    if(v < 14) {
      cputs("ENEMY ");
    } else if(v < 23) {
      cputs("WEAPON");
    } else {
      cputs("POTION"); 
    }
    gotoxy(text_x, text_y+2);
    if(v < 14) cprintf("LVL %02d", v + 1);
    else if(v < 23) cprintf("LVL %02d", v - 12);
    else cprintf("LVL %02d", v - 21); 
  }
}

/* Render main game screen */
void render_main_scene() {
  unsigned char i, deck_count = 0, statbase = 17,
    room_start_x = 1,
    room_start_y = 1,
    room_end_x = statbase - 8,
    room_end_y = SCREEN_HEIGHT - 4,
    room_mid_x = room_start_x + ((room_end_x - room_start_x)>>1) - 1,
    room_mid_y = room_start_y + ((room_end_y - room_start_y)>>1) - 1;
  for(i=0;i<sizeof(deck);i++)
    if(deck[i]) deck_count++;
  clrscr();
  ppu_off();
  /* render the frames */
  chlinexy(0,SCREEN_HEIGHT-1,SCREEN_WIDTH);
  chlinexy(0,SCREEN_HEIGHT-3,SCREEN_WIDTH);
  /* render the room */
  for(i=0;i<4;i++) render_room_item(i, room[i]);
  cputsxy(10, 10, "DECK");
  gotoxy(11, 12);
  cprintf("%02d", deck_count);
  cvlinexy(9, 10, 3);
  cvlinexy(14, 10, 3);
  chlinexy(10, 9, 4);
  chlinexy(10, 13, 4);
  /* render stats */
  gotoxy(statbase, 1);
  cprintf("Health      %02d", hp);
  gotoxy(statbase, 3);
  cprintf("Weapon      %02d", weapon);
  gotoxy(statbase, 5);
  cprintf("Durability  %02d", durability);
  cputsxy(statbase, 17, "Choose: D-Pad");
  cputsxy(statbase, 19, can_run ? "Run: A/B/SELECT" : "Cannot run!");
  gotoxy(statbase, 21);
  cprintf("Rooms clrd: %02d", rooms_cleared);
  /* render status message */
  gotoxy(1, SCREEN_HEIGHT-2);
  cprintf("%s", status_msg);
  ppu_on();
  waitvsync();
}

/* Confirmation method */
unsigned char confirm(char *prompt) {
  unsigned char res = 2, statbase = SCREEN_WIDTH - 7;
  snprintf(status_msg, sizeof(status_msg), "%s", prompt);
  render_main_scene();
  gotoxy(statbase, SCREEN_HEIGHT-5);
  cprintf("A=YES");
  gotoxy(statbase, SCREEN_HEIGHT-4);
  cprintf("B=NO");
  while(res > 1) {
    switch(joy_input_wait()) {
      case KEY_A: res = 1; break;
      case KEY_B: res = 0; break;
      default: res = 2;
    }
  }
  beep_interact();
  return res;
}

/* Output method */
void print_msg(char *s) {
  memset(status_msg, 0, sizeof(status_msg));
  strncpy(status_msg, s, sizeof(status_msg));
  render_main_scene();
}

/* Array shuffle method */
void shuffle(char *array, unsigned int n) {
  unsigned int i, j, t;
  if(n > 1) {
    for(i=n-1;i>0;i--) {
      j = (unsigned int) (rand()%(i+1));
      t = array[j];
      array[j] = array[i];
      array[i] = t;
    }
  }
}

/* Room item handling methods */

void handle_monster(int val) {
  int healthlost = val;
  char monster_msg[(SCREEN_WIDTH-1)];
  beep_enemy();
  if(weapon > 0 && val <= durability) {
    int weapondiff = val - weapon;
    if(weapondiff < 0) weapondiff = 0;
    snprintf(monster_msg, sizeof(status_msg), "%d-level monster: use weapon?", val);
    if(confirm(monster_msg)) {
      healthlost = weapondiff;
      durability = val - 1;
      if(durability < 2) {
        durability = weapon = 0;
      }
    }
  } else {
    snprintf(status_msg, sizeof(status_msg), "You fight a %d-level monster.", val);
  }
  hp -= healthlost;
  if(hp < 0) hp = 0;
  snprintf(status_msg, sizeof(status_msg), "You lost %d HP. New HP: %d", healthlost, hp);
}

void handle_weapon(int val) {
  weapon = val;
  snprintf(status_msg, sizeof(status_msg), "You equip a %d-level weapon.", weapon);
  durability = 14; /* reset durability to max limit */
  beep_weapon();
}

void handle_potion(unsigned char val) {
  if(potion_drank) {
    print_msg("Already drank a potion here.");
    beep_err();
  } else {
    potion_drank = 1;
    hp += val;
    if(hp > 20) hp = 20;
    snprintf(status_msg, sizeof(status_msg), "You drink a %d-level potion.", val);
    if(deck_idx >= sizeof(deck) || deck[deck_idx] == 0)
      last_potion_val = val;
    beep_potion();
  }
}

/* Main gameplay */
int game() {
  unsigned int i;
  int score = 0; /* score storage */
  int item, room_sum; /* true item value */
  int last_room = 0, last_room_clr = 0; /* last room markers */
  char ch;
  deck_idx = 0; /* reset the deck index */
  /* Prefill the deck */
  for(i=0;i<13;i++) deck[i] = deck[i+13] = i+1;
  for(i=26;i<44;i++) deck[i] = i - 12;
  /* Shuffle the deck */
  shuffle(deck, sizeof(deck));
  /* prepare all other parameters */
  hp = 20;
  can_run = 1;
  weapon = durability = engaged = rooms_cleared = 0;
  potion_drank = last_potion_val = 0;
  for(i=0;i<sizeof(room);i++) room[i] = 0; /* reset the room */
  print_msg("Good luck!"); /* reset the status message */

  while(hp > 0 && !last_room_clr) {
    /* fill in the new room unless engaged */
    if(!engaged) {
      for(i=0;i<sizeof(room);i++) {
        /* fill only if empty */
        if(!room[i]) {
          /* Check if deck is empty or exhausted */
          if(deck_idx >= sizeof(deck) || deck[deck_idx] == 0) {
            last_room = 1;
            can_run = 0;
          } else {
            room[i] = deck[deck_idx];
            deck[deck_idx] = 0; /* remove from deck */
            deck_idx++;
            /* Check immediately if that was the last card */
            if(deck_idx >= sizeof(deck) || deck[deck_idx] == 0) {
               last_room = 1;
               can_run = 0;
            }
          }
        }
      }
    }

    /* display the stats and room */
    render_main_scene();
    ch = get_choice();

    /* Logic validation */
    if(ch == CH_R) {
        if(!can_run || engaged) ch = CH_INVAL; /* Cannot run if disabled or engaged */
    } else if(ch < CH_R && !room[(int)ch]) {
        ch = CH_INVAL; /* empty item */
    }

    if(ch == CH_Q) {
      hp = 0;
      break;
    } else if(ch == CH_INVAL) {
      print_msg("Invalid input!");
      beep_err();
      continue;
    } else if(ch == CH_R) { /* run mechanics */
      /* Compact and rearrange the deck */
      char temp_deck[sizeof(deck)];
      int t_idx = 0;

      /* 1. Collect all valid remaining cards from deck */
      for(i=0; i<sizeof(deck); i++) {
        if(deck[i] != 0) temp_deck[t_idx++] = deck[i];
      }

      /* 2. Shuffle room cards and append to the end */
      shuffle(room, sizeof(room));
      for(i=0; i<sizeof(room); i++) {
        if(room[i] != 0) {
          temp_deck[t_idx++] = room[i];
          room[i] = 0; /* Clear room */
        }
      }

      /* 3. Rebuild deck */
      memset(deck, 0, sizeof(deck));
      for(i=0; i<t_idx; i++) deck[i] = temp_deck[i];

      /* 4. Reset state */
      deck_idx = 0; /* Reset index to start of compacted deck */
      can_run = 0; /* can't run twice in a row */
      engaged = 0;
      last_room = 0; /* Since we added cards, it's not the last room anymore */
      print_msg("You ran from the room.");
      beep_run();
    } else { /* engagement mechanics */
      engaged++; /* increase the amount of engaged cards */
      can_run = 0; /* Cannot run once engaged */

      item = room[(int)ch]; /* get the item from the room */
      room[(int)ch] = 0; /* mark the room slot as empty */
      /* Note: We do NOT put the item back in deck. It is consumed. */

      if(item < 14) { /* monster */
        handle_monster(item + 1);
      } else if(item < 23) { /* weapon */
        handle_weapon(item - 12);
      } else { /* potion */
        handle_potion(item - 21);
      }

      /* condition to move to the next room */
      room_sum = 0;
      for(i=0;i<sizeof(room);i++) room_sum += room[i];

      if(hp > 0) {
        if(room_sum == 0) {
          if(last_room) last_room_clr = 1;
          else {
            engaged = 0;
            potion_drank = 0;
            can_run = 1;
            rooms_cleared++;
          }
        } else if(!last_room && engaged == 3) {
          engaged = 0;
          potion_drank = 0;
          can_run = 1;
          rooms_cleared++;
        }
      }
    }
  }
  /* Score the result */
  if(hp > 0) { /* win */
    score = hp;
    if(hp == 20) score += last_potion_val;
  } else { /* fail */
    for(i=0;i<sizeof(room);i++)
      if(room[i] && room[i] < 14)
        score -= (room[i] + 1);
    for(i=0;i<sizeof(deck);i++)
      if(deck[i] && deck[i] < 14)
        score -= (deck[i] + 1);
  }
  return score;
}

/* Entry point */
int main() {
  int score;
  game_startup();
  while(1) {
    score = game();
    if(score > 0) {
      win_screen(score);
      break;
    } else {
      beep_lose();
      snprintf(status_msg, sizeof(status_msg), "RIP! Score: %d. Restart?", score);
      if(!confirm(status_msg)) break;
    }
  }
  return 0;
}