Files
Dejvino d542d6ffa7 MiataDrive: flicker-free framebuffer rendering + 80 MHz SPI
Render every frame into a full-frame TFT_eSprite (16 bpp, PSRAM) and push
it to the panel in one continuous SPI stream — direct scattered draw calls
raced the panel scan-out and flickered. renderRoad split into projection
and draw passes: the sky now fills down to the topmost road row (fixes the
stale band at the horizon over crests) and the nearest segment is extended
to the screen bottom (fixes the wobbling stale strip). fillTrap uses
incremental edge interpolation. SPI raised to 80 MHz via build flag
(Setup210 define guarded) so the frame push fits the 33 ms budget.
2026-11-12 23:17:43 +01:00

1043 lines
41 KiB
Arduino

/**
* @file MiataDrive.ino
* @brief MiataDrive - Lotus Turbo Challenge style pseudo-3D racer for LilyGo T-Deck.
*
* Classic segment-based pseudo-3D road: track = list of (curve, hill)
* segments projected with perspective. Road is drawn near->far with rumble
* strips, lane markers and alternating shades that scroll with distance.
* Roadside scenery and traffic are depth-scaled sprites drawn far->near,
* clipped behind hill crests. Centrifugal force pulls you wide in curves.
*
* Controls:
* Trackball / arrow keys : steer (left/right), gas (up), brake (down)
* W / S : gas on / brake pulse A / D : steer
* Enter / click : start / restart P : toggle auto-play
*/
#include <Arduino.h>
#include <SPI.h>
#include <TFT_eSPI.h>
#include <Wire.h>
#include <math.h>
#include "utilities.h"
#include "sprites.h"
#include "sound_engine.h"
TFT_eSPI tft;
SoundEngine sound;
// Render every frame into a RAM buffer and push it to the panel in one
// continuous SPI stream. Painting straight onto the panel with thousands of
// small draw calls lets the panel's own scan-out overtake the drawing, which
// shows up as flicker / tearing; a single push writes each pixel exactly once.
#ifndef EMULATOR
static TFT_eSprite fb(&tft); // full-frame framebuffer (auto-allocates in PSRAM)
static TFT_eSprite *const GFXP = &fb;
#else
static TFT_eSPI *const GFXP = &tft; // emulator shim draws straight into the SDL framebuffer
#endif
static int scrW, scrH;
// ---------------------------------------------------------------------------
// Tunables
// ---------------------------------------------------------------------------
static const uint32_t FRAME_MS = 33; // ~30 fps
static const int SEG_LEN = 200; // segment length (world units)
static const int RUMBLE_SEGS = 3; // segments per rumble stripe
static const int DRAW_DIST = 60; // segments drawn ahead
static const float ROAD_W = 1000.0f; // road half-width (world units)
static const float CAM_H = 1500.0f; // camera height above road
static const float CAM_D = 0.84f; // 1/tan(fov/2), fov ~100 deg
static const float CENTRIFUGAL = 0.28f;
static const float MAX_SPEED = SEG_LEN * 60.0f;
static const float ACCEL = MAX_SPEED / 4.5f;
static const float BRAKE = -MAX_SPEED * 1.2f;
static const float DECEL = -MAX_SPEED / 5.0f;
static const float OFF_DECEL = -MAX_SPEED / 1.5f;
static const float OFF_LIMIT = MAX_SPEED / 4.0f;
static const int LAPS = 3;
static const float LAP_TIME = 75.0f;
// ---------------------------------------------------------------------------
// Track
// ---------------------------------------------------------------------------
struct Segment {
float curve;
float y1, y2; // road elevation at segment start / end
float clip; // screen y: sprite rows below this are hidden
uint8_t spriteType[2];
int8_t spriteOff[2]; // lateral offset in 1/8 road-half units
uint8_t spriteCount;
};
static const int MAX_SEGS = 1500;
static Segment segments[MAX_SEGS];
static int segCount = 0;
static float trackLen = 0;
// player views per color: 0 rear, 1 slight-turn, 2 turn, 3 side
enum { PV_REAR = 0, PV_SLIGHT, PV_TURN, PV_SIDE };
enum { SID_PLAYER_RED = 0, SID_PLAYER_BLUE = 4, SID_PLAYER_WHITE = 8, SID_PLAYER_YELLOW = 12,
SID_PALM = 16, SID_PINE, SID_BUSH, SID_BILLBOARD, SID_ARCH, SID_TIRES,
SID_CAR_BLUE, SID_CAR_BLUE_T, SID_CAR_WHITE, SID_CAR_WHITE_T,
SID_CAR_YELLOW, SID_CAR_YELLOW_T };
enum PlayerColor { PC_RED = 0, PC_BLUE = 1, PC_WHITE = 2, PC_YELLOW = 3 };
static int playerColor = PC_RED;
static inline int playerSprite(int view) { return playerColor * 4 + view; }
static float lastY() { return segCount ? segments[segCount - 1].y2 : 0.0f; }
static void addSegment(float curve, float y) {
if (segCount >= MAX_SEGS) return;
Segment &s = segments[segCount];
s.curve = curve;
s.y1 = lastY();
s.y2 = y;
s.clip = 0;
s.spriteCount = 0;
segCount++;
}
static float easeIn(float a, float b, float p) { return a + (b - a) * p * p; }
static float easeInOut(float a, float b, float p) { return a + (b - a) * (-cosf(p * 3.14159265f) / 2 + 0.5f); }
static void addRoad(int enter, int hold, int leave, float curve, float hillY) {
float startY = lastY();
float endY = startY + hillY * SEG_LEN;
int total = enter + hold + leave;
for (int i = 0; i < enter; i++)
addSegment(easeIn(0, curve, (float)i / enter), easeInOut(startY, endY, (float)(i + 1) / total));
for (int i = 0; i < hold; i++)
addSegment(curve, easeInOut(startY, endY, (float)(enter + i + 1) / total));
for (int i = 0; i < leave; i++)
addSegment(easeInOut(curve, 0, (float)i / leave), easeInOut(startY, endY, (float)(enter + hold + i + 1) / total));
}
static void addSprite(int segIdx, int type, float offRoadHalves) {
if (segIdx < 0 || segIdx >= segCount) return;
Segment &s = segments[segIdx];
if (s.spriteCount >= 2) return;
s.spriteType[s.spriteCount] = (uint8_t)type;
s.spriteOff[s.spriteCount] = (int8_t)(offRoadHalves * 8);
s.spriteCount++;
}
static void addScenery(int segIdx, int type, float side) {
float off = side * (1.3f + (float)random(220) / 100.0f);
addSprite(segIdx, type, off);
}
static void buildTrack() {
segCount = 0;
addRoad(40, 40, 40, 0, 0); // start straight
addRoad(30, 50, 30, 2, 0); // gentle right
addRoad(30, 40, 30, -3, 10); // left, slight rise
addRoad(40, 60, 40, 4, -20); // long right, downhill
addRoad(30, 30, 30, 0, 30); // climb
addRoad(30, 50, 30, -5, 0); // hard left over the crest
addRoad(40, 40, 40, 0, -30); // descend
addRoad(25, 35, 25, 3, 0); // S bends
addRoad(25, 35, 25, -3, 0);
addRoad(40, 70, 40, 5, 20); // long right sweeper, uphill
addRoad(30, 30, 30, 0, -10); // downhill straight (tuned to close the elevation loop)
addRoad(30, 60, 30, -4, 0); // long left
addRoad(20, 20, 20, 6, 0); // tight right
addRoad(40, 40, 40, 0, 0); // finish straight
trackLen = segCount * (float)SEG_LEN;
addSprite(2, SID_ARCH, 0.0f); // start/finish gantry
for (int n = 8; n < segCount - 8; n++) {
float c = fabsf(segments[n].curve);
if (n % 9 == 0) addScenery(n, (random(10) < 5) ? SID_PALM : SID_PINE, -1.0f);
if (n % 9 == 4) addScenery(n, (random(10) < 5) ? SID_PINE : SID_PALM, 1.0f);
if (n % 17 == 0) addScenery(n, SID_BUSH, (random(2) ? -1.0f : 1.0f));
if (n % 53 == 0) addScenery(n, SID_BILLBOARD, (n % 2) ? -1.8f : 1.8f);
if (c > 3.5f && n % 14 == 0) addScenery(n, SID_TIRES, (segments[n].curve > 0) ? -1.15f : 1.15f);
}
}
// ---------------------------------------------------------------------------
// Game state
// ---------------------------------------------------------------------------
enum GameState { ST_TITLE, ST_PLAYING, ST_CRASH, ST_GAMEOVER, ST_WIN, ST_SPRITES };
static GameState gameState = ST_TITLE;
static uint32_t stateT0 = 0;
static uint32_t nextFrame = 0;
static float position_ = 0;
static float playerX = 0;
static float speed_ = 0;
static float timeLeft = LAP_TIME;
static int lap = 0;
static int score = 0;
static bool autoPlay =
#ifdef AUTOPLAY
true;
#else
false;
#endif
;
// sound cooldowns
static uint32_t sndAccelT = 0;
#ifdef EMULATOR
extern bool emuAutoplay;
#endif
static uint32_t sndSkidT = 0;
// steering click tracking for skid trigger
static uint32_t turnClickT = 0;
static int turnClicks = 0;
static void registerTurn() {
uint32_t now = millis();
if (now - turnClickT > 350) turnClicks = 0;
turnClicks++;
turnClickT = now;
}
// crash / rollover
static uint32_t crashT0 = 0;
static int crashDir = 1; // slide direction off the road
static float crashVel = 0; // sliding speed during the tumble
static uint32_t shakeUntil = 0; // camera jolt
struct TrafficCar { float z, offset, speed; int sprite, spriteTurn; };
static const int N_CARS = 8;
static TrafficCar cars[N_CARS];
// manual input state
static float steerInput = 0;
static int gasLatch = 0; // W = 1
static uint32_t brakeUntil = 0;
static int gasFrame = 0; // resolved each frame: 1 gas, -1 brake
// ---------------------------------------------------------------------------
// Input: trackball
// ---------------------------------------------------------------------------
static volatile uint32_t tbEdges[4];
static volatile uint32_t tbClicks;
static void IRAM_ATTR tbIsrRight() { tbEdges[0]++; }
static void IRAM_ATTR tbIsrUp() { tbEdges[1]++; }
static void IRAM_ATTR tbIsrLeft() { tbEdges[2]++; }
static void IRAM_ATTR tbIsrDown() { tbEdges[3]++; }
static void IRAM_ATTR tbIsrClick() { tbClicks++; }
static const int TB_FP = 8;
#ifdef EMULATOR
static const int TB_IMPULSE = 6;
static const int TB_FRICTION = 12;
#else
static const int TB_IMPULSE = 24;
static const int TB_FRICTION = 15;
#endif
static const int TB_VMAX = 48 << TB_FP;
static int32_t tbVelX, tbVelY, tbRemX, tbRemY;
static void attachTrackball() {
const uint8_t tbPins[5] = { BOARD_TBOX_G02, BOARD_TBOX_G01, BOARD_TBOX_G04, BOARD_TBOX_G03, BOARD_BOOT_PIN };
for (int i = 0; i < 5; i++) pinMode(tbPins[i], INPUT_PULLUP);
attachInterrupt(digitalPinToInterrupt(tbPins[0]), tbIsrRight, FALLING);
attachInterrupt(digitalPinToInterrupt(tbPins[1]), tbIsrUp, FALLING);
attachInterrupt(digitalPinToInterrupt(tbPins[2]), tbIsrLeft, FALLING);
attachInterrupt(digitalPinToInterrupt(tbPins[3]), tbIsrDown, FALLING);
attachInterrupt(digitalPinToInterrupt(tbPins[4]), tbIsrClick, FALLING);
}
static void resetTrackball() {
for (int i = 0; i < 4; i++) tbEdges[i] = 0;
tbClicks = 0; tbVelX = tbVelY = tbRemX = tbRemY = 0;
}
static void applyTrackball(int &pxX, int &pxY, uint32_t &clicks) {
uint32_t e[4];
for (int i = 0; i < 4; i++) { e[i] = tbEdges[i]; tbEdges[i] = 0; }
clicks = tbClicks; tbClicks = 0;
tbVelX += ((int32_t)e[0] - (int32_t)e[2]) * TB_IMPULSE;
tbVelY += ((int32_t)e[3] - (int32_t)e[1]) * TB_IMPULSE;
if (tbVelX > TB_VMAX) tbVelX = TB_VMAX;
if (tbVelX < -TB_VMAX) tbVelX = -TB_VMAX;
if (tbVelY > TB_VMAX) tbVelY = TB_VMAX;
if (tbVelY < -TB_VMAX) tbVelY = -TB_VMAX;
tbVelX = tbVelX * TB_FRICTION / 16;
tbVelY = tbVelY * TB_FRICTION / 16;
tbRemX += tbVelX; tbRemY += tbVelY;
pxX = tbRemX / TB_FP; pxY = tbRemY / TB_FP;
tbRemX -= pxX * TB_FP; tbRemY -= pxY * TB_FP;
}
// ---------------------------------------------------------------------------
// Colors / palette (with distance fog)
// ---------------------------------------------------------------------------
static uint16_t C(uint8_t r, uint8_t g, uint8_t b) {
return ((r & 0xF8) << 8) | ((g & 0xFC) << 3) | (b >> 3);
}
static uint16_t palRoad[2][3], palGrassL[3], palGrassD[3], palRumL[3], palRumD[3], palLane[3];
static uint16_t colSkyHi, colSkyLo;
static void buildPalette() {
colSkyHi = C(70, 130, 220); colSkyLo = C(120, 175, 240);
// [light band][fog 0..2]
palRoad[0][0] = C(102,102,102); palRoad[1][0] = C(96, 96, 96);
palRoad[0][1] = C(128,132,130); palRoad[1][1] = C(122,126,124);
palRoad[0][2] = C(150,165,190); palRoad[1][2] = C(146,161,186);
palGrassL[0] = C(26,148,54); palGrassD[0] = C(18,118,42);
palGrassL[1] = C(70,152,96); palGrassD[1] = C(58,132,84);
palGrassL[2] = C(115,165,165);palGrassD[2] = C(104,152,152);
palRumL[0] = C(255,255,255); palRumD[0] = C(205,40,40);
palRumL[1] = C(235,235,235); palRumD[1] = C(205,120,120);
palRumL[2] = C(215,220,225); palRumD[2] = C(205,165,165);
palLane[0] = C(255,255,255); palLane[1] = C(235,235,235); palLane[2] = C(215,220,225);
}
// ---------------------------------------------------------------------------
// Draw primitives
// ---------------------------------------------------------------------------
static inline int iround(float v) { return (int)(v + (v >= 0 ? 0.5f : -0.5f)); }
static void fillSpan(int y, float xa, float xb, uint16_t c) {
if (y < 0 || y >= scrH) return;
int a = iround(xa), b = iround(xb);
if (b < a) { int t = a; a = b; b = t; }
if (b < 0 || a >= scrW) return;
if (a < 0) a = 0;
if (b >= scrW) b = scrW - 1;
GFXP->drawFastHLine(a, y, b - a + 1, c);
}
static void fillTrap(float y1, float xa1, float xb1, float y2, float xa2, float xb2, uint16_t c) {
if (y1 == y2) { fillSpan(iround(y1), xa1, xb1, c); return; }
int yTop = (int)ceilf(y1 < y2 ? y1 : y2);
int yBot = (int)floorf(y1 < y2 ? y2 : y1);
float dyr = y2 - y1;
float dxa = (xa2 - xa1) / dyr;
float dxb = (xb2 - xb1) / dyr;
float seed = ((float)yTop - y1) / dyr;
xa1 += dxa * seed; // step to the first drawn row, then
xb1 += dxb * seed; // increment instead of dividing per row
for (int y = yTop; y <= yBot; y++) {
fillSpan(y, xa1, xb1, c);
xa1 += dxa; xb1 += dxb;
}
}
// scaled sprite, bottom-center anchor, rows below clipY are cut (hill occlusion)
static void drawSprite(int id, int destW, float sx, float bottomY, float clipY, bool flip = false) {
const GameSprite &sp = SPRITES[id];
if (destW < 1) return;
int dw = destW;
int dh = (int)(destW * sp.h / sp.w); if (dh < 1) dh = 1;
int x0 = iround(sx) - dw / 2;
int yBase = iround(bottomY);
int clip = iround(clipY);
if (x0 >= scrW || x0 + dw <= 0) return;
for (int y = 0; y < dh; y++) {
int dy = yBase - dh + y; // bottom-up
if (dy > clip) continue; // hidden behind nearer geometry / crest
if (dy < 0 || dy >= scrH) continue;
const uint16_t *row = sp.data + (y * sp.h / dh) * sp.w;
int lastC = -2, runStart = 0;
for (int x = 0; x <= dw; x++) {
uint16_t c = (x < dw) ? row[(flip ? (dw - 1 - x) : x) * sp.w / dw] : (uint16_t)0;
bool trans = (x == dw) || (c == SPR_TRANSP);
if (!trans) {
if (c != lastC) {
if (lastC >= 0) {
int dx0 = x0 + runStart, wln = x - runStart;
if (dx0 < scrW && dx0 + wln > 0) GFXP->fillRect(dx0, dy, wln, 1, (uint16_t)lastC);
}
runStart = x; lastC = c;
}
} else {
if (lastC >= 0) {
int dx0 = x0 + runStart, wln = x - runStart;
if (dx0 < scrW && dx0 + wln > 0) GFXP->fillRect(dx0, dy, wln, 1, (uint16_t)lastC);
}
lastC = -2;
}
}
}
}
// ---------------------------------------------------------------------------
// Projection + road render
// ---------------------------------------------------------------------------
struct Proj { float x, y, w; };
static Proj P1[DRAW_DIST + 2];
static Proj P2[DRAW_DIST + 2];
static int segIdxN[DRAW_DIST + 2];
static bool slotValid[DRAW_DIST + 2];
static bool roadDraw[DRAW_DIST + 2];
static void renderRoad() {
// LOW horizon (OutRun-style) -> camera feels planted on the road
const float HORIZON_Y = scrH * 0.36f;
int skyBot = (int)HORIZON_Y + 14;
int skySplit = skyBot * 2 / 5;
float basePercent = fmodf(position_, SEG_LEN) / SEG_LEN;
int baseIdx = ((int)(position_ / SEG_LEN)) % segCount;
const Segment &bs = segments[baseIdx];
float camY = CAM_H + bs.y1 + (bs.y2 - bs.y1) * basePercent;
float camX = playerX * ROAD_W;
// whiplash camera jolt
if ((int32_t)(millis() - shakeUntil) < 0) camX += (float)(random(201) - 100);
// --- pass 1: project every segment and work out hill occlusion ---
float x = 0;
float dx = -(bs.curve * basePercent);
float maxY = (float)scrH;
const float NEAR_Z = CAM_D * 30.0f;
for (int n = 0; n < DRAW_DIST; n++) {
int idx = (baseIdx + n) % segCount;
bool looped = idx < baseIdx;
float camZ = position_ - (looped ? trackLen : 0);
Segment &seg = segments[idx];
float z1 = idx * (float)SEG_LEN - camZ;
float z2 = z1 + SEG_LEN;
// clamp near plane so the road reaches the bottom of the screen
// (avoids a gap where the camera's own segment is skipped)
float z1p = z1;
float xn = x;
if (z1p < NEAR_Z) {
float frac = (NEAR_Z - z1) / SEG_LEN;
if (frac > 1.0f) frac = 1.0f;
z1p = NEAR_Z;
xn = x + dx * frac;
}
// project p1/p2 (curve accumulated into camera x)
float s1 = CAM_D / z1p;
float s2 = CAM_D / z2;
P1[n].x = scrW / 2.0f + s1 * (0 - (camX - xn)) * scrW / 2.0f;
P1[n].y = HORIZON_Y - s1 * (seg.y1 + (seg.y2 - seg.y1) * ((z1p - z1) / SEG_LEN) - camY) * scrH / 2.0f;
P1[n].w = s1 * ROAD_W * scrW / 2.0f;
float x2 = x + dx; // p2 camera x offset (curve)
float camX2 = camX - x2;
P2[n].x = scrW / 2.0f + s2 * (0 - camX2) * scrW / 2.0f;
P2[n].y = HORIZON_Y - s2 * (seg.y2 - camY) * scrH / 2.0f;
P2[n].w = s2 * ROAD_W * scrW / 2.0f;
seg.clip = maxY;
segIdxN[n] = idx;
slotValid[n] = (z1 > NEAR_Z) && (z1 < DRAW_DIST * SEG_LEN * 2.0f);
roadDraw[n] = false;
x += dx;
dx += seg.curve;
if (z2 <= NEAR_Z) continue; // fully behind camera
if (P2[n].y >= maxY || P2[n].y >= P1[n].y) continue; // hidden or backfacing
roadDraw[n] = true;
maxY = P2[n].y;
}
// Sky down to just past the vanishing point — or down to the topmost road
// row, so no stale pixels are left between the horizon and the far road
// (that gap used to flicker when cresting hills).
int roadTop = (maxY >= (float)scrH) ? scrH : iround(maxY);
if (roadTop < 0) roadTop = 0;
int skyFill = (skyBot > roadTop) ? skyBot : roadTop;
GFXP->fillRect(0, 0, scrW, skySplit, colSkyHi);
GFXP->fillRect(0, skySplit, scrW, skyFill - skySplit, colSkyLo);
// --- pass 2: draw the road near -> far from the cached projections ---
bool nearest = true;
for (int n = 0; n < DRAW_DIST; n++) {
if (!roadDraw[n]) continue;
int idx = segIdxN[n];
const Segment &seg = segments[idx];
int fog = 0;
if (n > DRAW_DIST * 3 / 4) fog = 2;
else if (n > DRAW_DIST / 2) fog = 1;
bool light = ((idx / RUMBLE_SEGS) % 2) == 0;
// the nearest segment runs off the bottom edge: extend its near
// cross-section so no stale strip is left under the road
if (nearest && P2[n].y > P1[n].y) {
float yExt = (float)scrH;
float t = (yExt - P1[n].y) / (P2[n].y - P1[n].y);
P1[n].x += (P2[n].x - P1[n].x) * t;
P1[n].w += (P2[n].w - P1[n].w) * t;
P1[n].y = yExt;
}
nearest = false;
// grass band
uint16_t grass = light ? palGrassL[fog] : palGrassD[fog];
int yTop = iround(P2[n].y), yBot = iround(P1[n].y) - 1;
if (yBot > (int)seg.clip - 1) yBot = (int)seg.clip - 1;
if (yTop <= yBot && yBot >= 0) GFXP->fillRect(0, yTop, scrW, yBot - yTop + 1, grass);
// rumble strips (wide, for speed sensation)
float r1 = P1[n].w / 6.0f, r2 = P2[n].w / 6.0f;
uint16_t rumble = light ? palRumL[fog] : palRumD[fog];
fillTrap(P1[n].y, P1[n].x - P1[n].w - r1, P1[n].x - P1[n].w,
P2[n].y, P2[n].x - P2[n].w - r2, P2[n].x - P2[n].w, rumble);
fillTrap(P1[n].y, P1[n].x + P1[n].w + r1, P1[n].x + P1[n].w,
P2[n].y, P2[n].x + P2[n].w + r2, P2[n].x + P2[n].w, rumble);
// road surface
fillTrap(P1[n].y, P1[n].x - P1[n].w, P1[n].x + P1[n].w,
P2[n].y, P2[n].x - P2[n].w, P2[n].x + P2[n].w, palRoad[light ? 0 : 1][fog]);
// dashed center line on light bands
if (light) {
float l1 = P1[n].w / 22.0f, l2 = P2[n].w / 22.0f;
fillTrap(P1[n].y, P1[n].x - l1, P1[n].x + l1,
P2[n].y, P2[n].x - l2, P2[n].x + l2, palLane[fog]);
}
}
}
// ---------------------------------------------------------------------------
// Sprites (far -> near)
// ---------------------------------------------------------------------------
static void renderSprites() {
for (int n = DRAW_DIST - 1; n >= 1; n--) {
if (!slotValid[n]) continue;
int idx = segIdxN[n];
const Proj &pr = P1[n];
Segment &seg = segments[idx];
for (int si = 0; si < seg.spriteCount; si++) {
int type = seg.spriteType[si];
float off = seg.spriteOff[si] / 8.0f;
float worldW;
switch (type) {
case SID_PALM: worldW = 1.1f; break;
case SID_PINE: worldW = 1.0f; break;
case SID_BUSH: worldW = 0.45f; break;
case SID_BILLBOARD: worldW = 1.5f; break;
case SID_ARCH: worldW = 4.6f; break;
case SID_TIRES: worldW = 0.5f; break;
default: worldW = 1.0f; break;
}
float sx = pr.x + off * pr.w;
drawSprite(type, iround(worldW * pr.w), sx, pr.y, seg.clip);
}
// traffic cars in this segment
for (int c = 0; c < N_CARS; c++) {
int carSeg = (int)(cars[c].z / SEG_LEN) % segCount;
if (carSeg != idx) continue;
float percent = fmodf(cars[c].z, SEG_LEN) / SEG_LEN;
const Proj &pn = (n + 1 < DRAW_DIST && slotValid[n + 1]) ? P1[n + 1] : pr;
float sx = pr.x + (pn.x - pr.x) * percent + cars[c].offset * pr.w;
float sy = pr.y + (pn.y - pr.y) * percent;
float w = pr.w + (pn.w - pr.w) * percent;
// lean into corners: turning 3/4 view, mirrored on right-hand curves
float cv = segments[idx].curve;
int sid = (fabsf(cv) > 1.5f) ? cars[c].spriteTurn : cars[c].sprite;
drawSprite(sid, iround(w * 0.48f), sx, sy, seg.clip, cv > 0);
}
}
}
static void drawPlayerCar() {
const int CAR_W = 64; // player car width on screen (px)
float speedPct = speed_ / MAX_SPEED;
float bounce = (float)(random(3) - 1) * speedPct * 1.0f;
float cx = scrW / 2.0f + steerInput * 5.0f;
int baseY = scrH - 3 + (int)bounce;
// dirt rushing from the rear wheels while accelerating
if (gasFrame > 0 && speed_ > MAX_SPEED * 0.15f) {
for (int i = 0; i < 10; i++) {
int side = (i < 5) ? -1 : 1;
int dx0 = iround(cx) + side * (14 + (int)random(6));
int dy0 = baseY - 2 - (int)random(14);
int r = 1 + (int)random(3);
uint8_t g = 110 + (uint8_t)random(60);
GFXP->fillCircle(dx0, dy0, r, C(g, g - 20, g - 40));
}
// skid-like streaks when launching hard
if (speedPct < 0.4f) {
for (int i = 0; i < 4; i++) {
int side = (i < 2) ? -1 : 1;
int x0 = iround(cx) + side * 16;
GFXP->drawFastVLine(x0, baseY - 18, 12, C(150, 140, 120));
}
}
}
// contact shadow -> plants the car on the road
for (int dy = 0; dy < 5; dy++) {
int wdt = CAR_W - 6 - dy * 7;
if (wdt > 0) GFXP->drawFastHLine(scrW / 2 - wdt / 2, baseY + dy, wdt, C(30, 30, 26));
}
float ta = fabsf(steerInput);
int view = PV_REAR;
if (ta > 0.75f) view = PV_TURN;
else if (ta > 0.30f) view = PV_SLIGHT;
bool flip = steerInput > 0; // sheet views face nose-left; mirror for right turns
drawSprite(playerSprite(view), CAR_W, cx, baseY, scrH, flip);
}
// rollover animation: spare car sprites tumbling off the road
static void drawCrashCar() {
uint32_t t = millis() - crashT0;
const float DUR = 2300.0f;
float p = t / DUR; if (p > 1) p = 1;
// sprite sequence: rear -> slight -> turn -> side (rolling over)
int id;
if (t < 260) {
id = playerSprite(PV_REAR);
} else {
int f = ((t - 260) / 140) % 3;
id = playerSprite(PV_SLIGHT + f);
}
float cx = scrW / 2.0f + crashDir * p * 46.0f;
if (t < 650) cx += (float)(random(7) - 3); // whiplash shake
float hop = -sinf(p * 3.14159f) * 16.0f; // airborne arc
int baseY = scrH - 3 + (int)hop;
int w = 64 + (int)(sinf(p * 3.14159f) * 12.0f); // swells mid-tumble
// dust kicked up opposite the slide
for (int i = 0; i < 5; i++) {
int dx0 = iround(cx) - crashDir * (28 + (int)random(26));
int dy0 = baseY - (int)random(10);
GFXP->fillCircle(dx0, dy0, 1 + (int)random(2), C(150, 140, 120));
}
drawSprite(id, w, cx, baseY, scrH, crashDir > 0);
}
// ---------------------------------------------------------------------------
// HUD
// ---------------------------------------------------------------------------
static void drawHUD() {
GFXP->setTextDatum(TL_DATUM);
GFXP->setTextFont(2);
GFXP->setTextColor(TFT_WHITE, C(15,15,18));
char buf[48];
snprintf(buf, sizeof(buf), "TIME %d", (int)ceilf(timeLeft));
GFXP->drawString(buf, 6, 4);
snprintf(buf, sizeof(buf), "LAP %d/%d", lap + 1 < 1 ? 1 : lap + 1, LAPS);
GFXP->drawString(buf, 6, 22);
GFXP->setTextDatum(TR_DATUM);
snprintf(buf, sizeof(buf), "%d km/h", (int)(speed_ / 100.0f));
GFXP->drawString(buf, scrW - 6, 4);
GFXP->setTextDatum(TL_DATUM);
}
// ---------------------------------------------------------------------------
// Simulation
// ---------------------------------------------------------------------------
static void placeTraffic() {
const float lane[3] = { -0.66f, 0.0f, 0.66f };
for (int i = 0; i < N_CARS; i++) {
cars[i].z = (float)random((long)trackLen);
cars[i].offset = lane[i % 3];
cars[i].speed = MAX_SPEED * (0.25f + (float)random(30) / 100.0f);
static const int carSets[3][2] = {
{ SID_CAR_BLUE, SID_CAR_BLUE_T },
{ SID_CAR_WHITE, SID_CAR_WHITE_T },
{ SID_CAR_YELLOW, SID_CAR_YELLOW_T },
};
cars[i].sprite = carSets[i % 3][0];
cars[i].spriteTurn = carSets[i % 3][1];
}
}
static void startGame() {
position_ = 0; playerX = 0; speed_ = 0;
timeLeft = LAP_TIME; lap = 0; score = 0;
steerInput = 0; gasLatch = 0; brakeUntil = 0; // manual gas by default (no auto-throttle)
placeTraffic();
gameState = ST_PLAYING;
stateT0 = millis();
}
static float clampf(float v, float lo, float hi) { return v < lo ? lo : (v > hi ? hi : v); }
static void updateGame(float dt) {
int baseIdx = ((int)(position_ / SEG_LEN)) % segCount;
const Segment &baseSeg = segments[baseIdx];
float speedPct = speed_ / MAX_SPEED;
// --- sound triggers ---
uint32_t now = millis();
// continuous engine hum: frequency tracks speed (keep queue short for snappy SFX)
if (speed_ > 10.0f && sound.pending() < 2 && (int32_t)(now - sndAccelT) >= 100) {
sndAccelT = now;
int f = 70 + (int)(speedPct * 170.0f);
uint16_t amp = gasFrame > 0 ? 7000 : 4500;
SndEvent e = { SND_TONE, (uint16_t)f, 0, 120, amp };
sound.play(e);
}
bool skid = (turnClicks >= 3) && (fabsf(steerInput) > 0.55f) && (speedPct > 0.45f);
if (skid && (int32_t)(now - sndSkidT) >= 600) {
sndSkidT = now;
turnClicks = 0;
sound.clear();
SndEvent e = { SND_SWEEP, 900, 300, 120, 9000 };
sound.play(e);
}
float dx = dt * 2.4f * (speedPct > 0.18f ? speedPct : 0.18f); // steer authority grows with speed (min so steering works at low speed)
if (autoPlay) {
// AI: aim inside of upcoming curve, dodge traffic
float aheadCurve = 0;
for (int k = 2; k < 22; k++)
aheadCurve += segments[(baseIdx + k) % segCount].curve;
float target = clampf(-aheadCurve * 0.035f, -0.8f, 0.8f);
for (int c = 0; c < N_CARS; c++) {
float rel = cars[c].z - position_;
if (rel < 0) rel += trackLen;
if (rel > 0 && rel < SEG_LEN * 14 && fabsf(cars[c].offset - playerX) < 0.55f)
target = clampf(cars[c].offset + (cars[c].offset >= 0 ? -0.9f : 0.9f), -0.85f, 0.85f);
}
if (target > playerX) playerX += dx;
else if (target < playerX) playerX -= dx;
float maxA = (fabsf(aheadCurve) > 9.0f) ? 0.6f : 1.0f;
speed_ += (speed_ < MAX_SPEED * maxA) ? ACCEL * dt : DECEL * dt;
} else {
playerX += dx * steerInput * 1.8f;
if (gasFrame > 0) speed_ += ACCEL * dt;
else if (gasFrame < 0) speed_ += BRAKE * dt;
else speed_ += DECEL * dt;
}
// centrifugal force in curves
playerX -= dx * speedPct * baseSeg.curve * CENTRIFUGAL;
// off-road drag
if ((playerX < -1.05f || playerX > 1.05f) && speed_ > OFF_LIMIT)
speed_ += OFF_DECEL * dt;
// hard off-road excursion -> rollover crash (any speed above a crawl)
if (fabsf(playerX) > 1.65f && speed_ > MAX_SPEED * 0.08f) {
crashDir = (playerX > 0) ? 1 : -1;
crashVel = speed_ * 0.45f;
crashT0 = millis();
shakeUntil = crashT0 + 700;
score -= 300; if (score < 0) score = 0;
speed_ = 0;
gameState = ST_CRASH;
// crash sound (clear queued hum so it plays immediately)
sound.clear();
{ SndEvent e = { SND_NOISE, 0, 0, 260, 22000 }; sound.play(e);
SndEvent f = { SND_SWEEP, 400, 80, 220, 14000 }; sound.play(f); }
return;
}
playerX = clampf(playerX, -2.2f, 2.2f);
if (speed_ < 0) speed_ = 0;
if (speed_ > MAX_SPEED) speed_ = MAX_SPEED;
position_ += speed_ * dt;
while (position_ >= trackLen) {
position_ -= trackLen;
lap++;
timeLeft += 45.0f;
score += 2000;
if (lap >= LAPS) { gameState = ST_WIN; stateT0 = millis(); return; }
}
score += (int)(speed_ * dt * 0.02f);
for (int c = 0; c < N_CARS; c++) {
cars[c].z += cars[c].speed * dt;
if (cars[c].z >= trackLen) cars[c].z -= trackLen;
float rel = cars[c].z - position_;
if (rel < 0) rel += trackLen;
if (rel < SEG_LEN * 0.9f && fabsf(cars[c].offset - playerX) < 0.30f) {
speed_ = cars[c].speed * 0.6f;
position_ = cars[c].z - SEG_LEN * 1.2f;
if (position_ < 0) position_ += trackLen;
shakeUntil = millis() + 250; // jolt on rear-ending traffic
{ SndEvent e = { SND_NOISE, 0, 0, 120, 12000 }; sound.play(e); }
}
}
timeLeft -= dt;
if (timeLeft <= 0) { timeLeft = 0; gameState = ST_GAMEOVER; stateT0 = millis(); }
}
// rollover: slide, tumble through the spare car sprites, then rejoin
static void updateCrash(float dt) {
crashVel *= 0.90f;
position_ += crashVel * dt;
if (position_ >= trackLen) position_ -= trackLen;
timeLeft -= dt;
if (millis() - crashT0 > 2300) {
playerX = crashDir * 0.55f; // recovered, back on the tarmac
speed_ = 0;
gasLatch = 1;
gameState = ST_PLAYING;
}
if (timeLeft <= 0) { timeLeft = 0; gameState = ST_GAMEOVER; stateT0 = millis(); }
}
// ---------------------------------------------------------------------------
// Screens
// ---------------------------------------------------------------------------
static void drawTitle() {
// backdrop is our own scene: the start line under the arch
position_ = 0; playerX = 0; speed_ = 0;
renderRoad();
renderSprites();
GFXP->setTextDatum(MC_DATUM);
GFXP->setFreeFont(&FreeSansBold24pt7b);
GFXP->setTextColor(TFT_YELLOW, C(15,15,18));
GFXP->drawString("MIATADRIVE", scrW / 2, 14);
GFXP->setFreeFont(nullptr);
GFXP->setTextFont(2);
GFXP->setTextColor(TFT_WHITE, C(15,15,18));
GFXP->drawString("W gas S brake A/D steer", scrW / 2, 60);
GFXP->drawString("P auto T sprites Press/tap: race", scrW / 2, 78);
// car color picker: 1 Red 2 Blue 3 White 4 Yellow
static const char* names[4] = { "1 Red", "2 Blue", "3 White", "4 Yellow" };
uint16_t pal[4] = { C(220,40,40), C(60,90,220), C(235,235,235), C(240,200,40) };
for (int i = 0; i < 4; i++) {
GFXP->setTextColor(i == playerColor ? pal[i] : C(200,200,200), C(15,15,18));
GFXP->setTextDatum(TC_DATUM);
GFXP->drawString(names[i], 46 + i * 76, 102);
if (i == playerColor) {
GFXP->setTextColor(TFT_WHITE, C(15,15,18));
GFXP->drawString("^", 46 + i * 76, 118);
}
}
GFXP->setTextDatum(TL_DATUM);
// showcase the selected car, parked on the road below the arch
drawSprite(playerSprite(PV_REAR), 110, scrW / 2, scrH - 4, scrH);
}
// sprite test gallery: every SPRITES[] entry at native size on a checkerboard,
// bottom-center anchored like in-game, labeled with index + crop size
static int spritePage = 0;
static void drawSpriteTest() {
// checker background
for (int by = 0; by < scrH; by += 8)
for (int bx = 0; bx < scrW; bx += 8) {
uint16_t c = (((bx / 8) + (by / 8)) & 1) ? C(70,70,74) : C(135,135,138);
GFXP->fillRect(bx, by, 8, 8, c);
}
// build list of sprite ids for this page
int ids[12]; int nids = 0;
if (spritePage < 4) {
int color = spritePage; // 0..3
ids[nids++] = color * 4 + PV_REAR;
ids[nids++] = color * 4 + PV_SLIGHT;
ids[nids++] = color * 4 + PV_TURN;
} else if (spritePage == 4) {
int arr[] = { SPR_CAR_BLUE, SPR_CAR_BLUE_T, SPR_CAR_WHITE, SPR_CAR_WHITE_T, SPR_CAR_YELLOW, SPR_CAR_YELLOW_T };
for (int i = 0; i < 6; i++) ids[nids++] = arr[i];
} else {
int arr[] = { SPR_PALM, SPR_PINE, SPR_BUSH, SPR_BILLBOARD, SPR_ARCH, SPR_TIRES };
for (int i = 0; i < 6; i++) ids[nids++] = arr[i];
}
const int CELL_W = 96, CELL_H = 96;
int cols = 3;
for (int i = 0; i < nids; i++) {
int col = i % cols, row = i / cols;
int cx0 = col * CELL_W + 8, cy0 = row * CELL_H + 24;
GFXP->drawRect(cx0, cy0, CELL_W, CELL_H, C(20,20,24));
const GameSprite &sp = SPRITES[ids[i]];
int destW = sp.w <= CELL_W - 8 ? sp.w : CELL_W - 8;
if (destW * sp.h / sp.w > CELL_H - 16) destW = (CELL_H - 16) * sp.w / sp.h;
drawSprite(ids[i], destW, cx0 + CELL_W / 2, cy0 + CELL_H - 8, scrH);
GFXP->fillCircle(cx0 + CELL_W / 2, cy0 + CELL_H - 8, 1, TFT_MAGENTA);
char buf[24];
snprintf(buf, sizeof(buf), "%d %dx%d", ids[i], sp.w, sp.h);
GFXP->setTextDatum(TL_DATUM);
GFXP->setTextFont(1);
GFXP->setTextColor(TFT_YELLOW, C(20,20,24));
GFXP->drawString(buf, cx0 + 2, cy0 + 2);
}
GFXP->setTextFont(2);
GFXP->setTextColor(TFT_WHITE, C(20,20,24));
GFXP->setTextDatum(TC_DATUM);
char title[48];
const char* names[] = { "Car 1", "Car 2", "Car 3", "Car 4", "Traffic cars", "Props" };
snprintf(title, sizeof(title), "Page %d/6: %s (A/D flip, T back)", spritePage + 1, names[spritePage]);
GFXP->drawString(title, scrW / 2, 0);
GFXP->setTextDatum(TL_DATUM);
}
static void drawEndScreen(bool win) {
GFXP->fillRect(0, 0, scrW, scrH, C(10,10,14));
GFXP->setTextDatum(MC_DATUM);
GFXP->setFreeFont(&FreeSansBold24pt7b);
GFXP->setTextColor(win ? TFT_GREEN : TFT_RED, C(10,10,14));
GFXP->drawString(win ? "FINISH!" : "GAME OVER", scrW / 2, 80);
GFXP->setFreeFont(nullptr);
GFXP->setTextFont(2);
GFXP->setTextColor(TFT_WHITE, C(10,10,14));
char buf[48];
snprintf(buf, sizeof(buf), "Score %d", score);
GFXP->drawString(buf, scrW / 2, 140);
GFXP->setTextColor(TFT_GOLD, C(10,10,14));
GFXP->drawString("Press to restart", scrW / 2, 190);
GFXP->setTextDatum(TL_DATUM);
}
// ---------------------------------------------------------------------------
// Frame present
// ---------------------------------------------------------------------------
#ifndef EMULATOR
// Push the finished frame to the panel as one continuous SPI stream. The
// 320x240x16 buffer lives in PSRAM; the push is what used to be thousands of
// scattered draw calls racing the panel's scan-out (the flicker).
static void present() {
if (!fb.created()) return;
tft.startWrite();
fb.pushSprite(0, 0);
tft.endWrite();
}
#else
static void present() {} // shim draws straight into the SDL framebuffer
#endif
static void render() {
switch (gameState) {
case ST_TITLE: drawTitle(); break;
case ST_SPRITES: drawSpriteTest(); break;
case ST_GAMEOVER: drawEndScreen(false); break;
case ST_WIN: drawEndScreen(true); break;
default:
renderRoad();
renderSprites();
if (gameState == ST_CRASH) drawCrashCar(); else drawPlayerCar();
drawHUD();
break;
}
present();
}
// ---------------------------------------------------------------------------
// Keyboard
// ---------------------------------------------------------------------------
static void pollKeyboard() {
static char lastKey = 0;
Wire.requestFrom((uint8_t)0x55, (uint8_t)1);
if (Wire.available() == 0) { lastKey = 0; return; }
char k = (char)Wire.read();
if (k == 0) { lastKey = 0; return; }
if (k == lastKey) return;
lastKey = k;
char c = tolower(k);
switch (c) {
case 'w': gasLatch = 1; break;
case 's': brakeUntil = millis() + 500; gasLatch = 0; break;
case 'a':
if (gameState == ST_SPRITES) { spritePage = (spritePage + 5) % 6; }
else { steerInput -= 0.4f; registerTurn(); }
break;
case 'd':
if (gameState == ST_SPRITES) { spritePage = (spritePage + 1) % 6; }
else { steerInput += 0.4f; registerTurn(); }
break;
case 'p': autoPlay = !autoPlay; break;
case '1': playerColor = PC_RED; if (gameState == ST_TITLE) drawTitle(); break;
case '2': playerColor = PC_BLUE; if (gameState == ST_TITLE) drawTitle(); break;
case '3': playerColor = PC_WHITE; if (gameState == ST_TITLE) drawTitle(); break;
case '4': playerColor = PC_YELLOW; if (gameState == ST_TITLE) drawTitle(); break;
case 't':
if (gameState == ST_SPRITES) { gameState = ST_TITLE; stateT0 = millis(); }
else gameState = ST_SPRITES;
break;
case ' ': case 'r':
if (gameState == ST_TITLE) startGame();
else if (gameState == ST_GAMEOVER || gameState == ST_WIN) { gameState = ST_TITLE; stateT0 = millis(); }
break;
}
steerInput = clampf(steerInput, -1, 1);
}
// ---------------------------------------------------------------------------
// Hardware
// ---------------------------------------------------------------------------
static void hardwareInit() {
Serial.begin(115200);
pinMode(BOARD_POWERON, OUTPUT);
digitalWrite(BOARD_POWERON, HIGH);
pinMode(BOARD_SDCARD_CS, OUTPUT);
pinMode(RADIO_CS_PIN, OUTPUT);
pinMode(BOARD_TFT_CS, OUTPUT);
digitalWrite(BOARD_SDCARD_CS, HIGH);
digitalWrite(RADIO_CS_PIN, HIGH);
digitalWrite(BOARD_TFT_CS, HIGH);
pinMode(BOARD_SPI_MISO, INPUT_PULLUP);
SPI.begin(BOARD_SPI_SCK, BOARD_SPI_MISO, BOARD_SPI_MOSI);
tft.begin();
tft.setRotation(1);
tft.fillScreen(TFT_BLACK);
pinMode(BOARD_BL_PIN, OUTPUT);
digitalWrite(BOARD_BL_PIN, HIGH);
Wire.begin(BOARD_I2C_SDA, BOARD_I2C_SCL);
attachTrackball();
randomSeed(esp_random());
}
void setup() {
hardwareInit();
scrW = tft.width();
scrH = tft.height();
#ifndef EMULATOR
fb.setColorDepth(16);
if (!fb.createSprite(scrW, scrH))
Serial.println("MiataDrive: framebuffer alloc failed (falling back to blank screen)");
#endif
buildPalette();
buildTrack();
if (!sound.begin()) Serial.println("Sound engine init failed");
sound.setVolume(5);
#ifdef EMULATOR
if (emuAutoplay) autoPlay = true;
#endif
drawTitle();
stateT0 = millis();
}
void loop() {
uint32_t now = millis();
if (now < 1500) { resetTrackball(); delay(1); return; }
if ((int32_t)(now - nextFrame) < 0) { delay(1); return; }
float dt = (nextFrame == 0) ? 0.033f : (float)(now - (nextFrame - FRAME_MS)) / 1000.0f;
if (dt < 0.004f) dt = 0.004f;
if (dt > 0.1f) dt = 0.1f;
nextFrame = now + FRAME_MS;
int pxX, pxY; uint32_t clicks;
applyTrackball(pxX, pxY, clicks);
if (clicks && (int32_t)(now - stateT0) > 1500) {
if (gameState == ST_TITLE) startGame();
else if (gameState == ST_GAMEOVER || gameState == ST_WIN) { gameState = ST_TITLE; stateT0 = millis(); }
}
pollKeyboard();
// resolve manual input for this frame
gasFrame = gasLatch;
if (pxY < 0) gasFrame = 1;
if (pxY > 0) gasFrame = -1;
if ((int32_t)(now - brakeUntil) < 0) gasFrame = -1;
if (gameState == ST_PLAYING && !autoPlay) {
if (pxX) { steerInput += (pxX > 0 ? 1 : -1) * 0.4f; registerTurn(); }
else steerInput *= 0.90f; // auto-center only when not steering
steerInput = clampf(steerInput, -1, 1);
}
// auto-play driver / demo loop
if (autoPlay) {
if (gameState == ST_TITLE && now - stateT0 > 1200) startGame();
if ((gameState == ST_GAMEOVER || gameState == ST_WIN) && now - stateT0 > 3500) {
gameState = ST_TITLE; stateT0 = millis();
}
}
if (gameState == ST_PLAYING) updateGame(dt);
else if (gameState == ST_CRASH) updateCrash(dt);
render();
}