home *** CD-ROM | disk | FTP | other *** search
/ FreeWare Collection 3 / FreeSoftwareCollection3pd199x-jp.img / pao / ms_dos / game / src / lc2d.c < prev    next >
Text File  |  1980-01-02  |  18KB  |  700 lines
  1. /* << MSC V5.1 >> *************************************************************
  2. **
  3. **    Light Cycle 2D
  4. **
  5. **    CREATE : 1990.09.20
  6. **    FINISH : 1990.09.23
  7. **
  8. **    <  NOTE   >
  9. **    TABS = 4
  10. **    FMTOWNS/FMR-70の切り換えは、GRP.H を修正しﾘｺﾝﾊﾟｲﾙすればよい。
  11. **
  12. **    < HISTIRY >
  13. **    1990.09.20 : CREATE
  14. **    1990.09.27 : 線を消す処理が無限ﾙｰﾌﾟにならないようにした。
  15. **    1990.10.02 : BREAKｷｰの入力可能場所を増やした｡
  16. **               : YES/NO ? の時に、ESCｷｰは NO が選択された時と同様とした。
  17. **
  18. **    All Rights Reserved, Copyright (C) Y.Hirata 1990.
  19. **
  20. **    Programed by Y.Hirata ( Nifty ID : NAB03321 )
  21. **
  22. ******************************************************************************/
  23.  
  24. #include <stdio.h>
  25. #include <stdlib.h>
  26. #include <string.h>
  27. #include <time.h>
  28. #include "kyb.h"
  29. #include "grp.h"
  30.  
  31. #define        TITLE        "陣屋<2D> V0.60  (c) ﾊﾟｵﾊﾟｵ 1990."
  32.  
  33. #define        TEXTPAGE    0
  34. #define        GAMEPAGE    1
  35.  
  36. #define        NUSER        6            /*  最大ﾌﾟﾚｲﾔｰ数        */
  37. #define        DOT_ON        30            /*  ｽﾋﾟｰﾄﾞ制御(表示)    */
  38. #define        SPEEDUP        3            /*  ｱｯﾌﾟｽﾋﾟｰﾄﾞ            */
  39. #define        TURBO        300            /*  ｽﾋﾟｰﾄﾞｱｯﾌﾟ制御        */
  40.  
  41. #define        BEEP_TIME    20            /*  BEEP時間 x 10 ms    */
  42. #define        BEEP_COUNT    192            /*  19200 / ? Hz        */
  43. #define        BEEP_COUNT2    10            /*  19200 / ? Hz        */
  44.  
  45. #define        TURNLEFT    2
  46. #define        TURNRIGHT    1
  47. #define        NOTURN        0
  48. #define        D_UP        1
  49. #define        D_RIGHT        2
  50. #define        D_DOWN        3
  51. #define        D_LEFT        4
  52. struct _USER_STATUS {
  53.     short    x ;            /*  現在の X 座標                        */
  54.     short    y ;            /*  現在の Y 座標                        */
  55.     short    x2 ;        /*  次の X 座標                            */
  56.     short    y2 ;        /*  次の Y 座標                            */
  57.     short    d ;            /*  現在の進行方向 : 1-UP, 2-RIGHT, 3-DOWN, 4-LEFT    */
  58.     short    d2 ;        /*  変更したい方向 : 1-RIGHT, 2-LEFT    */
  59.     int        count ;        /*  ｽﾋﾟｰﾄﾞ制御                            */
  60.     int        spcount ;    /*  ｽﾋﾟｰﾄﾞ制御                            */
  61.     char    turn ;        /*  方向変更あり?                        */
  62.     char    dead ;        /*  負けたか?                            */
  63.     short    point ;        /*  今回の得点                            */
  64.     long    tpoint ;    /*  いままでの合計得点                    */
  65.     } ;
  66. struct _USER_STATUS    User[NUSER] ;
  67.  
  68. #ifdef    FMR70                        /*  FMR-70(24ﾄﾞｯﾄ用)    */
  69. struct _USER_STATUS    User_data[NUSER] = {
  70.         { 280, 375, 280, 375, D_RIGHT, 0, 0, 0, FALSE, FALSE, 0, 0l },
  71.         { 839, 375, 839, 375, D_LEFT,  0, 0, 0, FALSE, FALSE, 0, 0l },
  72.         { 280, 195, 280, 195, D_RIGHT, 0, 0, 0, FALSE, FALSE, 0, 0l },
  73.         { 839, 195, 839, 195, D_LEFT,  0, 0, 0, FALSE, FALSE, 0, 0l },
  74.         { 280, 555, 280, 555, D_RIGHT, 0, 0, 0, FALSE, FALSE, 0, 0l },
  75.         { 839, 555, 839, 555, D_LEFT,  0, 0, 0, FALSE, FALSE, 0, 0l }
  76.     } ;
  77. #else                                /*  FMTOWNS(16ﾄﾞｯﾄ用)    */
  78. struct _USER_STATUS    User_data[NUSER] = {
  79.         { 150, 200, 150, 200, D_RIGHT, 0, 0, 0, FALSE, FALSE, 0, 0l },
  80.         { 489, 200, 489, 200, D_LEFT,  0, 0, 0, FALSE, FALSE, 0, 0l },
  81.         { 150, 100, 150, 100, D_RIGHT, 0, 0, 0, FALSE, FALSE, 0, 0l },
  82.         { 489, 100, 489, 100, D_LEFT,  0, 0, 0, FALSE, FALSE, 0, 0l },
  83.         { 150, 300, 150, 300, D_RIGHT, 0, 0, 0, FALSE, FALSE, 0, 0l },
  84.         { 489, 300, 489, 300, D_LEFT,  0, 0, 0, FALSE, FALSE, 0, 0l }
  85.     } ;
  86. #endif
  87.  
  88. struct _USER_PARA {
  89.     short    color ;                /*  color            */
  90.     char    left ;                /*  左方向ｷｰ        */
  91.     char    speed ;                /*  ｽﾋﾟｰﾄﾞｷｰ        */
  92.     char    right ;                /*  右方向ｷｰ        */
  93.     } ;
  94. struct _USER_PARA    Upara[NUSER] = {
  95.         { C_GREEN,   KEY_1,    KEY_2,     KEY_3        },
  96.         { C_SKYBLUE, KEY_GT,   KEY_QUEST, KEY_UNDERBER },
  97.         { C_RED,     KEY_G,    KEY_H,     KEY_J        },
  98.         { C_YELLOW,  KEY_8,    KEY_9,     KEY_0        },
  99.         { C_PURPLE,  KEY_Z,    KEY_X,     KEY_C        },
  100.         { C_WHITE,   TKEY_1,   TKEY_2,    TKEY_3       }
  101.     } ;
  102.  
  103. typedef struct _USER_TRACE {
  104.     short    x ;
  105.     short    y ;
  106.     char    d ;
  107.     } USER_TRACE ;
  108. USER_TRACE    *Utrace[NUSER] ;
  109. short    Nturn[NUSER] ;
  110.  
  111. char    *UserKey[] = {
  112.                         "1  2  3",
  113.                         ">  ?  _",
  114.                         "G  H  J",
  115.                         "8  9  0",
  116.                         "Z  X  C",
  117.                         "T1  T2  T3"
  118.         } ;
  119.  
  120. int        Nplayer = 6 ;                /*  ﾌﾟﾚｲﾔｰ数        */
  121. int        Resplayer ;                    /*  残りﾌﾟﾚｲﾔｰ数    */
  122. short    Backcolor = 0 ;                /*  背景色番号        */
  123. long    Backpixel = 0x203030l ;        /*  背景色 : r0g0b0    */
  124. char    Continueflg = FALSE ;
  125. char    Breakflg = FALSE ;
  126.  
  127. #define        RANDINIT    srand((unsigned int)time(NULL))        /*  乱数初期化    */
  128. #define        RANDOM(x)    (rand()%(x))                        /*  乱数 : 0～x    */
  129.  
  130. /***************************  USER Parameter init  ***************************/
  131. void play_init()
  132. {
  133.     int        c ;
  134.  
  135.     Resplayer = Nplayer ;
  136.     for ( c=0; c<NUSER; c++ ) {
  137.         User[c].x       = User_data[c].x ;
  138.         User[c].y       = User_data[c].y ;
  139.         User[c].x2      = User_data[c].x2 ;
  140.         User[c].y2      = User_data[c].y2 ;
  141.         User[c].d       = User_data[c].d ;
  142.         User[c].d2      = User_data[c].d2 ;
  143.         User[c].count   = User_data[c].count ;
  144.         User[c].spcount = User_data[c].spcount ;
  145.         User[c].turn    = User_data[c].turn ;
  146.         User[c].dead    = User_data[c].dead ;
  147.         Nturn[c] = 0 ;
  148.     }
  149.  
  150. }
  151.  
  152. /****************************  Yes/No ｷｰ入力する  ****************************/
  153. int yesno()
  154. {
  155.     int        ret ;
  156.     char    matrix[16] ;
  157.     char    keyend ;
  158.  
  159.     ret = 0 ;
  160.     keyend = FALSE ;
  161.     Breakflg = FALSE ;
  162.     do {
  163.         KEY_bufcls() ;
  164.         KEY_matrix( matrix ) ;
  165.         if ( KEY_test( matrix,KEY_N ) ||
  166.                 KEY_test( matrix,KEY_ESC ) ) {
  167.             ret = FALSE ;
  168.             keyend = KEY_N ;
  169.             KEY_break( KEY_N ) ;
  170.             KEY_break( KEY_ESC ) ;
  171.         } else if ( KEY_test( matrix,KEY_Y ) ||
  172.                 KEY_test( matrix,KEY_CR ) ||
  173.                 KEY_test( matrix,TKEY_CR ) ||
  174.                 KEY_test( matrix,KEY_EXEC ) ) {
  175.             ret = TRUE ;
  176.             keyend = KEY_Y ;
  177.             KEY_break( KEY_Y ) ;
  178.             KEY_break( KEY_CR ) ;
  179.             KEY_break( TKEY_CR ) ;
  180.             KEY_break( KEY_EXEC ) ;
  181.         } else if ( KEY_test( matrix,KEY_BREAK ) ) {
  182.             ret = FALSE ;
  183.             keyend = KEY_BREAK ;
  184.             KEY_break( KEY_BREAK ) ;
  185.             Breakflg = TRUE ;
  186.         }
  187.     } while ( !keyend ) ;
  188.  
  189.     KEY_bufcls() ;
  190.  
  191.     return( ret ) ;
  192. }
  193.  
  194. /*******************************  DOT ERACE  *********************************/
  195. void erace( short uno )
  196. {
  197.     short    px, py, pcol, pd ;
  198.     long    pturn ;
  199.  
  200.     px = User_data[uno].x ;
  201.     py = User_data[uno].y ;
  202.     pd = User_data[uno].d ;
  203.     pturn = 0 ;
  204.     GRP_color( Backcolor ) ;
  205.     pcol = GRP_getpixel( px,py ) ;
  206.     if ( pcol == Upara[uno].color ) {
  207.         GRP_pset( px,py ) ;
  208.     } else {
  209.         return ;
  210.     }
  211.  
  212.     while ( TRUE ) {
  213.         if ( Nturn[uno] > 0 ) {
  214.             if ( Utrace[uno][pturn].x == px &&
  215.                     Utrace[uno][pturn].y == py ) {
  216.                 pd = Utrace[uno][pturn].d ;
  217.                 pturn ++ ;
  218.             }
  219.         }
  220.         if ( pturn > Nturn[uno] ) break ;
  221.         switch ( pd ) {                                /*  次の座標    */
  222.             case D_UP :
  223.                 py -- ;
  224.                 break ;
  225.             case D_RIGHT :
  226.                 px ++ ;
  227.                 break ;
  228.             case D_DOWN :
  229.                 py ++ ;
  230.                 break ;
  231.             case D_LEFT :
  232.                 px -- ;
  233.                 break ;
  234.         }
  235.         if ( px == User[uno].x && py == User[uno].y ) break ;
  236.         GRP_pset( px,py ) ;
  237.     }
  238.  
  239. }
  240.  
  241. /*******************************  DEAD CHECK  ********************************/
  242. void dead_check()
  243. {
  244.     int        c, cc, ndead ;
  245.     short    color ;
  246.     char    deadflg[NUSER] ;
  247.  
  248.     GRP_color( Backcolor ) ;
  249.     ndead = 0 ;
  250.     for ( c=0; c<Nplayer; c++ ) {
  251.         deadflg[c] = FALSE ;
  252.         color = GRP_getpixel( User[c].x2,User[c].y2 ) ;
  253.         if ( User[c].dead == TRUE ) {                    /*  ぶつかった    */
  254.             deadflg[c] = TRUE ;
  255.             ndead ++ ;
  256.         } else if ( !User[c].dead ) {
  257.             if ( c < ( Nplayer - 1 ) ) {
  258.                 for ( cc=c+1; cc<Nplayer; cc++ ) {
  259.                     if ( User[cc].dead == TRUE &&
  260.                         User[c].x2 == User[cc].x2 &&
  261.                         User[c].y2 == User[cc].y2 ) {    /*  共倒れ        */
  262.                         deadflg[c] = TRUE ;
  263.                         ndead ++ ;
  264.                         GRP_pset( User[c].x2,User[c].y2 ) ;
  265.                     }
  266.                 }
  267.             }
  268.             if ( !deadflg[c] ) {                        /*  生存        */
  269.                 User[c].x = User[c].x2 ;
  270.                 User[c].y = User[c].y2 ;
  271.             }
  272.         }
  273.     }
  274.     for ( c=0; c<Nplayer; c++ ) {
  275.         if ( !User[c].dead || User[c].dead == TRUE ) {
  276.             if ( deadflg[c] ) {
  277.                 GRP_beep( BEEP_TIME,BEEP_COUNT ) ;
  278.                 User[c].dead = TRUE + 1 ;
  279.                 User[c].point = ( Nplayer - Resplayer ) ;
  280.                 User[c].tpoint += (long)User[c].point ;
  281.                 GRP_pset( User[c].x,User[c].y ) ;
  282.                 erace( c ) ;
  283.             }
  284.         }
  285.     }
  286.     Resplayer -= ndead ;
  287.  
  288. }
  289.  
  290. /*********************************  BOMB 発生  *******************************/
  291. void bomb()
  292. {
  293.     short    x, y ;
  294.  
  295.     GRP_beep( BEEP_TIME,BEEP_COUNT2 ) ;
  296.     x = RANDOM( VIEW_XE-6 ) + 3 ;
  297.     y = RANDOM( VIEW_YE-6 ) + 3 ;
  298.     GRP_color( C_WHITE ) ;
  299.     GRP_rectangle( x-2,y-2,x+2,y+2,FALSE ) ;
  300.     GRP_rectangle( x-1,y-1,x+1,y+1,FALSE ) ;
  301. }
  302.  
  303. /******************************  PLAYER CHECK  *******************************/
  304. void player_check( char *matrix )
  305. {
  306.     int        c ;
  307.     char    dotonflg ;
  308.     char    bombflg[NUSER] ;
  309.     short    color ;
  310.     static int    dotcount=0 ;
  311.  
  312.     dotonflg = FALSE ;
  313.     for ( c=0; c<Nplayer; c++ ) {
  314.         bombflg[c] = FALSE ;
  315.         if ( !User[c].dead ) {
  316.             if ( KEY_test( matrix,Upara[c].speed ) ) {            /*  SPEED UP*/
  317.                 User[c].spcount ++ ;
  318.                 if ( User[c].spcount > TURBO ) {
  319.                     User[c].count += (SPEEDUP*2) ;
  320.                 } else {
  321.                     User[c].count += SPEEDUP ;
  322.                 }
  323.             } else {
  324.                 if ( User[c].spcount > 1 ) {
  325.                     User[c].spcount -= 2 ;
  326.                     if ( User[c].spcount > TURBO ) {
  327.                         User[c].count += SPEEDUP ;
  328.                     } else {
  329.                         User[c].spcount = 0 ;
  330.                         User[c].count ++ ;
  331.                     }
  332.                 } else {
  333.                     User[c].spcount = 0 ;
  334.                     User[c].count ++ ;
  335.                 }
  336.             }
  337.             if ( KEY_test( matrix,Upara[c].left ) ) {            /*  LEFT    */
  338.                 if ( !KEY_test( matrix,Upara[c].right ) ) {
  339.                     if ( !User[c].turn ) {
  340.                         User[c].d2   = TURNLEFT ;
  341.                         User[c].turn = TRUE ;
  342.                     }
  343.                 } else {
  344.                     User[c].d2   = NOTURN ;
  345.                     User[c].turn = FALSE ;
  346.                     bombflg[c] = TRUE ;
  347.                 }
  348.             } else if ( KEY_test( matrix,Upara[c].right ) ) {    /*  RIGHT    */
  349.                 if ( !User[c].turn ) {
  350.                     User[c].d2   = TURNRIGHT ;
  351.                     User[c].turn = TRUE ;
  352.                 }
  353.             } else {
  354.                 User[c].d2   = NOTURN ;
  355.                 User[c].turn = FALSE ;
  356.             }
  357.             if ( User[c].count > DOT_ON ) {
  358.                 dotonflg = TRUE ;
  359.                 User[c].count = 0 ;
  360.                 if ( User[c].d2 == TURNLEFT )  User[c].d-- ;
  361.                 if ( User[c].d2 == TURNRIGHT ) User[c].d++ ;
  362.                 if ( User[c].d < D_UP ) User[c].d = D_LEFT ;
  363.                 if ( User[c].d > D_LEFT ) User[c].d = D_UP ;
  364.                 switch ( User[c].d ) {
  365.                     case D_UP :                        /*  UP        */
  366.                         User[c].x2 = User[c].x ;
  367.                         User[c].y2 = User[c].y - 1 ;
  368.                         break ;
  369.                     case D_RIGHT :                    /*  RIGHT    */
  370.                         User[c].x2 = User[c].x + 1 ;
  371.                         User[c].y2 = User[c].y ;
  372.                         break ;
  373.                     case D_DOWN :                    /*  DOWN    */
  374.                         User[c].x2 = User[c].x ;
  375.                         User[c].y2 = User[c].y + 1 ;
  376.                         break ;
  377.                     case D_LEFT :                    /*  LEFT    */
  378.                         User[c].x2 = User[c].x - 1 ;
  379.                         User[c].y2 = User[c].y ;
  380.                         break ;
  381.                     default :
  382.                         User[c].x2 = User[c].x ;
  383.                         User[c].y2 = User[c].y ;
  384.                         break ;
  385.                 }
  386.                 if ( User[c].d2 != NOTURN ) {
  387.                     Utrace[c][Nturn[c]].x = User[c].x ;
  388.                     Utrace[c][Nturn[c]].y = User[c].y ;
  389.                     Utrace[c][Nturn[c]].d = User[c].d ;
  390.                     Nturn[c] ++ ;
  391.                 }
  392.                 User[c].d2 = NOTURN ;
  393.                 color = GRP_getpixel( User[c].x2,User[c].y2 ) ;
  394.                 GRP_color( Upara[c].color ) ;
  395.                 if ( color != Backcolor ) {
  396.                     User[c].dead = TRUE ;
  397.                 } else {
  398.                     GRP_line( User[c].x,User[c].y,User[c].x2,User[c].y2 ) ;
  399.                     if ( bombflg[c] && dotcount == 0 ) {
  400.                         bomb() ;
  401.                     }
  402.                 }
  403.             }
  404.         }
  405.     }
  406.     if ( dotonflg ) {
  407.         dotcount ++ ;
  408.         if ( dotcount > 30 ) dotcount = 0 ;
  409.         dead_check() ;
  410.     }
  411.  
  412. }
  413.  
  414. /**************************  何人でプレイするのか？  *************************/
  415. int inplayer()
  416. {
  417.     char    matrix[16] ;                            /*  ｷｰﾏﾄﾘｸｽ取得用        */
  418.     int        ret ;
  419.  
  420.     Breakflg = FALSE ;
  421.     while( TRUE ) {
  422.          KEY_bufcls() ;
  423.         KEY_matrix( matrix ) ;
  424.  
  425.         if ( KEY_test( matrix,KEY_BREAK ) ) {            /*  BREAK ｷｰ ON        */
  426.             ret = 0 ;
  427.             Breakflg = TRUE ;
  428.             KEY_break( KEY_BREAK ) ;
  429.             break ;
  430.         } else if ( KEY_test( matrix,KEY_ESC ) ) {
  431.             ret = 0 ;
  432.             KEY_break( KEY_ESC ) ;
  433.             break ;
  434.         } else if ( KEY_test( matrix,KEY_2 ) ||
  435.                     KEY_test( matrix,TKEY_2 ) ) {        /*  2人                */
  436.             ret = 2 ;
  437.             break ;
  438.         } else if ( KEY_test( matrix,KEY_3 ) ||
  439.                     KEY_test( matrix,TKEY_3 ) ) {        /*  3人                */
  440.             ret = 3 ;
  441.             break ;
  442.         } else if ( KEY_test( matrix,KEY_4 ) ||
  443.                     KEY_test( matrix,TKEY_4 ) ) {        /*  4人                */
  444.             ret = 4 ;
  445.             break ;
  446.         } else if ( KEY_test( matrix,KEY_5 ) ||
  447.                     KEY_test( matrix,TKEY_5 ) ) {        /*  5人                */
  448.             ret = 5 ;
  449.             break ;
  450.         } else if ( KEY_test( matrix,KEY_6 ) ||
  451.                     KEY_test( matrix,TKEY_6 ) ) {        /*  6人                */
  452.             ret = 6 ;
  453.             break ;
  454.         }
  455.     }
  456.     return( ret ) ;
  457. }
  458.  
  459. /*******************************  GAME READY  ********************************/
  460. int ready()
  461. {
  462.     int        c, nplay ;
  463.     char    msg[80] ;
  464.     char    readyflg ;
  465.     short    x, y ;
  466.  
  467.     GRP_writePage( GAMEPAGE ) ;
  468.     GRP_color( C_BLACK ) ;
  469.     GRP_clearScreen( CLEARSCREEN ) ;
  470.     GRP_displayPage( GAMEPAGE ) ;
  471.  
  472.     GRP_color( C_WHITE ) ;
  473.     GRP_rectangle( VIEW_XS,VIEW_YS,VIEW_XE,VIEW_YE,FALSE ) ;
  474.     GRP_locate( 2,4 ) ;
  475.     GRP_textcolor( C_GREEN ) ;
  476.     GRP_outtext( TITLE ) ;
  477.     for ( c=0; c<NUSER; c++ ) {
  478.         sprintf( msg,"Player %d",c+1 ) ;
  479.         GRP_locate( User_data[c].y/YDOTS-1,User_data[c].x/XDOTS+1-5 ) ;
  480.         GRP_textcolor( Upara[c].color ) ;
  481.         GRP_outtext( msg ) ;
  482.         GRP_locate( User_data[c].y/YDOTS,User_data[c].x/XDOTS+1-5 ) ;
  483.         GRP_outtext( UserKey[c] ) ;
  484.     }
  485.     GRP_textcolor( C_WHITE ) ;
  486.  
  487.     readyflg = 0 ;
  488.     GRP_cursor( TRUE ) ;
  489.     nplay = Nplayer ;
  490.     do {
  491.         if ( readyflg == 0 && !Continueflg ) {
  492.             GRP_locate( 3,4 ) ;
  493.             for ( c=0; c<80; c++ ) msg[c] = ' ' ;
  494.             msg[79] = '\0' ;
  495.             GRP_outtext( msg ) ;
  496.             GRP_locate( 3,4 ) ;
  497.             GRP_outtext( "何人でプレイしますか？ ( 2 ～ 6 ) " ) ;
  498.             nplay = inplayer() ;
  499.             if ( nplay ) {
  500.                 readyflg = 1 ;
  501.             } else {
  502.                 if ( Breakflg ) {
  503.                     return( FALSE ) ;                /*  中断            */
  504.                 } else {
  505.                     Continueflg = TRUE ;            /*  人数設定ｷｬﾝｾﾙ    */
  506.                 }
  507.             }
  508.         }
  509.         if ( nplay ) {
  510.             sprintf( msg,"GAME START ! ( %d player ) Are you ready ? (Y/N) ",
  511.                     nplay) ;
  512.         } else {
  513.             sprintf( msg,"GAME START ! ( %d player ) Are you ready ? (Y/N) ",
  514.                     Nplayer) ;
  515.         }
  516.         GRP_locate( 3,4 ) ;
  517.         GRP_outtext( msg ) ;
  518.         if ( !yesno() ) {                            /*  NOT READY        */
  519.             readyflg = 0 ;
  520.             Continueflg = FALSE ;
  521.             if ( Breakflg ) return( FALSE ) ;        /*  中断            */
  522.         } else {                                    /*  READY GO!        */
  523.             readyflg = 2 ;
  524.         }
  525.  
  526.     } while ( readyflg != 2 ) ;
  527.     GRP_cursor( FALSE ) ;
  528.  
  529.     if ( nplay && Nplayer != nplay ) {            /*  前回と人数が異なる    */
  530.         Nplayer = nplay ;
  531.         for ( c=0; c<NUSER; c++ ) {                    /*  得点ｸﾘｱ            */
  532.             User[c].point = 0 ;
  533.             User[c].tpoint = 0 ;
  534.         }
  535.     }
  536.  
  537.     GRP_clearScreen( CLEARTEXT ) ;
  538.     return( TRUE ) ;
  539. }
  540.  
  541. /*******************************  GAME START  ********************************/
  542. int play_start()
  543. {
  544.     char    matrix[16] ;                            /*  ｷｰﾏﾄﾘｸｽ取得用        */
  545.     char    endflg ;                                /*  終了ﾌﾗｸﾞ            */
  546.     int        c ;
  547.  
  548.     if ( !ready() ) return( FALSE ) ;
  549.     play_init() ;
  550.  
  551.     endflg = FALSE ;
  552.     do {
  553.          KEY_bufcls() ;
  554.         KEY_matrix( matrix ) ;
  555.  
  556.         if ( KEY_test( matrix,KEY_BREAK ) ) {            /*  BREAK ｷｰ ON        */
  557.             endflg = TRUE ;
  558.             for ( c=0; c<Nplayer; c++ ) {
  559.                 if ( !User[c].dead ) {
  560.                     User[c].point = ( Nplayer - Resplayer ) ;
  561.                     User[c].tpoint += (long)User[c].point ;
  562.                 }
  563.             }
  564.             KEY_break( KEY_BREAK ) ;
  565.             break ;
  566.         } else {
  567.             player_check( matrix ) ;
  568.             if ( Resplayer == 1 ) {
  569.                 for ( c=0; c<Nplayer; c++ ) {
  570.                     if ( !User[c].dead ) {
  571.                         User[c].point = ( Nplayer - Resplayer ) ;
  572.                         User[c].tpoint += (long)User[c].point ;
  573.                         break ;
  574.                     }
  575.                 }
  576.             }
  577.             if ( Resplayer <= 1 ) {
  578.                 endflg = TRUE ;
  579.             }
  580.         }
  581.  
  582.     } while ( !endflg ) ;
  583.  
  584.     return( TRUE ) ;
  585. }
  586.  
  587. /************************  char 0-f(F) -> int 0-15  **************************/
  588. int ctoi( c )
  589. char    c ;
  590. {
  591.     int        i ;
  592.  
  593.     i = 0 ;
  594.     if ( c >= '0' && c <= '9' ) {
  595.         i = c - '0' ;
  596.     } else {
  597.         if ( c >= 'A' && c <= 'F' )
  598.             i = 10 + c - 'A' ;
  599.         if ( c >= 'a' && c <= 'f' )
  600.             i = 10 + c - 'a' ;
  601.     }
  602.     return( i ) ;
  603. }
  604.  
  605. /*********************************  ﾒｲﾝ 処理  ********************************/
  606. void main( int ac,char *av[] )
  607. {
  608.     int        c ;
  609.     char    msg[80] ;
  610.     long    pixel ;                            /*  r0g0b0        */
  611.     char    playon ;
  612.  
  613.     pixel = 0l ;
  614.     if ( ac > 1 ) {                            /*  引数あり    */
  615.         if ( strlen( av[1] ) == 3 ) {
  616.             c = ctoi( *(av[1]+1) ) ;        /*  RED            */
  617.             c <<= 4 ;
  618.             pixel |= (long)c ;
  619.             c = ctoi( *(av[1]+2) ) ;        /*  GREEN        */
  620.             c <<= 4 ;
  621.             pixel <<= 8 ;
  622.             pixel |= (long)c ;
  623.             c = ctoi( *av[1] ) ;            /*  BLUE        */
  624.             c <<= 4 ;
  625.             pixel <<= 8 ;
  626.             pixel |= (long)c ;
  627.         }
  628.     }
  629.  
  630. /*
  631. **    初期処理
  632. **
  633. **    GAME は、Page 1
  634. **    TEXT は、Page 0
  635. */
  636.     printf("program start!\n") ;
  637.     INT23_init() ;
  638.     GRP_init() ;
  639.     GRP_palette( Backcolor,Backpixel ) ;
  640.     for ( c=0; c<NUSER; c++ ) {                /*  得点ｸﾘｱ        */
  641.         User[c].point = 0 ;
  642.         User[c].tpoint = 0 ;
  643.     }
  644.     RANDINIT ;
  645.     playon = TRUE ;
  646.     for ( c=0; c<NUSER; c++ ) {
  647.         Utrace[c] = (USER_TRACE *)malloc( sizeof(USER_TRACE)*4096 ) ;
  648.         if ( Utrace[c] == NULL ) {
  649.             printf("メモリ不足です。\n") ;
  650.             playon = FALSE ;
  651.             break ;
  652.         } ;
  653.     }
  654. /*
  655. **    キー入力処理
  656. */
  657.     while( TRUE && playon ) {
  658.         if ( play_start() ) {
  659.             GRP_clearScreen( CLEARTEXT ) ;
  660.             GRP_textcolor( C_WHITE ) ;
  661.             GRP_locate( 4,25 ) ;
  662.             GRP_outtext( "GAME OVER !" ) ;
  663.             for ( c=0; c<Nplayer; c++ ) {
  664.                 sprintf( msg,"Player %d : %d  < TOTAL : %ld >",
  665.                     c+1,User[c].point,User[c].tpoint ) ;
  666.                 GRP_locate( 6+c,25 ) ;
  667.                 GRP_textcolor( Upara[c].color ) ;
  668.                 GRP_outtext( msg ) ;
  669.             }
  670.             GRP_textcolor( C_WHITE ) ;
  671.             GRP_locate( 13,25 ) ;
  672.             GRP_outtext( "CONTINUE ? (Y/N) " ) ;
  673.             GRP_cursor( TRUE ) ;
  674.             Continueflg = yesno() ;
  675.         }
  676.         if ( !Continueflg ) {                        /*  NOT CONTINUE    */
  677.             GRP_clearScreen( CLEARTEXT ) ;
  678.             GRP_textcolor( C_WHITE ) ;
  679.             GRP_locate( 3,4 ) ;
  680.             GRP_outtext( "GAME を終了してもよろしいですか？ (Y/N) " ) ;
  681.             if ( yesno() ) break ;
  682.             for ( c=0; c<NUSER; c++ ) {                /*  得点ｸﾘｱ        */
  683.                 User[c].point = 0 ;
  684.                 User[c].tpoint = 0 ;
  685.             }
  686.         }
  687.         GRP_cursor( FALSE ) ;
  688.     }
  689. /*
  690. **    終了処理
  691. */
  692.     GRP_clearScreen( CLEARGRAPH ) ;
  693.     GRP_end() ;
  694.     GRP_palette( Backcolor,pixel ) ;
  695.     INT23_release() ;
  696.     printf("ﾌﾟﾛｸﾞﾗﾑ終了\n") ;
  697.  
  698. }
  699.  
  700.