dcovington
/
C64-dev
1
0
複製 0
程式碼 問題 0 合併請求 0 版本發佈 0 Wiki 活動
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
37 提交
1 分支
35MB
目錄樹: 7ea1100239
分支列表 標籤
${ item.name }
建立分支 ${ searchTerm }
從 '7ea1100239'
${ noResults }
C64-dev/examples/moonlander.c

466 line
14KB
原始文件 Blame 歷史記錄 

  1. /* moonlander.c – Lunar Lander for Commodore 64

  2.  *

  3.  * Build:

  4.  *   cl65 -t c64 -O -o moonlander.prg moonlander.c

  5.  *

  6.  * Controls (joystick port 2):

  7.  *   FIRE        = upward thrust

  8.  *   LEFT/RIGHT  = horizontal thrust

  9.  *

  10.  * Land gently on the green pad to score points.

  11.  * Hard landing or missing the pad = CRASH.

  12.  */

  13. 

  14. #include <c64.h>

  15. #include <conio.h>

  16. #include <string.h>

  17. #include <stdio.h>

  18. 

  19. /* ----------------------------------------------------------------

  20.    Hardware register macros

  21.    ---------------------------------------------------------------- */

  22. #define SP0X    (*(unsigned char*)0xD000)

  23. #define SP0Y    (*(unsigned char*)0xD001)

  24. #define MSIGX   (*(unsigned char*)0xD010)   /* MSB of sprite X coords */

  25. #define SPENA   (*(unsigned char*)0xD015)   /* sprite enable bits */

  26. #define SP0COL  (*(unsigned char*)0xD027)   /* sprite 0 color */

  27. #define BGCOL   (*(unsigned char*)0xD021)   /* background color */

  28. #define BORDER  (*(unsigned char*)0xD020)   /* border color */

  29. #define RASTER  (*(unsigned char*)0xD012)   /* current raster line */

  30. 

  31. #define SCREEN  ((unsigned char*)0x0400)    /* screen RAM */

  32. #define COLRAM  ((unsigned char*)0xD800)    /* color RAM */

  33. #define SPR0PTR (*(unsigned char*)0x07F8)   /* sprite 0 data pointer */

  34. 

  35. /* CIA #1 $DC00 – joystick port 2 (active LOW) */

  36. #define JOY2      (*(unsigned char*)0xDC00)

  37. #define JOY_PORT2_UP    0x01

  38. #define JOY_PORT2_DOWN  0x02

  39. #define JOY_PORT2_LEFT  0x04

  40. #define JOY_PORT2_RIGHT 0x08

  41. #define JOY_PORT2_FIRE  0x10

  42. 

  43. /* SID voice 1 */

  44. #define SID_FLO (*(unsigned char*)0xD400)

  45. #define SID_FHI (*(unsigned char*)0xD401)

  46. #define SID_CT  (*(unsigned char*)0xD404)

  47. #define SID_AD  (*(unsigned char*)0xD405)

  48. #define SID_SR  (*(unsigned char*)0xD406)

  49. #define SID_VOL (*(unsigned char*)0xD418)

  50. 

  51. /* ----------------------------------------------------------------

  52.    Layout constants

  53.    ---------------------------------------------------------------- */

  54. #define COLS        40

  55. #define ROWS        25

  56. #define TERRAIN_ROW 22      /* text row: top of terrain surface */

  57. #define PAD_COL     18      /* landing pad left column */

  58. #define PAD_W        4      /* landing pad width in characters */

  59. 

  60. /* Sprite block 13 sits at $0340 (tape buffer area, safe to reuse) */

  61. #define SPR_BLOCK   13

  62. #define SPR_MEM     ((unsigned char*)0x0340)

  63. 

  64. /* Sprite Y where terrain surface begins (NTSC top ≈ 50, row*8 px) */

  65. #define GROUND_Y    (50 + TERRAIN_ROW * 8)   /* = 226 */

  66. 

  67. /* Landing pad pixel X bounds (left border ≈ 24px for NTSC) */

  68. #define PAD_PIX_L   (24 + PAD_COL * 8)               /* 168 */

  69. #define PAD_PIX_R   (24 + (PAD_COL + PAD_W) * 8)     /* 200 */

  70. 

  71. /* Fixed-point scale: multiply all positions/velocities by SCALE */

  72. #define SCALE 4

  73. 

  74. /* ----------------------------------------------------------------

  75.    Lander sprite: 24×21 hi-res, 63 bytes + 1 padding

  76.    ----------------------------------------------------------------

  77.    Looks like a rocket/lander body with two splayed landing legs.

  78.    ---------------------------------------------------------------- */

  79. static const unsigned char spr_lander[64] = {

  80.     0x00, 0x18, 0x00,  /* row  0  top nozzle */

  81.     0x00, 0x3C, 0x00,  /* row  1 */

  82.     0x00, 0x7E, 0x00,  /* row  2 */

  83.     0x01, 0xFF, 0x80,  /* row  3 */

  84.     0x03, 0xFF, 0xC0,  /* row  4 */

  85.     0x07, 0xFF, 0xE0,  /* row  5  wide body */

  86.     0x03, 0xFF, 0xC0,  /* row  6 */

  87.     0x01, 0xFF, 0x80,  /* row  7 */

  88.     0x00, 0xFF, 0x00,  /* row  8 */

  89.     0x00, 0x7E, 0x00,  /* row  9 */

  90.     0x00, 0x3C, 0x00,  /* row 10 */

  91.     0x00, 0x3C, 0x00,  /* row 11 */

  92.     0x00, 0x3C, 0x00,  /* row 12 */

  93.     0x01, 0xFF, 0x80,  /* row 13 lower body */

  94.     0x03, 0xFF, 0xC0,  /* row 14 */

  95.     0x07, 0xFF, 0xE0,  /* row 15 */

  96.     0x06, 0x00, 0x60,  /* row 16 leg struts */

  97.     0x0C, 0x00, 0x30,  /* row 17 */

  98.     0x18, 0x00, 0x18,  /* row 18 */

  99.     0x30, 0x00, 0x0C,  /* row 19 */

  100.     0x60, 0x00, 0x06,  /* row 20 footpads */

  101.     0x00               /* padding byte */

  102. };

  103. 

  104. /* ----------------------------------------------------------------

  105.    Thrust exhaust sprite: 24×21, placed below lander when firing

  106.    ---------------------------------------------------------------- */

  107. static const unsigned char spr_exhaust[64] = {

  108.     0x00, 0x18, 0x00,

  109.     0x00, 0x3C, 0x00,

  110.     0x00, 0x7E, 0x00,

  111.     0x01, 0xFF, 0x80,

  112.     0x01, 0xE7, 0x80,

  113.     0x00, 0xC3, 0x00,

  114.     0x00, 0x42, 0x00,

  115.     0x00, 0x3C, 0x00,

  116.     0x00, 0x18, 0x00,

  117.     0x00, 0x00, 0x00,

  118.     0x00, 0x00, 0x00,

  119.     0x00, 0x00, 0x00,

  120.     0x00, 0x00, 0x00,

  121.     0x00, 0x00, 0x00,

  122.     0x00, 0x00, 0x00,

  123.     0x00, 0x00, 0x00,

  124.     0x00, 0x00, 0x00,

  125.     0x00, 0x00, 0x00,

  126.     0x00, 0x00, 0x00,

  127.     0x00, 0x00, 0x00,

  128.     0x00, 0x00, 0x00,

  129.     0x00

  130. };

  131. 

  132. /* ----------------------------------------------------------------

  133.    Game state

  134.    ---------------------------------------------------------------- */

  135. static int px, py;          /* lander sprite position × SCALE */

  136. static int vx, vy;          /* velocity × SCALE */

  137. static int fuel;            /* remaining fuel × SCALE */

  138. static int score;

  139. static unsigned char crashed;

  140. static unsigned char landed;

  141. 

  142. /* ----------------------------------------------------------------

  143.    Helpers

  144.    ---------------------------------------------------------------- */

  145. 

  146. /* Sync to raster line 250 – gives one tick per TV frame (≈50/60 Hz) */

  147. static void wait_frame(void)

  148. {

  149.     while (RASTER != 250) {}

  150.     while (RASTER == 250) {}

  151. }

  152. 

  153. static void sid_thrust_on(void)

  154. {

  155.     SID_VOL = 0x0F;

  156.     SID_FLO = 0x60;

  157.     SID_FHI = 0x00;

  158.     SID_CT  = 0x81;   /* noise waveform + gate */

  159.     SID_AD  = 0x00;

  160.     SID_SR  = 0xF0;

  161. }

  162. 

  163. static void sid_off(void)

  164. {

  165.     SID_CT = 0x00;    /* release gate */

  166. }

  167. 

  168. static void sid_silence_all(void)

  169. {

  170.     (*(unsigned char*)0xD404) = 0x00;

  171.     (*(unsigned char*)0xD40B) = 0x00;

  172.     (*(unsigned char*)0xD412) = 0x00;

  173.     SID_VOL = 0x0F;

  174. }

  175. 

  176. /* Draw two rows of terrain: solid blocks with a flat pad gap */

  177. static void draw_terrain(void)

  178. {

  179.     unsigned char c;

  180.     for (c = 0; c < COLS; c++) {

  181.         unsigned int r1 = (unsigned int)TERRAIN_ROW * COLS + c;

  182.         unsigned int r2 = (unsigned int)(TERRAIN_ROW + 1) * COLS + c;

  183. 

  184.         if (c >= PAD_COL && c < PAD_COL + PAD_W) {

  185.             SCREEN[r1] = 0x2D;   /* '-' in screen code = pad marker */

  186.             COLRAM[r1] = 5;      /* green */

  187.         } else {

  188.             SCREEN[r1] = 0xA0;   /* solid block */

  189.             COLRAM[r1] = 11;     /* dark grey */

  190.         }

  191.         SCREEN[r2] = 0xA0;

  192.         COLRAM[r2] = 11;

  193.     }

  194. }

  195. 

  196. static void draw_stars(void)

  197. {

  198.     static const unsigned char sr[] = { 2,  4,  7, 10, 13,  3,  8, 15, 19,  6 };

  199.     static const unsigned char sc[] = { 5, 15, 30,  8, 35, 22,  3, 18, 10, 37 };

  200.     unsigned char i;

  201.     for (i = 0; i < 10; i++) {

  202.         unsigned int p = (unsigned int)sr[i] * COLS + sc[i];

  203.         SCREEN[p] = 0x2E;   /* '.' */

  204.         COLRAM[p] = 1;      /* white */

  205.     }

  206. }

  207. 

  208. /* Write sprite 0 position registers from internal fixed-point state */

  209. static void update_sprite(void)

  210. {

  211.     unsigned int sx = (unsigned int)(px / SCALE);

  212.     unsigned int sy = (unsigned int)(py / SCALE);

  213. 

  214.     if (sx > 255) {

  215.         SP0X  = (unsigned char)(sx - 256);

  216.         MSIGX = MSIGX | 0x01;

  217.     } else {

  218.         SP0X  = (unsigned char)sx;

  219.         MSIGX = MSIGX & 0xFE;

  220.     }

  221.     SP0Y = (unsigned char)(sy > 247 ? 247 : sy);

  222. }

  223. 

  224. /* Update exhaust sprite 1 (shown only while thrusting) */

  225. static void update_exhaust(unsigned char thrusting)

  226. {

  227.     if (thrusting) {

  228.         unsigned int sx = (unsigned int)(px / SCALE);

  229.         unsigned int sy = (unsigned int)(py / SCALE) + 18;

  230.         if (sx > 255) {

  231.             (*(unsigned char*)0xD002) = (unsigned char)(sx - 256);

  232.             MSIGX = MSIGX | 0x02;

  233.         } else {

  234.             (*(unsigned char*)0xD002) = (unsigned char)sx;

  235.             MSIGX = MSIGX & 0xFD;

  236.         }

  237.         (*(unsigned char*)0xD003) = (unsigned char)(sy > 247 ? 247 : sy);

  238.         SPENA = SPENA | 0x02;

  239.     } else {

  240.         SPENA = SPENA & 0xFD;   /* hide exhaust sprite */

  241.     }

  242. }

  243. 

  244. static void draw_hud(void)

  245. {

  246.     gotoxy(0, 0);

  247.     cprintf("FUEL:%4d  VY:%3d  VX:%3d  SC:%5d",

  248.             fuel / SCALE, vy / SCALE, vx / SCALE, score);

  249. }

  250. 

  251. static void center_msg(const char *msg, unsigned char row)

  252. {

  253.     unsigned char len = (unsigned char)strlen(msg);

  254.     unsigned char col = (COLS - len) / 2;

  255.     gotoxy(col, row);

  256.     textcolor(COLOR_WHITE);

  257.     cputs(msg);

  258. }

  259. 

  260. /* ----------------------------------------------------------------

  261.    main

  262.    ---------------------------------------------------------------- */

  263. int main(void)

  264. {

  265.     unsigned char joy;

  266.     unsigned char thrusting;

  267.     unsigned char gravity_tick;

  268.     unsigned char play_again;

  269.     int lsx, lsy;   /* lander sprite X/Y (not scaled) for collision */

  270. 

  271.     /* ---- Title screen ------------------------------------------ */

  272.     clrscr();

  273.     bgcolor(COLOR_BLACK);

  274.     bordercolor(COLOR_BLACK);

  275.     textcolor(COLOR_CYAN);

  276.     center_msg("* MOONLANDER *", 4);

  277.     textcolor(COLOR_YELLOW);

  278.     center_msg("GUIDE YOUR SHIP TO THE GREEN PAD", 7);

  279.     textcolor(COLOR_WHITE);

  280.     center_msg("FIRE       = UPWARD THRUST", 9);

  281.     center_msg("LEFT/RIGHT = HORIZONTAL THRUST", 10);

  282.     center_msg("LAND GENTLY TO SCORE POINTS", 11);

  283.     center_msg("HARD LANDING OR MISSING PAD", 12);

  284.     center_msg("MEANS CERTAIN DOOM!", 13);

  285.     textcolor(COLOR_GREEN);

  286.     center_msg("PRESS FIRE TO BEGIN", 17);

  287. 

  288.     /* Park lander off-screen during title */

  289.     memcpy(SPR_MEM, spr_lander, 64);

  290.     memcpy((unsigned char*)0x0380, spr_exhaust, 64);

  291.     SPR0PTR                    = SPR_BLOCK;        /* block 13 = lander */

  292.     (*(unsigned char*)0x07F9)  = 14;               /* block 14 = exhaust */

  293.     SP0COL                     = 7;                /* yellow lander */

  294.     (*(unsigned char*)0xD028)  = 8;                /* orange exhaust */

  295.     SP0X = 0; SP0Y = 251;

  296.     SPENA = 0x01;

  297.     sid_silence_all();

  298. 

  299.     while (JOY2 & JOY_PORT2_FIRE) {}    /* wait for fire press */

  300.     while (!(JOY2 & JOY_PORT2_FIRE)) {} /* wait for release */

  301. 

  302.     play_again = 1;

  303.     do {

  304.     /* ---- Game setup -------------------------------------------- */

  305.     clrscr();

  306.     bgcolor(COLOR_BLACK);

  307.     bordercolor(COLOR_BLACK);

  308.     textcolor(COLOR_WHITE);

  309. 

  310.     draw_terrain();

  311.     draw_stars();

  312. 

  313.     px    = 160 * SCALE;

  314.     py    =  55 * SCALE;

  315.     vx    = 0;

  316.     vy    = 1;              /* start with gentle downward drift */

  317.     fuel  = 200 * SCALE;

  318.     score = 0;

  319.     crashed = 0;

  320.     landed  = 0;

  321.     gravity_tick = 0;

  322. 

  323.     SPENA = 0x01;

  324.     update_sprite();

  325.     update_exhaust(0);

  326. 

  327.     /* ---- Main game loop ---------------------------------------- */

  328.     while (!crashed && !landed) {

  329.         wait_frame();

  330. 

  331.         joy       = JOY2;

  332.         thrusting = 0;

  333. 

  334.         /* Upward thrust from fire button */

  335.         if (!(joy & JOY_PORT2_FIRE) && fuel > 0) {

  336.             vy       -= 5;

  337.             fuel     -= SCALE;

  338.             thrusting = 1;

  339.             sid_thrust_on();

  340.         } else {

  341.             sid_off();

  342.         }

  343. 

  344.         /* Horizontal thrust */

  345.         if (!(joy & JOY_PORT2_LEFT) && fuel > 0) {

  346.             vx   -= 2;

  347.             fuel -= 1;

  348.         }

  349.         if (!(joy & JOY_PORT2_RIGHT) && fuel > 0) {

  350.             vx   += 2;

  351.             fuel -= 1;

  352.         }

  353.         if (fuel < 0) fuel = 0;

  354. 

  355.         /* Very gentle gravity: +1 sub-pixel every fourth frame */

  356.         gravity_tick++;

  357.         if (gravity_tick >= 4) {

  358.             gravity_tick = 0;

  359.             vy += 1;

  360.         }

  361. 

  362.         /* Light horizontal damping (simulate RCS / air drag) */

  363.         if      (vx > 0) vx--;

  364.         else if (vx < 0) vx++;

  365. 

  366.         /* Clamp velocities */

  367.         if (vy >  32) vy =  32;

  368.         if (vy < -24) vy = -24;

  369.         if (vx >  16) vx =  16;

  370.         if (vx < -16) vx = -16;

  371. 

  372.         /* Integrate position */

  373.         px += vx;

  374.         py += vy;

  375. 

  376.         /* Clamp to visible playfield (X: ~24..295 sprite pixels) */

  377.         if (px < 24 * SCALE)  { px = 24 * SCALE;  vx = -vx / 2; }

  378.         if (px > 295 * SCALE) { px = 295 * SCALE; vx = -vx / 2; }

  379. 

  380.         /* ---- Ground collision ---------------------------------- */

  381.         lsx = (int)(px / SCALE);

  382.         lsy = (int)(py / SCALE);

  383. 

  384.         /* Sprite is 21 px tall; check if bottom row reaches terrain */

  385.         if (lsy + 21 >= GROUND_Y) {

  386.             py  = (GROUND_Y - 21) * SCALE;

  387.             lsy = GROUND_Y - 21;

  388. 

  389.             /* Is lander center (X+12) over the pad? */

  390.             if ((lsx + 12) >= PAD_PIX_L && (lsx + 12) <= PAD_PIX_R) {

  391.                 /* Safe if slow enough: vy <= 8, |vx| <= 6 */

  392.                 if (vy <= 8 && vx >= -6 && vx <= 6) {

  393.                     score = 1000 - (vy / SCALE) * 40 + (fuel / SCALE);

  394.                     if (score < 0) score = 0;

  395.                     landed = 1;

  396.                 } else {

  397.                     crashed = 1;

  398.                 }

  399.             } else {

  400.                 crashed = 1;   /* missed the pad */

  401.             }

  402.         }

  403. 

  404.         /* Don't let lander go above row 1 (HUD row) */

  405.         if (py < 58 * SCALE) { py = 58 * SCALE; vy = 1; }

  406. 

  407.         update_sprite();

  408.         update_exhaust(thrusting);

  409.         draw_hud();

  410.     }

  411. 

  412.     /* ---- Game over --------------------------------------------- */

  413.     sid_off();

  414. 

  415.     if (landed) {

  416.         SPENA = 0x01;   /* keep lander visible */

  417.         textcolor(COLOR_GREEN);

  418.         center_msg("** SAFE LANDING! **", 9);

  419.         {

  420.             char buf[24];

  421.             sprintf(buf, "YOUR SCORE:  %d", score);

  422.             textcolor(COLOR_YELLOW);

  423.             center_msg(buf, 11);

  424.         }

  425.         textcolor(COLOR_WHITE);

  426.         center_msg("NICE FLYING, PILOT!", 13);

  427.     } else {

  428.         SPENA = 0x00;   /* hide sprite – it exploded */

  429.         /* Draw explosion at impact site */

  430.         {

  431.             unsigned char ex_col = (unsigned char)((px / SCALE - 24) / 8);

  432.             unsigned int  ep;

  433.             if (ex_col >= COLS) ex_col = COLS - 1;

  434.             ep = (unsigned int)(TERRAIN_ROW - 1) * COLS + ex_col;

  435.             SCREEN[ep] = 0x51;   /* '*' in PETSCII screen code */

  436.             COLRAM[ep] = 2;      /* red */

  437.         }

  438.         textcolor(COLOR_RED);

  439.         center_msg("** CRASH! **", 9);

  440.         textcolor(COLOR_WHITE);

  441.         center_msg("NO SCORE FOR YOU.", 11);

  442.     }

  443. 

  444.     textcolor(COLOR_GREEN);

  445.     center_msg("FIRE = PLAY AGAIN", 16);

  446.     textcolor(COLOR_WHITE);

  447.     center_msg("LEFT = QUIT", 17);

  448. 

  449.     while (!(JOY2 & JOY_PORT2_FIRE) || !(JOY2 & JOY_PORT2_LEFT)) {}

  450.     do {

  451.         joy = JOY2;

  452.     } while ((joy & JOY_PORT2_FIRE) && (joy & JOY_PORT2_LEFT));

  453.     play_again = !(joy & JOY_PORT2_FIRE);

  454.     while (!(JOY2 & JOY_PORT2_FIRE) || !(JOY2 & JOY_PORT2_LEFT)) {}

  455.     } while (play_again);

  456. 

  457.     /* ---- Return to BASIC --------------------------------------- */

  458.     SPENA = 0x00;

  459.     sid_silence_all();

  460.     clrscr();

  461.     bgcolor(6);     /* restore C64 default blue */

  462.     bordercolor(14);

  463. 

  464.     return 0;

  465. }

Powered by TurnKey Linux.