#include <Arduino.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

/********* OLED *********/
#define SCREEN_WIDTH    128
#define SCREEN_HEIGHT   64
#define SCREEN_ADDRESS  0x3C
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1, 1700000UL, 1700000UL);

/********* Touch pins (official pinout) *********/
#define N_TOUCH 6
int touch_pins[N_TOUCH] = {3, 4, 2, 27, 1, 26};

/********* Touch timing *********/
const uint32_t SAFE_WINDOW_MS   = 2000;
volatile uint16_t T_MAX_US      = 500;
const uint16_t DISCHARGE_US     = 25;

/********* Game timing *********/
const uint32_t FRAME_MS         = 50;   // 20 FPS；如需更顺可改 40

/********* Physics (tuned) *********/
const float GRAVITY        = 1.05f;   // 更紧凑的抛物线
const float JUMP_IMPULSE   = -9.6f;   // 跳更高
const float MAX_FALL_SPEED = 11.0f;
const float AIR_DOWN_BOOST = 0.60f;

/********* Input mapping *********/
// CH2,3,4,5 = down,left,right,up ; CH0,1 = func right/left
#define CH_DOWN   2
#define CH_LEFT   3
#define CH_RIGHT  4
#define CH_UP     5
#define CH_FUNC_R 0
#define CH_FUNC_L 1

/********* Touch state *********/
uint16_t touch_us[N_TOUCH] = {0};
bool     pressed[N_TOUCH]  = {0};     // 非0即按下

static inline void usb_friendly_yield() { yield(); }
static inline uint16_t measure_touch_us(int pin) {
  pinMode(pin, OUTPUT);
  digitalWriteFast(pin, LOW);
  delayMicroseconds(DISCHARGE_US);
  pinMode(pin, INPUT_PULLUP);
  unsigned long t0 = micros();
  while (!digitalReadFast(pin)) {
    if ((uint16_t)(micros() - t0) >= T_MAX_US) break;
    usb_friendly_yield();
  }
  return (uint16_t)(micros() - t0);
}
void poll_touch() {
  for (int i=0;i<N_TOUCH;i++) {
    touch_us[i] = measure_touch_us(touch_pins[i]);
    pressed[i]  = (touch_us[i] != 0);
  }
}

/********* Game state *********/
enum GameState { GS_MENU, GS_PLAY, GS_PAUSE, GS_GAMEOVER };
GameState gstate = GS_MENU;

/********* Chrome-dino-like sprites (1-bit bitmaps) *********/
// 24x20 running frame A
const uint8_t PROGMEM DINO_RUN_A[] = {
  0x00,0xF0,0x00,
  0x01,0xF8,0x00,
  0x03,0xFC,0x00,
  0x07,0xFE,0x00,
  0x07,0x8E,0x00,
  0x07,0xFE,0x00,
  0x07,0xFE,0x00,
  0x03,0xFC,0x00,
  0x03,0xFC,0x00,
  0x03,0xFC,0x00,
  0x03,0xFC,0x00,
  0x03,0xFC,0x00,
  0x03,0xFC,0x00,
  0x03,0x9C,0x00,
  0x07,0x1E,0x00,
  0x06,0x0E,0x00,
  0x06,0x0E,0x00,
  0x0E,0x07,0x00,
  0x0F,0x07,0x00,
  0x06,0x06,0x00
};
// 24x20 running frame B
const uint8_t PROGMEM DINO_RUN_B[] = {
  0x00,0xF0,0x00,
  0x01,0xF8,0x00,
  0x03,0xFC,0x00,
  0x07,0xFE,0x00,
  0x07,0x8E,0x00,
  0x07,0xFE,0x00,
  0x07,0xFE,0x00,
  0x03,0xFC,0x00,
  0x03,0xFC,0x00,
  0x03,0xFC,0x00,
  0x03,0xFC,0x00,
  0x03,0xFC,0x00,
  0x03,0x9C,0x00,
  0x07,0x1E,0x00,
  0x06,0x0E,0x00,
  0x0E,0x07,0x00,
  0x0F,0x07,0x00,
  0x06,0x06,0x00,
  0x06,0x06,0x00,
  0x00,0x00,0x00
};
// 28x14 crouch frame
const uint8_t PROGMEM DINO_CROUCH[] = {
  0x03,0xF8,0x00,0x00,
  0x07,0xFC,0x00,0x00,
  0x0F,0xFE,0x00,0x00,
  0x0F,0x8E,0x00,0x00,
  0x0F,0xFE,0x00,0x00,
  0x0F,0xFE,0x00,0x00,
  0x07,0xFC,0x00,0x00,
  0x07,0xFC,0x00,0x00,
  0x07,0x1C,0x00,0x00,
  0x06,0x0C,0x00,0x00,
  0x06,0x0C,0x00,0x00,
  0x0E,0x0E,0x00,0x00,
  0x0E,0x0E,0x00,0x00,
  0x00,0x00,0x00,0x00
};

struct Dino {
  int   x = 12;
  int   y = 40;
  float vy = 0;
  bool  crouch = false;
} dino;

const int groundY = 54;

// 使用贴近位图的碰撞盒（稍小一点更公平）
int dinoW() { return dino.crouch ? 26 : 20; }
int dinoH() { return dino.crouch ? 12 : 18; }

// 两帧跑步动画相位
uint8_t runPhase = 0;

struct Rock {
  int x = 140;
  int y = groundY - 6;
  int w = 6;
  int h = 6;
  bool active = false;
};
const int MAX_ROCKS = 3;
Rock rocks[MAX_ROCKS];

int      scrollSpeed = 2;
uint32_t frameTimer  = 0;
uint32_t spawnTimer  = 0;
uint32_t score = 0, best = 0;

/********* Spawn / difficulty tuning *********/
int      activeRocksLimit = 2;
uint32_t spawnInterval    = 1400;
uint32_t spawnJitter      = 900;
uint16_t minGapPx         = 70;

int rightmostRockX() { int rx=-1000; for(int i=0;i<MAX_ROCKS;i++) if(rocks[i].active) rx=max(rx,rocks[i].x); return rx; }
int activeRockCount(){ int c=0; for(int i=0;i<MAX_ROCKS;i++) if(rocks[i].active) c++; return c; }
void retune_spawn_from_score(){
  if (score >= 150) scrollSpeed = 3;
  if (score >= 300) scrollSpeed = 4;
  uint32_t base = 1400;
  if (score >= 100) base = 1200;
  if (score >= 250) base = 1000;
  spawnInterval = base;
  spawnJitter   = 700;
  minGapPx = 70;
  if (score >= 150) minGapPx = 60;
  if (score >= 300) minGapPx = 52;
}
void spawn_rock(){
  if (activeRockCount() >= activeRocksLimit) return;
  if (rightmostRockX() > SCREEN_WIDTH - (int)minGapPx) return;
  for (int i=0;i<MAX_ROCKS;i++) if (!rocks[i].active) {
    rocks[i].active = true;
    rocks[i].x = SCREEN_WIDTH + random(0,24);
    int type = random(0,3);
    if (type==0){ rocks[i].w=6; rocks[i].h=6; }
    if (type==1){ rocks[i].w=8; rocks[i].h=10;}
    if (type==2){ rocks[i].w=4; rocks[i].h=4; }
    rocks[i].y = groundY - rocks[i].h;
    break;
  }
  retune_spawn_from_score();
  spawnTimer = 0;
  uint32_t jitter = random(0, spawnJitter);
  spawnInterval = max<uint32_t>(spawnInterval + jitter, 700);
}

/********* collision *********/
bool collideRect(int x1,int y1,int w1,int h1, int x2,int y2,int w2,int h2) {
  return !(x2 > x1+w1-1 || x2+w2-1 < x1 || y2 > y1+h1-1 || y2+h2-1 < y1);
}

/********* drawing *********/
void draw_dino() {
  // 贴地对齐：y 表示顶部；地面在 groundY
  int h = dinoH();
  int topY = dino.y;

  if (dino.crouch) {
    // crouch sprite 28x14
    display.drawBitmap(dino.x, topY, DINO_CROUCH, 28, 14, SSD1306_WHITE);
  } else {
    // running 24x20，采用两帧交替（runPhase）
    const uint8_t* frame = (runPhase==0) ? DINO_RUN_A : DINO_RUN_B;
    display.drawBitmap(dino.x, topY, frame, 24, 20, SSD1306_WHITE);
  }
}
void draw_ground(){ display.drawLine(0, groundY+1, SCREEN_WIDTH-1, groundY+1, SSD1306_WHITE); }
void draw_rocks(){ for(int i=0;i<MAX_ROCKS;i++) if(rocks[i].active) display.fillRect(rocks[i].x, rocks[i].y, rocks[i].w, rocks[i].h, SSD1306_WHITE); }
void draw_hud(){
  display.setTextSize(1); display.setTextColor(SSD1306_WHITE);
  display.setCursor(0,0);  display.print("Score:"); display.print(score);
  display.setCursor(64,0); display.print("Best:"); display.print(best);
  display.setCursor(0,56);
  if (gstate==GS_MENU)           display.print("Q0:Start Q1:Reset");
  else if (gstate==GS_PAUSE)     display.print("PAUSE Q0:Resume");
  else if (gstate==GS_PLAY)      display.print("Up Jump L/R Move Q0 P");
  else if (gstate==GS_GAMEOVER)  display.print("GameOver Q1 Restart");
}
void draw_scene(){
  display.clearDisplay();
  draw_ground(); draw_rocks(); draw_dino(); draw_hud();
  if (gstate == GS_MENU) {
    display.setCursor(20, 16); display.println("Tiny Alien");
    display.setCursor(10, 28); display.println("Q0 Start Q1 Reset");
  } else if (gstate == GS_PAUSE) {
    display.setCursor(44, 20); display.println("PAUSED");
  } else if (gstate == GS_GAMEOVER) {
    display.setCursor(28, 18); display.println("GAME OVER");
    display.setCursor(15, 30); display.println("Q1: Restart");
  }
  display.display();
}

/********* helpers *********/
void reset_game(bool keep_best){
  dino.x = 12;
  dino.vy = 0;
  dino.crouch = false;
  // 根据站立高度摆到地面上
  dino.y = groundY - dinoH();
  runPhase = 0;

  for(int i=0;i<MAX_ROCKS;i++){ rocks[i].active=false; rocks[i].x=140; rocks[i].y=groundY-6; rocks[i].w=6; rocks[i].h=6; }
  scrollSpeed = 2;
  if (!keep_best) best = 0;
  score = 0; spawnTimer = 0; spawnInterval = 1400;
}

/********* states *********/
void do_menu(){ if (pressed[CH_FUNC_R]) gstate = GS_PLAY; if (pressed[CH_FUNC_L]) reset_game(false); }
void do_pause(){ if (pressed[CH_FUNC_R]) gstate = GS_PLAY; if (pressed[CH_FUNC_L]) { reset_game(true); gstate = GS_MENU; } }
void do_gameover(){ if (pressed[CH_FUNC_L]) { reset_game(true); gstate = GS_MENU; } }

void do_play(){
  bool jump  = pressed[CH_UP];
  bool left  = pressed[CH_LEFT];
  bool right = pressed[CH_RIGHT];
  bool down  = pressed[CH_DOWN];

  if (pressed[CH_FUNC_R]) { gstate = GS_PAUSE; return; }

  // crouch
  dino.crouch = down;

  // 地面判定（根据当前帧高度）
  int curH = dinoH();
  bool onGround = (dino.y >= groundY - curH);
  if (onGround) { dino.y = groundY - curH; dino.vy = 0; }
  if (jump && onGround) dino.vy = JUMP_IMPULSE;

  // 左右
  if (left)  dino.x -= 2;
  if (right) dino.x += 2;
  dino.x = constrain(dino.x, 2, 50);

  // 重力/下落
  dino.vy += GRAVITY;
  if (!onGround && down) dino.vy += AIR_DOWN_BOOST;
  if (dino.vy >  MAX_FALL_SPEED) dino.vy =  MAX_FALL_SPEED;
  if (dino.vy < -MAX_FALL_SPEED) dino.vy = -MAX_FALL_SPEED;
  dino.y  += (int)dino.vy;

  // 落地对齐 & 跑步动画切换
  curH = dinoH();
  if (dino.y > groundY - curH) { dino.y = groundY - curH; dino.vy = 0; }
  if (dino.y >= groundY - curH && !dino.crouch) runPhase ^= 1;

  // 生成
  spawnTimer += FRAME_MS;
  if (spawnTimer >= spawnInterval) spawn_rock();

  // 岩石运动/判定
  for (int i=0;i<MAX_ROCKS;i++) if (rocks[i].active) {
    rocks[i].x -= scrollSpeed;
    if (rocks[i].x + rocks[i].w < 0) {
      rocks[i].active = false;
      score += 10;
      if (score > best) best = score;
      if (score % 80 == 0 && scrollSpeed < 4) scrollSpeed++;
      retune_spawn_from_score();
    } else {
      // 碰撞盒：用位图内较紧凑区域（从左偏 2px、宽略减）
      int hbX = dino.x + 2;
      int hbW = dinoW() - 4; if (hbW < 4) hbW = 4;
      if (collideRect(hbX, dino.y, hbW, dinoH(),
                      rocks[i].x, rocks[i].y, rocks[i].w, rocks[i].h)) {
        gstate = GS_GAMEOVER;
      }
    }
  }
}

/********* setup/loop *********/
unsigned long t_boot = 0;

void setup(){
  pinMode(LED_BUILTIN, OUTPUT);
  Serial.begin(115200);
  t_boot = millis();

  Wire.begin();
  Wire.setClock(400000);
  delay(30);
  display.begin(SSD1306_SWITCHCAPVCC, SCREEN_ADDRESS);
  display.clearDisplay();
  display.setTextSize(1);
  display.setTextColor(SSD1306_WHITE);
  display.setCursor(10, 16); display.println("Tiny Alian!");
  display.setCursor(6,  28); display.println("Q0 Start/ Q1 Reset");
  display.display();

  randomSeed(micros());
  reset_game(true);
  gstate = GS_MENU;
}

void loop(){
  if (millis() - t_boot < SAFE_WINDOW_MS) {
    digitalWrite(LED_BUILTIN, (millis()/250)%2);
    delay(50);
    return;
  }

  static uint32_t last = 0;
  uint32_t now = millis();
  if (now - last < FRAME_MS) return;
  last = now;

  poll_touch();

  switch (gstate) {
    case GS_MENU:     do_menu();     break;
    case GS_PLAY:     do_play();     break;
    case GS_PAUSE:    do_pause();    break;
    case GS_GAMEOVER: do_gameover(); break;
  }

  draw_scene();
}