home *** CD-ROM | disk | FTP | other *** search
/ rtsi.com / 2014.01.www.rtsi.com.tar / www.rtsi.com / OS9 / OSK / EFFO / forum7.lzh / C / HINTERHALT / hinterhalt.c < prev    next >
Text File  |  2009-11-06  |  10KB  |  274 lines
  1. /*****************************************************************************/
  2. /*      M O D U L :      HINTERHALT.C                                        */
  3. /*****************************************************************************/
  4. /*                                                                           */
  5. /*  Programmname: Hinterhalt                   erstellt am: 17.09.88         */
  6. /* Programmierer: Frank BrΣuer                                               */
  7. /*                Bruckner Str. 8                                            */
  8. /*                7080 Aalen                                                 */
  9. /*                                                                           */
  10. /* Programmbeschreibung:                                                     */
  11. /*   Ein Spiel, bei dem Sie sich einen Weg an vom Computer aufgestellten     */
  12. /*   Hindernissen vorbei suchen mⁿssen. Je mehr Schritte Sie schaffen, desto */
  13. /*   besser.                                                                 */
  14. /*                                                                           */
  15. /* Eingabefile(s):                                                           */
  16. /*   stdin                                                                   */
  17. /*                                                                           */
  18. /* Ausgabefile(s):                                                           */
  19. /*   stdout                                                                  */
  20. /*                                                                           */
  21. /*****************************************************************************/
  22. #include <stdio.h>
  23. #include <scrstuff.h>
  24.  
  25. #define PLAYER '*'
  26. #define OBSTACLE ' '
  27. #define XSTART 39
  28. #define YSTART 8
  29. #define FMAXX 79
  30. #define FMAXY 23
  31. #define LEFT '4'
  32. #define RIGHT '6'
  33. #define UP '8'
  34. #define DOWN '2'
  35. #define TRUE 1
  36. #define FALSE 0
  37.  
  38. unsigned short field [80][24], move, plposx, plposy, obstposx, obstposy;
  39.  
  40. main ()
  41. {
  42.     char c;
  43.     
  44.     stdin -> _flag |= _UNBUF;                       /* ungepufferte Eingabe  */
  45.     set_up ("TERM");                                /* initial. Terminal     */
  46.     randomize ();                                   /* initial. Zufallsreihe */
  47.     clscr ();                                       /* Bildschirm l÷schen    */
  48.     gotoXY (34, 0);                                 /* Cursor positionieren  */
  49.     sout_on ();                                     /* Inverse an            */
  50.     printf ("HINTERHALT\n");
  51.     sout_off ();                                    /* Inverse aus           */
  52.     do {
  53.         gotoXY (0, 3);
  54.         printf ("Brauchen Sie eine Anleitung (J/N)?\n");
  55.         c = getc (stdin);                           /* Antwort von Tastatur  */
  56.     } while (c != 'J' && c != 'j' && c != 'N' && c != 'n');
  57.     if (c == 'J' || c == 'j') anleitung ();
  58.     do {
  59.         move = 0;
  60.         initfield ();
  61.         showfield ();
  62.         do {
  63.             moveplayer ();
  64.             if (field [plposx][plposy]) setobstacle ();
  65.         } while (field [plposx][plposy]);
  66.         bewertung ();
  67.         do {
  68.             gotoXY (10, 20);
  69.             printf ("Noch ein Spiel (J/N)?\n");
  70.             c = getc (stdin);
  71.         } while (c != 'J' && c != 'j' && c != 'N' && c != 'n');
  72.     } while (c == 'J' || c == 'j');
  73.     clscr ();
  74. }
  75.  
  76. anleitung ()                                        /* gibt Anleitung auf    */ 
  77. {                                                   /* Bildschirm aus        */
  78.     char c;
  79.     
  80.     gotoXY (0, 3);
  81.     printf ("Sie befinden sich auf einem eingezΣunten Spielfeld. ");
  82.     printf ("Ihre Position wird mit\n");
  83.     printf ("einem '*' markiert. Sie k÷nnen sich in alle vier ");
  84.     printf ("Himmelsrichtungen bewegen.\n");
  85.     printf ("Benutzen Sie dazu im Ziffernblock die Tasten '8' fⁿr ");
  86.     printf ("aufwΣrts, '2' fⁿr abwΣrts,\n");
  87.     printf ("'4' fⁿr links und '6' fⁿr rechts.\n");
  88.     down ();                                        /* Cursor 1 Zeile tiefer */
  89.     printf ("Der Computer wird versuchen Sie am VorwΣrtskommen ");
  90.     printf ("zu hindern, indem er Ihren\n");
  91.     printf ("Weg verbaut. Die Hindernisse werden mit '\n");
  92.     gotoXY (41, 9),
  93.     sout_on ();
  94.     printf (" \n");
  95.     sout_off ();
  96.     gotoXY (42, 9);
  97.     printf ("' dargestellt und dⁿrfen nicht\n");
  98.     printf ("berⁿhrt werden.\n");
  99.     down ();
  100.     printf ("Wenn Sie sich nicht mehr bewegen k÷nnen, ist das ");
  101.     printf ("Spiel zu Ende.\n");
  102.     printf ("Ich wⁿnsche Ihnen viel Vergnⁿgen.\n");
  103.     gotoXY (5, 22);
  104.     sout_on ();
  105.     printf ("Bitte Taste drⁿcken!\n");
  106.     sout_off ();
  107.     gotoXY (26, 22);
  108.     c = getc (stdin);
  109. }
  110.  
  111. initfield ()                                        /* Spielfeld initialisie-*/
  112. {                                                   /* ren                   */
  113.     unsigned short i, j;
  114.     
  115.     for (i = 0; i < FMAXX; i++)                     /* alle Felder auf TRUE  */
  116.         for (j = 0; j < FMAXY; j++) field [i][j] = TRUE;
  117.     for (i = 0; i < FMAXX; i++) {                   /* Rand oben u. unten auf*/
  118.         field [i][0] = FALSE;                       /* FALSE setzen          */
  119.         field [i][FMAXY - 1] = FALSE;
  120.     }
  121.     for (i = 0; i < FMAXY; i++) {                   /* Rand links u. rechts  */
  122.         field [0][i] = FALSE;                       /* auf FALSE setzen      */
  123.         field [FMAXX - 1][i] = FALSE;
  124.     }
  125.     plposx = XSTART - 1;                            /* Spieler in Startposi- */
  126.     plposy = YSTART - 1;                            /* tion                  */
  127.     obstposx = 1;                                   /* Hindernis in Start-   */
  128.     obstposy = 1;                                   /* position              */
  129. }
  130.  
  131. showfield ()                                        /* Spielfeld anzeigen    */
  132. {
  133.     unsigned short i, j;
  134.     char c;
  135.     
  136.     clscr ();
  137.     for (i = 0; i < FMAXX; i++)                     /* Rand setzen           */
  138.         for (j = 0; j < FMAXY; j++)
  139.             if (!field [i][j]) {
  140.                 gotoXY (i, j);
  141.                 sout_on ();
  142.                 printf ("%c\n", OBSTACLE);
  143.                 sout_off ();
  144.             }
  145.     gotoXY (XSTART - 1, YSTART - 1);                /* Spieler setzen        */
  146.     printf ("%c\n", PLAYER);
  147. }
  148.  
  149. moveplayer ()                                       /* Spieler bewegen       */
  150. {
  151.     char c;
  152.     
  153.     gotoXY (0, 0);                                  /* Verhindert Anzeige    */
  154.     printf (" \n");                                 /* des Tastendrucks      */
  155.     gotoXY (0, 0);
  156.     c = getc (stdin);
  157.     gotoXY (plposx, plposy);                        /* alte Spielerposition  */
  158.     printf (" \n");                                 /* loeschen              */
  159.     switch (c) {                                    /* neue Position ermitt. */
  160.         case LEFT: {
  161.             plposx--;
  162.             break;
  163.         }
  164.         case RIGHT: {
  165.             plposx++;
  166.             break;
  167.         }
  168.         case UP: {
  169.             plposy--;
  170.             break;
  171.         }
  172.         case DOWN: {
  173.             plposy++;
  174.             break;
  175.         }
  176.     }
  177.     gotoXY (plposx, plposy);                        /* neue Position setzen  */
  178.     printf ("%c\n", PLAYER);
  179.     move++;                                         /* ZugzΣhler increment.  */
  180. }
  181.  
  182. setobstacle ()                                      /* Hindernisse setzen    */
  183. {
  184.     unsigned long r, rndx ();
  185.  
  186.     do {
  187.         r = rndx (1, 4, 1);                         /* neue Zufallszahl      */
  188.         switch (r) {                                /* Hindernisposition erm.*/
  189.             case 1: {
  190.                 obstposx = plposx - 1;
  191.                 obstposy = plposy;
  192.                 break;
  193.             }
  194.             case 2: {
  195.                 obstposx = plposx + 1;
  196.                 obstposy = plposy;
  197.                 break;
  198.             }
  199.             case 3: {
  200.                 obstposx = plposx;
  201.                 obstposy = plposy - 1;
  202.                 break;
  203.             }
  204.             case 4: {
  205.                 obstposx = plposx;
  206.                 obstposy = plposy + 1;
  207.                 break;
  208.             }
  209.         }
  210.     } while (!field [obstposx][obstposy]);          /* nur auf TRUE-Felder   */
  211.     gotoXY (obstposx, obstposy);
  212.     sout_on ();
  213.     printf ("%c\n", OBSTACLE);                      /* Hindernis setzen      */
  214.     sout_off ();
  215.     field [obstposx][obstposy] = FALSE;             /* Feld-Belegt-Kennz.    */
  216. }
  217.  
  218. bewertung ()                                        /* Spielergebnis bewerten*/
  219. {
  220.     unsigned short i, j;
  221.     
  222.     clscr ();
  223.     gotoXY (18, 5);
  224.     low_on ();                                      /* dunklere Schrift an   */
  225.     printf ("Sie haben\n");
  226.     low_off ();                                     /* hellere Schrift an    */
  227.     gotoXY (27, 5);
  228.     printf ("%7d\n", move);
  229.     gotoXY (35, 5);
  230.     low_on ();
  231.     printf ("Zⁿge geschafft. Das ist eine\n");
  232.     gotoXY ( 30, 8);
  233.     low_off ();
  234.     unsc_on ();                                     /* Unterschreichung an   */
  235.     i = move / 100;                                 /* Hunderter             */
  236.     j = move % 100;                                 /* Zehner u. Einer       */
  237.     switch (i) {
  238.         case 0: {
  239.             if (j < 50) printf ("miese\n");
  240.             else printf ("mΣ▀ige\n");
  241.             break;
  242.         }
  243.         case 1: {
  244.             if (j < 50) printf ("ausreichende\n");
  245.             else printf ("befriedigende\n");
  246.             break;
  247.         }
  248.         case 2: {
  249.             if (j < 50) printf ("gute\n");
  250.             else printf ("sehr gute\n");
  251.             break;
  252.         }
  253.         case 3: {
  254.             if (j < 50) printf ("hervorragende\n");
  255.             else printf ("meisterhafte\n");
  256.             break;
  257.         }
  258.         case 4: {
  259.             if (j < 50) printf ("spitzenklasse\n");
  260.             else printf ("fast ⁿbermenschliche\n");
  261.             break;
  262.         }
  263.         default: {
  264.             printf ("ⁿbermenschliche\n");
  265.             break;
  266.         }
  267.     }
  268.     unsc_off ();                                    /* Unterstreichung aus   */
  269.     gotoXY (30, 10);
  270.     low_on ();
  271.     printf ("Leistung!\n");
  272.     low_off ();
  273. }
  274.