home *** CD-ROM | disk | FTP | other *** search
/ NetNews Usenet Archive 1992 #26 / NN_1992_26.iso / spool / comp / sources / apple2 / 6 < prev    next >
Encoding:
Text File  |  1992-11-08  |  21.6 KB  |  817 lines
  1. Path: sparky!uunet!stanford.edu!rutgers!igor.rutgers.edu!yoko.rutgers.edu!jac
  2. From: jac@yoko.rutgers.edu (Jonathan A. Chandross)
  3. Newsgroups: comp.sources.apple2
  4. Subject: v001SRC065:  Robots for HyperC
  5. Message-ID: <Nov.8.18.12.09.1992.16069@yoko.rutgers.edu>
  6. Date: 8 Nov 92 23:12:10 GMT
  7. Organization: Rutgers Univ., New Brunswick, N.J.
  8. Lines: 806
  9. Approved: jac@paul.rutgers.edu
  10.  
  11. Submitted-by: Andy Tefft (teffta@tsengr.dnet.ge.com)
  12. Posting-number: Volume 1, Source:65
  13. Archive-name: games/c/robots
  14. Architecture: ANY_2
  15. Version-number: 2.5
  16.  
  17. The object of this game is to stay alive while robots chase you.  If
  18. a robot catches you, you die.  You are given two weapons in your fight:
  19. a teleportation device and a blaster.  When two robots crash into each
  20. other they create a junk heap; junk heaps are deadly to other robots.
  21. You are allowed to move junk heaps around.  When all the robots are
  22. junk heaps, you advance to the next level.
  23.  
  24. Enjoy.
  25.  
  26. =Read.Me
  27. - 
  28. -Robots
  29. - 
  30. -The object of this game is to stay alive while robots chase you.  If
  31. -a robot catches you, you die.  You are given two weapons in your fight:
  32. -a teleportation device and a blaster.  When two robots crash into each
  33. -other they create a junk heap; junk heaps are deadly to other robots.
  34. -You are allowed to move junk heaps around.  When all the robots are
  35. -junk heaps, you advance to the next level.
  36. - 
  37. -This version of robots is based on the robots game that is usually
  38. -distributed with Unix. It is not a port, however, but written mostly
  39. -on my Apple //c under Hyperc.  This is version 2.5.  It should be 
  40. -slightly faster than previous versions in the higher levels (results
  41. -vary), and fixes the unlimited blast bug. Revision history is in robots.c.
  42. - 
  43. -Files:
  44. -    Read.Me        This file
  45. -    ccrobots    script to compile and link source files
  46. -    ladd.c        ladd() function (see robots.doc)
  47. -    lnkrobots    script to just link object files
  48. -    robots.c    HyperC source
  49. -    robots.doc    Documentation
  50. -    robots.files     list of files for linker to link
  51. -    uitostr.c    uitostr() function (see robots.doc)
  52. - 
  53. - 
  54. -Andrew Tefft
  55. -TEFFTA@tsengr.dnet.ge.com
  56. -July 1992
  57. -Version 2.5
  58. -
  59. =Manifest
  60. -Read.Me
  61. -ccrobots
  62. -ladd.c
  63. -lnkrobots
  64. -robots.c
  65. -robots.doc
  66. -robots.files
  67. -uitostr.c
  68. =ccrobots
  69. -/csys/bin/ppf -i |/ram/|/csys/hdrs/ -o $1.p $1.c
  70. -/csys/bin/hyperc -o $1.s $1.p
  71. -rm $1.p
  72. -/csys/bin/asmcp -o $1.o $1.s
  73. -rm $1.s
  74. -lnk -l |/ram/|/csys/libs/ -o robots -as &s.o robots.o ladd.o &mylib &libc
  75. -
  76. =ladd.c
  77. -/* for some reason ladd is unresolved so... */
  78. -
  79. -/* this version of ladd just adds the lsb of src to the array dest. */
  80. -
  81. -ladd(dest,src)
  82. -unsigned int dest[2],src[2];
  83. -{
  84. -int t;
  85. -t=dest[1]+src[1];
  86. -if (t < dest[1]) dest[0]++;
  87. -dest[1]=t;
  88. -}
  89. -
  90. =lnkrobots
  91. -lnk -l |/ram/|/csys/libs/ -o robots -asi robots.files
  92. =robots.c
  93. -/* robots by Andy Tefft, 6/28/92
  94. -
  95. -version 1.0: 6/28/92 (original)
  96. -version 2.0: 6/29/92 (pushable piles) (developed under unix)
  97. -version 2.1: 6/29/92 (2-move robots)  (developed under unix)
  98. -version 2.2: 6/29/92 (ported back to hyperc)
  99. -version 2.3: 6/29/92 - disable / until it works
  100. -                     - add blast command
  101. -                     - various scoring changes
  102. -version 2.4: 7/4/92  attempt to use long integer array for score
  103. -version 2.5: 7/8/92  added first & last for faster looping
  104. -*/
  105. -
  106. -#define VER "2.5"
  107. -
  108. -#include <std.h>
  109. -
  110. -#define XSIZE 79
  111. -#define YSIZE 22
  112. -#define ROBOT(x) robot_string[robot_moves[x]]
  113. -
  114. -char robot_moves[251];
  115. -char robot_x[251],robot_y[251],player_x,player_y; /* position;
  116. -                                                    x=255 means dead */
  117. -char field[XSIZE+1][YSIZE+1]; /* grid array. 0: empty
  118. -                            1 - 250: robot #
  119. -                                253: wall
  120. -                                254: pile
  121. -                                255: player  */
  122. -
  123. -char pile_x[250],pile_y[250];
  124. -
  125. -int RANDSeed=5343;
  126. -int first,last,blasts,piles,safe_teleports,score[2];
  127. -char get_cmd,rndl,robot_string[4];
  128. -
  129. -main() {
  130. -int result,number; /* number of robots */
  131. -
  132. -printf("Robots by Andy Tefft, version %s.\n",VER);
  133. -
  134. -robot_string=" #&";
  135. -
  136. -while (1) {
  137. -  putstr("Seeding random number generator now...\n");
  138. -  rs();  /* randomize rndl */
  139. -  srandom( (unsigned int) rndl); /* seed with randomized # */
  140. -
  141. -  score[0]=0,score[1]=0;
  142. -  safe_teleports=0;
  143. -  blasts=1;
  144. -
  145. - for (number=10 ;; ++safe_teleports, ++blasts, number += (number < 240) * 10){
  146. -
  147. -    init(number); /* initialize arrays to 0 */
  148. -    randomize(number); /* fill screen with n robots */
  149. -    screensetup(number);
  150. -    first=1; last=number;
  151. -    get_cmd=0;
  152. -
  153. -while (1) {
  154. -    cursor(player_y,player_x);
  155. -    result=get_player_move(number);
  156. -    if (result==2) quit();
  157. -    if (!result) if ((result=robot_move(number))) break;
  158. -}
  159. -    if (result==2) { quit(); break; } /* died */
  160. -    /* otherwise result==-1 which means end of level so continue */
  161. -}
  162. -}
  163. -}
  164. -
  165. -quit() {
  166. -char key;
  167. -    cursor(23,0);
  168. -    putstr("\nYour score was: ");
  169. -    prscore();
  170. -    putstr("\nPress q to quit, any other key to play again: ");
  171. -    key=getkey(1);
  172. -    cr();
  173. -    if (key=='q') exit(0);
  174. -}
  175. -
  176. -/*  A random number generator */
  177. -
  178. -srandom(NewSeed)
  179. -int NewSeed;
  180. -
  181. -{
  182. -RANDSeed = NewSeed;
  183. -}
  184. -
  185. -unsigned int random()
  186. -{
  187. -  RANDSeed = RANDSeed * 18627;
  188. -  if (RANDSeed < 0)
  189. -   RANDSeed += 32768;
  190. -  return RANDSeed;
  191. -}
  192. -
  193. -#define FIELD(n) field[robot_x[n]][robot_y[n]]
  194. -
  195. -/* robot_move moves the robots, creates piles, checks for dead player.
  196. -    returns: 
  197. -        0: robots & player are alive
  198. -        2: player died
  199. -       -1: all robots are dead
  200. -*/
  201. -
  202. -robot_move(number)
  203. -int number;
  204. -{
  205. -int flag,i,alive,x,n,nx,ny;
  206. -
  207. -for (n=last,flag=0,alive=1; n>=first; n--) {
  208. -  if (robot_x[n]==255) continue;
  209. -
  210. -  for(i=0; i<robot_moves[n]; i++) {
  211. -
  212. -    if (FIELD(n)==n) {
  213. -        FIELD(n) = 0;
  214. -        cursor(robot_y[n],robot_x[n]);
  215. -        putchr(' ');                 /* blank out old position */
  216. -    }
  217. -
  218. -    if (robot_x[n] > player_x) --robot_x[n];
  219. -    else if (robot_x[n] < player_x) ++robot_x[n];
  220. -    if (robot_y[n] > player_y) --robot_y[n];
  221. -    else if (robot_y[n] < player_y) ++robot_y[n];
  222. -
  223. -    nx=robot_x[n]; ny=robot_y[n];
  224. -
  225. -    cursor(ny,nx);
  226. -
  227. -    if ((x=FIELD(n)) > n) {
  228. -        if (x==255) {
  229. -            return 2; /* player just died */
  230. -        }
  231. -        addscore(number*robot_moves[n]);
  232. -        if (get_cmd=='w') addscore(number*robot_moves[n]);
  233. -
  234. -        FIELD(n) = 254; /* pile */
  235. -/*
  236. -        pile_x[++piles]=robot_x[n];
  237. -        pile_y[piles]=robot_y[n];
  238. -*/
  239. -        robot_x[n]=255; /* this robot is dead */
  240. -        if (x != 254) {
  241. -            robot_x[x] = 255; /* kill the other robot too */
  242. -            addscore(number*robot_moves[x]);
  243. -            if (get_cmd=='w') addscore(number*robot_moves[x]);
  244. -        }
  245. -        putchr('*'); /* draw pile */
  246. -        break;   /* don't try and move a dead robot */
  247. -    }
  248. -    else  {
  249. -        FIELD(n)=n;
  250. -        putchr(ROBOT(n));
  251. -        alive=0;
  252. -        if (!flag) last=n;
  253. -        flag=n;
  254. -    }
  255. -  }
  256. -  if (robot_x[n]==255) continue; /* 2-mover just died */
  257. -}
  258. -first=flag;
  259. -return (-alive);
  260. -}
  261. -
  262. -/* return values:
  263. -    0: normal move
  264. -    1: don't move robots
  265. -    2: quit
  266. -*/
  267. -
  268. -get_player_move(number)
  269. -int number;
  270. -{
  271. -char move;
  272. -int ox,oy,ox1,oy1;
  273. -
  274. -    if (!get_cmd) move = getkey();
  275. -    else move=get_cmd;
  276. -
  277. -    if (!index(" .?qtrhjklyubnw>HJKLYUBNz",move)) return 1; /* legal moves */
  278. -    if (move=='q') return 2;
  279. -
  280. -    if (move=='t' && !safe_teleports) return 1;
  281. -    if (move=='r' || move=='t') {
  282. -        field[player_x][player_y]=0;
  283. -        cursor(player_y,player_x);
  284. -        putchr(' ');
  285. -
  286. -        if (move=='r') do {
  287. -            player_x=random()%(XSIZE-1)+1;
  288. -            player_y=random()%(YSIZE-1)+1;
  289. -        } while (field[player_x][player_y]);
  290. -
  291. -        else do {
  292. -            player_x=random()%(XSIZE-1)+1;
  293. -            player_y=random()%(YSIZE-1)+1;
  294. -        } while (!safe_pos(player_x,player_y));
  295. -        if (move=='t') safe_teleports--;
  296. -
  297. -        field[player_x][player_y]=255;
  298. -        cursor(player_y,player_x);
  299. -        putchr('@');
  300. -        cursor(player_y,player_x);
  301. -    return 0;
  302. -    }
  303. -
  304. -    if (move=='.') return 0;
  305. -
  306. -    if (move=='?') {
  307. -        cursor(23,0);
  308. -        putstr("hjklyubn move, . stay, r/t rand/safe, z blast  sc: ");
  309. -        prscore();
  310. -        printf(" tele: %d bl: %d (%d)",safe_teleports,blasts,
  311. -                number/10);
  312. -        return 1; /* don't do robot move */
  313. -    }
  314. -
  315. -    if (move==' ') return print_safe();
  316. -
  317. -    if (move=='z') return blast();
  318. -
  319. -    if (move=='/') {
  320. -        screensetup(number);
  321. -        return 1;
  322. -    }
  323. -
  324. -    if (move=='w') {
  325. -        get_cmd='w'; return 0;
  326. -    }
  327. -
  328. -    else if (move=='>') {
  329. -        if (safe_pos(player_x,player_y)) {
  330. -            get_cmd='>'; return 0;
  331. -        } else {
  332. -            get_cmd=0; return 1;
  333. -        }
  334. -    }
  335. -
  336. -/* all commands previous to this point MUST contain a return! */
  337. -
  338. -    ox=player_x; oy=player_y;
  339. -    field[player_x][player_y]=0;
  340. -    cursor(player_y,player_x);
  341. -    putchr(' ');
  342. -
  343. -/* move-while-safe moves */
  344. -
  345. -    if (move=='H') {
  346. -        if (!move_if_safe(player_x-1,player_y)) return put_n_stop();
  347. -        else get_cmd='H';
  348. -    } 
  349. -    else if (move=='J') {
  350. -        if (!move_if_safe(player_x,player_y+1)) return put_n_stop();
  351. -        else get_cmd='J';
  352. -    }
  353. -    else if (move=='K') {
  354. -        if (!move_if_safe(player_x,player_y-1)) return put_n_stop();
  355. -        else get_cmd='K';
  356. -    }
  357. -    else if (move=='L') {
  358. -        if (!move_if_safe(player_x+1,player_y)) return put_n_stop();
  359. -        else get_cmd='L';
  360. -    }
  361. -    else if (move=='Y') {
  362. -        if (!move_if_safe(player_x-1,player_y-1)) return put_n_stop();
  363. -        else get_cmd='Y';
  364. -    }
  365. -    else if (move=='U') {
  366. -        if (!move_if_safe(player_x+1,player_y-1)) return put_n_stop();
  367. -        else get_cmd='U';
  368. -    }
  369. -    else if (move=='B') {
  370. -        if (!move_if_safe(player_x-1,player_y+1)) return put_n_stop();
  371. -            get_cmd='B';
  372. -    }
  373. -    else if (move=='N') {
  374. -        if (!move_if_safe(player_x+1,player_y+1)) return put_n_stop();
  375. -            get_cmd='N';
  376. -    }
  377. -
  378. -/* regular moves */
  379. -
  380. -    ox1=player_x; oy1=player_y;
  381. -
  382. -    if ((move=='h' || move=='y' || move=='b') && player_x > 1 )
  383. -         --ox1;
  384. -    if ((move=='l' || move=='n' || move=='u') && player_x < XSIZE-1)
  385. -         ++ox1;
  386. -    if ((move=='j' || move=='b' || move=='n') && player_y < YSIZE-1)
  387. -         ++oy1;
  388. -    if ((move=='k' || move=='y' || move=='u') && player_y > 1)
  389. -         --oy1;
  390. -
  391. -    if (field[ox1][oy1]==254) move_pile(ox1,oy1,ox1-player_x,oy1-player_y);
  392. -
  393. -    if (!field[ox1][oy1]) player_x=ox1,player_y=oy1;
  394. -
  395. -    field[player_x][player_y]=255;
  396. -    cursor(player_y,player_x);
  397. -
  398. -    putchr('@');
  399. -
  400. -    cursor(player_y,player_x);
  401. -
  402. -    return (ox==player_x && oy==player_y);
  403. -}
  404. -
  405. -blast() {
  406. -int i,j,x;
  407. -    if (!blasts) return 1;
  408. -    blasts--;
  409. -    for (i=-1; i<2; i++)
  410. -        for (j=-1; j<2; j++)
  411. -            if ((x=(int)field[player_x+i][player_y+j]) < 251
  412. -                && x>0) {
  413. -               cursor(player_y+j,player_x+i);
  414. -               putchr(' ');
  415. -               field[player_x+i][player_y+j]=0;
  416. -               robot_x[x]=255;
  417. -            }
  418. -    return 0;
  419. -}
  420. -
  421. -
  422. -/* move_if_safe(x,y) updates player_x and player_y to x,y if x,y is
  423. -    a safe position. It does not update field[][]. Returns 1 if moved. */
  424. -
  425. -move_if_safe(x,y) 
  426. -int x,y;
  427. -{
  428. -  if (safe_pos(x,y)) {
  429. -      player_x=x,player_y=y;
  430. -      return 1;
  431. -  } else return 0;
  432. -}
  433. -
  434. -
  435. -/* put_n_stop() can be used anytime it is needed to draw the player
  436. -    and update the field[][] array with his position. */
  437. -
  438. -put_n_stop() {
  439. -    get_cmd=0;
  440. -    cursor(player_y,player_x);
  441. -    putchr('@');
  442. -    field[player_x][player_y]=255;
  443. -    return 1;
  444. -}
  445. -
  446. -/* move_pile moves pile from (x,y) to (x+dx,y+dy) if possible. returns 1
  447. -    if successful */
  448. -
  449. -move_pile(x,y,dx,dy) 
  450. -int x,y,dx,dy;
  451. -{
  452. -if (field[x+dx][y+dy]) return 0;
  453. -field[x][y]=0;
  454. -field[x+dx][y+dy]=254;
  455. -cursor(y,x);
  456. -putchr(' ');
  457. -cursor(y+dy,x+dx);
  458. -putchr('*');
  459. -return 1;
  460. -}
  461. -
  462. -/* safe_pos checks to see if pos (x,y) would be safe to go to. returns 1
  463. -    unless:
  464. -
  465. -    - wall or pile is there
  466. -    - robot would move there if player moved there
  467. -*/
  468. -
  469. -safe_pos(x,y)
  470. -int x,y;
  471. -{
  472. -int i,j;
  473. -
  474. -    if (field[x][y]) if (field[x][y] != 255) return 0;
  475. -    for (i=-2; i<3; i++)
  476. -        for (j=-2; j<3; j++) {
  477. -           if (x+i<0 || x+i>XSIZE || y+j<0 || y+j>YSIZE) continue;
  478. -           if (field[x+i][y+j]) if (field[x+i][y+j] < 251) {
  479. -              if (abs(i)<2 && abs(j)<2) return 0;
  480. -              if (robot_moves[field[x+i][y+j]] == 2 &&
  481. -                 field[x+i/2][y+j/2] != 253) return 0;
  482. -            }
  483. -    }
  484. -    return 1;
  485. -}
  486. -
  487. -init(number) 
  488. -int number; 
  489. -{
  490. -int x,y;
  491. -
  492. -page();
  493. -printf("initializing...\n");
  494. -
  495. -piles=0;
  496. -for (x=0; x<XSIZE; x++)
  497. -    for (y=0; y<YSIZE; y++)
  498. -        field[x][y]=0;
  499. -
  500. -}
  501. -
  502. -randomize(number) 
  503. -int number;
  504. -{
  505. -int i,x,y;
  506. -putstr("Randomizing...\n");
  507. -for (i=1; i<=number; i++) {
  508. -    do {
  509. -        x=random()%(XSIZE-1)+1;
  510. -        y=random()%(YSIZE-1)+1;
  511. -        }
  512. -    while (field[x][y]!=0);
  513. -
  514. -    robot_x[i]=x; robot_y[i]=y;
  515. -    field[x][y]=i;
  516. -
  517. -    if (random()%10==2) robot_moves[i]=2;
  518. -    else robot_moves[i]=1;
  519. -}
  520. -
  521. -    do {
  522. -        x=random()%(XSIZE-1)+1;
  523. -        y=random()%(YSIZE-1)+1;
  524. -        }
  525. -    while (field[x][y]!=0);
  526. -
  527. -    player_x=x; player_y=y;
  528. -    field[x][y]=255;
  529. -}
  530. -
  531. -screensetup(n)
  532. -int n;
  533. -{
  534. -int i;
  535. -
  536. -page();
  537. -
  538. -for (i=0; i<= XSIZE; i++) { putchr('-'); field[i][0]=253; }
  539. -cursor(YSIZE,0);
  540. -for (i=0; i<= XSIZE; i++) { putchr('-'); field[i][YSIZE]=253; }
  541. -
  542. -for (i=1; i<YSIZE; i++) {
  543. -    cursor(i,0);
  544. -    putchr('|');
  545. -    cursor(i,XSIZE);
  546. -    putchr('|');
  547. -    field[0][i]=253;
  548. -    field[XSIZE][i]=253;
  549. -}
  550. -
  551. -for (i=1; i<=n; i++) {
  552. -    cursor(robot_y[i],robot_x[i]);
  553. -    putchr(ROBOT(i));
  554. -}
  555. -
  556. -for (i=0; i<piles; i++) {
  557. -    cursor(pile_y[i],pile_x[i]);
  558. -    putchr('*');
  559. -}
  560. -
  561. -cursor(player_y,player_x);
  562. -putchr('@');
  563. -
  564. -}
  565. -
  566. -/* rs waits for a keypress, scrambling rndl until pressed. This seeds
  567. -    the random number generator. */
  568. -
  569. -rs() {
  570. -printf("Press a key to begin...");
  571. -while (!keypress()) ++rndl;
  572. -return 0;
  573. -}
  574. -
  575. -/* print_safe() is a kludge to print out the safe moves. */
  576. -
  577. -print_safe() {
  578. -cursor(23,0);
  579. -
  580. -clreol();
  581. -
  582. -if (safe_pos(player_x-1,player_y)) putchr('h');
  583. -if (safe_pos(player_x,player_y-1)) putchr('k');
  584. -if (safe_pos(player_x,player_y+1)) putchr('j');
  585. -if (safe_pos(player_x+1,player_y)) putchr('l');
  586. -if (safe_pos(player_x-1,player_y-1)) putchr('y');
  587. -if (safe_pos(player_x+1,player_y-1)) putchr('u');
  588. -if (safe_pos(player_x-1,player_y+1)) putchr('b');
  589. -if (safe_pos(player_x+1,player_y+1)) putchr('n');
  590. -if (safe_pos(player_x,player_y)) putchr('.');
  591. -
  592. -return 1;
  593. -}
  594. -
  595. -/* addscore adds int i to score[2] */
  596. -
  597. -addscore(i)
  598. -int i;
  599. -{
  600. -int i2[2];
  601. -
  602. -i2[0]=0;
  603. -i2[1]=i;
  604. -
  605. -ladd(score,i2);
  606. -}
  607. -
  608. -/* prscore prints the score in ascii */
  609. -
  610. -prscore() {
  611. -char scorestr[9];
  612. -
  613. -uitostr2(scorestr,score);
  614. -putstr(scorestr);
  615. -}
  616. -
  617. =robots.doc
  618. -This version of robots is based on the robots game that is usually
  619. -distributed with Unix. It is not a port however, but written mostly on
  620. -my Apple //c under Hyperc. The SYS file version was created with the
  621. -use of Gary Desrochers and Andy Werner's 'makesys' programs.
  622. -
  623. -The object of the game is to stay alive while robots chase after you.
  624. -These robots are evil in that they will kill you if they catch you. However,
  625. -they are also stupid, and tend to crash into each other.
  626. -
  627. -You are given two weapons in your fight. One is a teleportation device.
  628. -You are allowed unlimited random teleports (which can drop you right into
  629. -danger), and a limited number of 'guaranteed safe' teleports. You also
  630. -have a blaster which has limited uses; it destroys all robots adjacent
  631. -to you but does not stop the rest from advancing.
  632. -
  633. -When two robots crash into each other, they create a junk heap and you
  634. -get points. Robots which run into junk heaps are also destroyed, giving you
  635. -more points. If a robot runs into you, you die and the game ends. You cannot
  636. -run into junk heaps or the screen borders. You can push a junk heap in any
  637. -direction as long as there is a blank space to move it into.
  638. -
  639. -When all the robots are junk heaps, you advance to the next level.
  640. -You gain one safe teleportation and one blast, and the next level contains 
  641. -more robots (up to a maximum of 250). (if all the robots are dead but you
  642. -have not advanced to the next level, press any movement key.)
  643. -
  644. -You are represented on the screen by an inverse '@'. Robots are '#' and
  645. -'&'; the latter move twice as fast as the former. Junk heaps are '*'. Borders
  646. -are obvious.
  647. -
  648. -Keys are as follows (and are the same as vi cursor-motion keys):
  649. -
  650. -             y   k   u    >: wait as long as it's safe
  651. -               \ | /      w: wait until level is cleared or you die
  652. -             h -   - l    .: wait one move
  653. -               / | \
  654. -             b   j   n
  655. -
  656. -YUHJKLBN: run in that direction as long as it's safe
  657. -?: show brief help, # of safe teleports (te:), # of blasts (bl:), score (sc:),
  658. -   and level
  659. -z: blast (or think of it as zap)
  660. -<space>: show safe moves
  661. -q: quit
  662. -
  663. -Scoring: each '#' robot is worth 10 points times the level number. '&' robots
  664. -are worth double. Each dead robot after you press 'w' is worth double its
  665. -usual value. Robots that you blast are worth 0.
  666. -
  667. ------------------------------------------------------------------------
  668. -planned future enhancements:
  669. -
  670. -- high score list
  671. -- ability to skip lower levels
  672. -
  673. ------------------------------------------------------------------------
  674. -The files:
  675. -
  676. -robots.doc: this file
  677. -robots:     hyperc executable
  678. -robots.c:   hyperc source
  679. -robots.system: prodos SYS file
  680. -ladd.c:     the ladd() function (see below)
  681. -uitostr.c:  the uitostr() function (see below)
  682. -ladd.o, uitostr.o
  683. -robots.files: list of files to link; use -i option with the linker
  684. -lnkrobots: the link command in a script
  685. -
  686. -Please send me any bug reports or enhancements (I'm particularly looking
  687. -for speed improvements and a better random-number generator).
  688. -
  689. -Andy Tefft
  690. -teffta@tsengr.dnet.ge.com
  691. -6/30/90
  692. -------------------------------------------------------------------------
  693. -Version 2.4 (7/4/92):
  694. -
  695. -You only need read this section if you plan on compiling the program.
  696. -You can play robots without compiling the program. You would only need
  697. -to recompile it if you make changes.
  698. -
  699. -So that the score doesn't "roll over" at 65536, I now use a two-integer
  700. -array to store the score. At this time I have decided to start splitting
  701. -up the source because it is taking a long time to compile. Therefore
  702. -this distribution contains two extra files: uitostr.[c,o] and ladd.[c,o].
  703. -
  704. -To compile robots, you now must follow these steps:
  705. -
  706. -1) cc ladd, if ladd.o does not exist (the 'lnk' command will fail,
  707. -    but we just need the ladd.o file anyway)
  708. -2) cc uitostr, if uitostr.o does not exist
  709. -
  710. -(note: I have included uitostr.o and ladd.o in the distribution so
  711. -you don't have to compile them again unless you change them)
  712. -
  713. -3) cc robots
  714. -4) do 'lnkrobots' or else type in the lnk command yourself.
  715. -
  716. -Note that you only have to cc the files you change; keep the .o files
  717. -around so that you can just redo 'lnkrobots' after you change & cc
  718. -one or more of the source files.
  719. -
  720. -note on ladd:
  721. -
  722. -ladd(ldest,lsrc) is listed in the hyperc manual. lib /csys/libs/libc shows
  723. -ladd.o. But I kept getting _ladd: unresolved when I linked the program,
  724. -so I wrote my own ladd() function. IMPORTANT: it does *not* add the
  725. -most significant int of the arrays, even though it takes two arrays
  726. -as arguments. I only needed to add an int to a 2-byte int array so that's
  727. -all I made it do, although I made the calling interface the same as
  728. -what the manual specifies.
  729. -
  730. -What this means to you is that if something is screwed up in my copy
  731. -of hyperc, and your copy of hyperc includes ladd like it should, you
  732. -will get a duplicate reference when you link it. If this should happen,
  733. -just remove ladd.o from the 'robots.files' file which is used by the link
  734. -command, and re-link. It should work. 
  735. -
  736. -note on uitostr:
  737. -
  738. -It is ugly. If you have a better way to do it, send it to me! If you don't,
  739. -and you want to use uitostr, feel free, and keep these things in mind:
  740. -
  741. -1) uitostr(str,i) converts the integer i[2] to the string str. i[0]
  742. -    is the *least* significant 16 bits of i.
  743. -2) uitostr2(str,i) expects i[0] to be the *most* significant bits of i.
  744. -3) i must be positive; it is actually treated as an unsigned int by
  745. -    the function. If you want to print a negative number, figure out
  746. -    how to take its absolute value, and print a - yourself.
  747. -4) str must be declared with size of at least 9 -- up to 8 digits
  748. -    plus a trailing null. No checks are made on this size and the function
  749. -    will be more than happy to tromp on other variables if you declare
  750. -    the string too small.
  751. -5) the string returned is right-justified. to print it without the leading
  752. -    spaces, you can do something like this:
  753. -
  754. -    putstr(rindex(str,' ')+1);
  755. -
  756. -    (rindex will return a pointer to the last ' ' character in the string).
  757. -
  758. -
  759. =robots.files
  760. -&s.o
  761. -robots.o
  762. -uitostr.o
  763. -ladd.o
  764. -&libc
  765. =uitostr.c
  766. -/* uitostr.c:
  767. -
  768. -    prints a two-byte unsigned int in ascii.
  769. -    uitostr(buf,i) assumes i[2] with i[0]=least significant;
  770. -    uitostr2(buf,i) assumes i[0] is most significant
  771. -
  772. -    note: uitostr destroys i; uitostr2 does not.
  773. -*/
  774. -
  775. -
  776. -#include <std.h>
  777. -
  778. -__twodiv(i) /* divides i by 10 and leaves the result in i */
  779. -unsigned int i[2]; /* i[0] is lsb */
  780. -{
  781. -i[0]=(i[0]/10)+6553*(i[1]%10)+(i[0]%10+6*(i[1]%10))/10;
  782. -i[1]=i[1]/10;
  783. -}
  784. -
  785. -__mod10(i) /* returns i%10 */
  786. -unsigned int i[2];
  787. -{
  788. -return (i[0]%10+(6*i[1])%10)%10;
  789. -}
  790. -
  791. -uitostr(buf,i)
  792. -char buf[9]; /* room for 8 chars */
  793. -unsigned int i[2];
  794. -{
  795. -int j;
  796. -for(j=7; j>=0; j--) {
  797. -    if (!(i[1]|i[0])) buf[j]=' ';
  798. -    else buf[j]=__mod10(i)+'0';
  799. -    __twodiv(i);
  800. -}
  801. -buf[8]=0;
  802. -if (buf[7]==' ') buf[7]='0';
  803. -return;
  804. -}
  805. -
  806. -uitostr2(buf,i)
  807. -char buf[9];
  808. -unsigned int i[2];
  809. -{
  810. -unsigned int j[2];
  811. -j[0]=i[1];
  812. -j[1]=i[0];
  813. -uitostr(buf,j);
  814. -}
  815. -
  816. + END OF ARCHIVE
  817.