6　外星人游戏（harib26e）

接下来，我们打算做一个跟OSASK上面的外星人游戏差不多的游戏。在看这本书的各位读者估计也不知道OSASK的外星人游戏到底是何方神圣，那么我们先从背景故事开始讲起吧（笑）。顺便说一句，这个故事不是之前就设定好的，而是笔者在这里现编的。

20XX年，从遥远的宇宙另一端飞来一群外星侵略者，它们不用穿太空服就能在宇宙中生存。它们也没有发达的文明，一直就这样在宇宙中四处漂泊。

虽然并没有恶意，但它们身上感染了一种凶恶的病毒，人类目前的科学水平还无法应付（它们自己虽然感染了病毒，但这种病毒对它们的健康无害），如果它们来到地球，包括人类在内的大多数地球生命都会遭到毁灭性的打击。

人类曾经尝试说服这些外星人，但是他们的语言能力不佳，根本就无法沟通。科学家们经过讨论，认为只好将它们击退。虽然做法有些残酷，但如果它们看到同伴受到攻击全都牺牲了，它们似乎就会做出“看来这里不适合我们居住”的判断。

时间紧迫，只争朝夕。就在人类商讨对策之时，它们已经来到地球了。没办法，只好抄起手边的等离子炮，将它们连同病毒一起消灭掉。

游戏的操作方法是这样的，按小键盘上的“4”和“6”键移动自机的位置，按空格键发射等离子炮。等离子炮每发射一次，必须进行一段时间的充电（或者是加热?）才能重新发射（其实这个时间也不是很长），因此不能连续发射。笔者也没见过真的等离子炮是什么样的（笑），不过我们的等离子炮炮弹飞行的速度慢到可以用肉眼看见，反正不是像光线那样飞快就是了，发射的时候还是要瞄准好哟。

消灭外星人会得到奖金（得分），命中率越高（打空的次数少）的话得到的奖金越多。因为这个等离子炮需要消费大量的电力，如果老是打不中而白白浪费的话，咱们国家的电力就会不够用啦。为了鼓励炮击手节约弹药，我们才设定了这样一个奖励的规定。

为了地球的和平，希望大家英勇奋战！

补充：当初估计它们只有30只来到了地球，但现在看来还有后续部队。另有不确定的情报表示，后续部队的移动速度很快……消灭它们吧！

我们来编写程序吧，这次比较长哦。

invader.c

  1. #include <stdio.h>      /* sprintf */
  2. #include <string.h>     /* strlen */
  3. #include "apilib.h"
  5. void putstr(int win, char *winbuf, int x, int y, int col, unsigned char *s);
  6. void wait(int i, int timer, char *keyflag);
  8. static unsigned char charset[16 * 8] = {
  10.     /* invader(0) */
  11.     0x00, 0x00, 0x00, 0x43, 0x5f, 0x5f, 0x5f, 0x7f,
  12.     0x1f, 0x1f, 0x1f, 0x1f, 0x00, 0x20, 0x3f, 0x00,
  14.     /* invader(1) */
  15.     0x00, 0x0f, 0x7f, 0xff, 0xcf, 0xcf, 0xcf, 0xff,
  16.     0xff, 0xe0, 0xff, 0xff, 0xc0, 0xc0, 0xc0, 0x00,
  18.     /* invader(2) */
  19.     0x00, 0xf0, 0xfe, 0xff, 0xf3, 0xf3, 0xf3, 0xff,
  20.     0xff, 0x07, 0xff, 0xff, 0x03, 0x03, 0x03, 0x00,
  22.     /* invader(3) */
  23.     0x00, 0x00, 0x00, 0xc2, 0xfa, 0xfa, 0xfa, 0xfe,
  24.     0xf8, 0xf8, 0xf8, 0xf8, 0x00, 0x04, 0xfc, 0x00,
  26.     /* fighter(0) */
  27.     0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
  28.     0x01, 0x43, 0x47, 0x4f, 0x5f, 0x7f, 0x7f, 0x00,
  30.     /* fighter(1) */
  31.     0x18, 0x7e, 0xff, 0xc3, 0xc3, 0xc3, 0xc3, 0xff,
  32.     0xff, 0xff, 0xe7, 0xe7, 0xe7, 0xe7, 0xff, 0x00,
  34.     /* fighter(2) */
  35.     0x00, 0x00, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
  36.     0x80, 0xc2, 0xe2, 0xf2, 0xfa, 0xfe, 0xfe, 0x00,
  38.     /* laser */
  39.     0x00, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
  40.     0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00
  41. };
  42. /* invader:"abcd", fighter:"efg", laser:"h" */
  44. void HariMain(void)
  45. {
  46.     int win, timer, i, j, fx, laserwait, lx = 0, ly;
  47.     int ix, iy, movewait0, movewait, idir;
  48.     int invline, score, high, point;
  49.     char winbuf[336 * 261], invstr[32 * 6], s[12], keyflag[4], *p;
  50.     static char invstr0[32] = " abcd abcd abcd abcd abcd ";
  52.     win = api_openwin(winbuf, 336, 261, -1, "invader");
  53.     api_boxfilwin(win, 6, 27, 329, 254, 0);
  54.     timer = api_alloctimer();
  55.     api_inittimer(timer, 128);
  57.     high = 0;
  58.     putstr(win, winbuf, 22, 0, 7, "HIGH:00000000");
  60. restart:
  61.     score = 0;
  62.     point = 1;
  63.     putstr(win, winbuf,  4, 0, 7, "SCORE:00000000");
  64.     movewait0 = 20;
  65.     fx = 18;
  66.     putstr(win, winbuf, fx, 13, 6, "efg");
  67.     wait(100, timer, keyflag);
  69. next_group:
  70.     wait(100, timer, keyflag);
  71.     ix = 7;
  72.     iy = 1;
  73.     invline = 6;
  74.     for (i = 0; i < 6; i++) {
  75.         for (j = 0; j < 27; j++) {
  76.             invstr[i * 32 + j] = invstr0[j];
  77.         }
  78.         putstr(win, winbuf, ix, iy + i, 2, invstr + i * 32);
  79.     }
  80.     keyflag[0] = 0;
  81.     keyflag[1] = 0;
  82.     keyflag[2] = 0;
  84.     ly = 0; /*不显示*/
  85.     laserwait = 0;
  86.     movewait = movewait0;
  87.     idir = +1;
  88.     wait(100, timer, keyflag);
  90.     for (;;) {
  91.         if (laserwait != 0) {
  92.             laserwait--;
  93.             keyflag[2 /* space */] = 0;
  94.         }
  96.         wait(4, timer, keyflag);
  98.         /*自机的处理*/
  99.         if (keyflag[0 /* left */]  != 0 && fx > 0) {
  100.             fx--;
  101.             putstr(win, winbuf, fx, 13, 6, "efg ");
  102.             keyflag[0 /* left */]  = 0;
  103.         }
  104.         if (keyflag[1 /* right */] != 0 && fx < 37) {
  105.             putstr(win, winbuf, fx, 13, 6, " efg");
  106.             fx++;
  107.             keyflag[1 /* right */] = 0;
  108.         }
  109.         if (keyflag[2 /* space */] != 0 && laserwait == 0) {
  111.             laserwait = 15;
  112.             lx = fx + 1;
  113.             ly = 13;
  114.         }
  116.         /*外星人移动*/
  117.         if (movewait != 0) {
  118.             movewait--;
  119.         } else {
  120.             movewait = movewait0;
  121.             if (ix + idir > 14 || ix + idir < 0) {
  122.                 if (iy + invline == 13) {
  123.                     break; /* GAME OVER */
  124.                 }
  125.                 idir = - idir;
  126.                 putstr(win, winbuf, ix + 1, iy, 0, "                         ");
  127.                 iy++;
  128.             } else {
  129.                 ix += idir;
  130.             }
  131.             for (i = 0; i < invline; i++) {
  132.                 putstr(win, winbuf, ix, iy + i, 2, invstr + i * 32);
  133.             }
  134.         }
  136.         /*炮弹处理*/
  137.         if (ly > 0) {
  138.             if (ly < 13) {
  139.                 if (ix < lx && lx < ix + 25 && iy <= ly && ly < iy + invline) {
  140.                     putstr(win, winbuf, ix, ly, 2, invstr + (ly - iy) * 32);
  141.                 } else {
  142.                     putstr(win, winbuf, lx, ly, 0, " ");
  143.                 }
  144.             }
  145.             ly--;
  146.             if (ly > 0) {
  147.                 putstr(win, winbuf, lx, ly, 3, "h");
  148.             } else {
  149.                 point -= 10;
  150.                 if (point <= 0) {
  151.                     point = 1;
  152.                 }
  153.             }
  154.             if (ix < lx && lx < ix + 25 && iy <= ly && ly < iy + invline) {
  155.                 p = invstr + (ly - iy) * 32 + (lx - ix);
  156.                 if (*p != ' ') {
  157.                     /* hit ! */
  158.                     score += point;
  159.                     point++;
  160.                     sprintf(s, "%08d", score);
  161.                     putstr(win, winbuf, 10, 0, 7, s);
  162.                     if (high < score) {
  163.                         high = score;
  164.                         putstr(win, winbuf, 27, 0, 7, s);
  165.                     }
  166.                     for (p--; *p != ' '; p--) { }
  167.                     for (i = 1; i < 5; i++) {
  168.                         p[i] = ' ';
  169.                     }
  170.                     putstr(win, winbuf, ix, ly, 2, invstr + (ly - iy) * 32);
  171.                     for (; invline > 0; invline--) {
  172.                         for (p = invstr + (invline - 1) * 32; *p != 0; p++) {
  173.                             if (*p != ' ') {
  174.                                 goto alive;
  175.                             }
  176.                         }
  177.                     }
  178.                     /*全部消灭*/
  179.                     movewait0 -= movewait0 / 3;
  180.                     goto next_group;
  181.     alive:
  182.                     ly = 0;
  184.                 }
  185.             }
  186.         }
  187.     }
  189.     /* GAME OVER */
  190.     putstr(win, winbuf, 15, 6, 1, "GAME OVER");
  191.     wait(0, timer, keyflag);
  192.     for (i = 1; i < 14; i++) {
  193.         putstr(win, winbuf, 0, i, 0, "                                        ");
  194.     }
  195.     goto restart;
  196. }
  198. void putstr(int win, char *winbuf, int x, int y, int col, unsigned char *s)
  199. {
  200.     int c, x0, i;
  201.     char *p, *q, t[2];
  202.     x = x * 8 + 8;
  203.     y = y * 16 + 29;
  204.     x0 = x;
  205.     i = strlen(s);  /*计算s的字符数*/
  206.     api_boxfilwin(win + 1, x, y, x + i * 8 - 1, y + 15, 0);
  207.     q = winbuf + y * 336;
  208.     t[1] = 0;
  209.     for (;;) {
  210.         c = *s;
  211.         if (c == 0) {
  212.             break;
  213.         }
  214.         if (c != ' ') {
  215.             if ('a' <= c && c <= 'h') {
  216.                 p = charset + 16 * (c - 'a');
  217.                 q += x;
  218.                 for (i = 0; i < 16; i++) {
  219.                     if ((p[i] & 0x80) != 0) { q[0] = col; }
  220.                     if ((p[i] & 0x40) != 0) { q[1] = col; }
  221.                     if ((p[i] & 0x20) != 0) { q[2] = col; }
  222.                     if ((p[i] & 0x10) != 0) { q[3] = col; }
  223.                     if ((p[i] & 0x08) != 0) { q[4] = col; }
  224.                     if ((p[i] & 0x04) != 0) { q[5] = col; }
  225.                     if ((p[i] & 0x02) != 0) { q[6] = col; }
  226.                     if ((p[i] & 0x01) != 0) { q[7] = col; }
  227.                     q += 336;
  228.                 }
  229.                 q -= 336 * 16 + x;
  230.             } else {
  231.                 t[0] = *s;
  232.                 api_putstrwin(win + 1, x, y, col, 1, t);
  233.             }
  234.         }
  235.         s++;
  236.         x += 8;
  237.     }
  238.     api_refreshwin(win, x0, y, x, y + 16);
  239.     return;
  240. }
  242. void wait(int i, int timer, char *keyflag)
  243. {
  244.     int j;
  245.     if (i > 0) {
  246.         /*等待一段时间*/
  247.         api_settimer(timer, i);
  248.         i = 128;
  249.     } else {
  250.         i = 0x0a; /* Enter */
  251.     }
  252.     for (;;) {
  253.         j = api_getkey(1);
  254.         if (i == j) {
  255.             break;
  257.         }
  258.         if (j == '4') {
  259.             keyflag[0 /* left */]  = 1;
  260.         }
  261.         if (j == '6') {
  262.             keyflag[1 /* right */] = 1;
  263.         }
  264.         if (j == ' ') {
  265.             keyflag[2 /* space */] = 1;
  266.         }
  267.     }
  268.     return;
  269. }

由于这不是操作系统，而只是一个应用程序。这本书也不是讲如何编写外星人游戏的，而是讲如何编写操作系统的（笑），因此对于程序的讲解我们就速战速决吧。

putstr函数用来显示字符串，不过a～h的字符不是直接显示，而是用charset的字库来显示的，为提高显示速度，使用了api_refreshwin。

wait函数用来延时并等待按键输入。当i指定为0时等待回车键的输入，否则按照“指定的时间×0.01秒”为基准进行延时等待，在等待期间如果有按键输入则反映到keyflag[0～2]中。

HariMain则是处理游戏的主体，里面有很多变量，这里介绍一些比较难懂的。

fx：自机的x坐标（fighter_x）

lx, ly：等离子炮弹的坐标（laser_x, laser_y）1

ix, iy：外星人群的坐标（invaders_x, invaders_y）

idir：外星人群的移动方向（invaders_direction）

laserwait：等离子炮弹的剩余充电时间

movewait：当这个变量变为0时外星人群前进一步

movewait0：movewait的初始值（消灭30只敌人后减少）

invline：外星人群的行数（invaders_line）

score：当前得分

high：最高得分

point：得分的增加量（奖金的单价？）

invstr：将外星人群的状态显示为字符串的变量

1 一开始本来管自机发射的炮弹叫“激光”，不过激光居然飞得这么慢实在太诡异了（笑），于是在编故事的时候改成等离子炮弹了。

对了，在这个游戏中，当外星人到达最底下一行时就Game Over了，这时按下回车键可以重新开始。对于这个程序我们没有设定正常的结束方法，大家可以按Shift+F1或者点击“×”按钮强制结束。

■■■■■

好了，我们来“make run”。静下心来，为了保卫地球的明天，加油！

6　外星人游戏（harib26e） - 图1 6　外星人游戏（harib26e） - 图2
战斗开始 呜哇！

漫长的战斗之后（话说也就是几分钟吧）……终于挂了！

地球完蛋了！……这样可不行，要是人生能重新来过就好了（太夸张了）。其实按下回车键就可以了哦，胜败乃兵家常事，大侠请重新来过（笑）。

我们再来重新看看程序吧。make之后生成的invader.hrb大小为2335字节，也就是说，“纸娃娃系统”所具备的API使得这样一个游戏仅用2.28KB就可以写出来。和其他操作系统相比，这并不能算是非常好，不过笔者还是感到挺自豪的。

今天就到这里吧，明天我们继续来编写应用程序哦！