home *** CD-ROM | disk | FTP | other *** search
/ rtsi.com / 2014.01.www.rtsi.com.tar / www.rtsi.com / OS9 / OSK / GAMES / infocom_src.lha / options.c < prev    next >
Text File  |  1993-03-03  |  12KB  |  484 lines
  1. /*
  2. **    File:    options.c
  3. **
  4. **    (C)opyright 1987-1992 InfoTaskforce.
  5. */
  6.  
  7. #include    "infocom.h"
  8.  
  9. #define        MAX_CHARS_PER_WORD    (PLUS_CHARS_PER_WORD)
  10. #define        VOCAB_BUFFER_SIZE    (MAX_CHARS_PER_WORD+3)
  11. #define        BYTE_DISPLAY(x)        hex_digit((x),2)
  12.  
  13. char        vocab_buffer[VOCAB_BUFFER_SIZE+1] ;
  14. char        *vocab_ptr ;
  15.  
  16. Void
  17. options ( opt )
  18. word    opt ;
  19. {
  20.     extern header    data_head ;
  21.  
  22.     init_print () ;
  23.     if ( opt & HEAD_INFO )
  24.         show_header () ;
  25.     if ( opt & ( VOCABULARY | EXTENDED_VOCAB ) )
  26.         show_vocab ( opt ) ;
  27.     if ( opt & OBJECTS )
  28.         show_objects ( data_head.z_code_version,opt ) ;
  29.     if ( opt & TREE )
  30.         show_tree ( data_head.z_code_version ) ;
  31. }
  32.  
  33. Void
  34. print_item ( s,n )
  35. char    *s ;
  36. word    n ;
  37. {
  38.     display ( s ) ;
  39.     hex_display ( n ) ;
  40.     new_line () ;
  41. }
  42.  
  43. Void
  44. show_header ()
  45. {
  46.     extern header    data_head ;
  47.     extern proc_ptr    PrintChar ;
  48.  
  49.     word            i ;
  50.  
  51.     /*
  52.     **    We use 'new_line()' to get a new line so that
  53.     **    the "**MORE**" facility will be used.
  54.     */
  55.  
  56.     display ( "INFOCOM Data File Header." ) ;
  57.     new_line () ;
  58.     new_line () ;
  59.     print_item ( "Z-Code Version: $",(word)data_head.z_code_version ) ;
  60.     new_line () ;
  61.     if ( data_head.mode_bits & USE_TIME )
  62.         display ( "Score/Time    : Time" ) ;
  63.     else
  64.         display ( "Score/Time    : Score" ) ;
  65.     new_line () ;
  66.     print_item ( "Mode Bits     : $",(word)data_head.mode_bits ) ;
  67.     print_item ( "Release Number: $",data_head.release ) ;
  68.     print_item ( "Resident Bytes: $",data_head.resident_bytes ) ;
  69.     print_item ( "Start Address : $",data_head.start ) ;
  70.     print_item ( "Vocab Address : $",data_head.vocab ) ;
  71.     print_item ( "Object List   : $",data_head.object_list ) ;
  72.     print_item ( "Global Vars.  : $",data_head.globals ) ;
  73.     print_item ( "Save Bytes    : $",data_head.save_bytes ) ;
  74.     print_item ( "Script Status : $",data_head.script_status ) ;
  75.     if ( data_head.script_status == 0 )
  76.         display ( "Script Status : Off" ) ;
  77.     else
  78.         display ( "Script Status : On" ) ;
  79.     new_line () ;
  80.     display ( "Serial Number : " ) ;
  81.     for ( i = 0 ; i < 6 ; i++ )
  82.         (*PrintChar) ( (word)data_head.serial_no[i] ) ;
  83.     new_line () ;
  84.     print_item ( "Common Words  : $",data_head.common_word ) ;
  85.     print_item ( "Verify Length : $",data_head.verify_length ) ;
  86.     print_item ( "Verify Check  : $",data_head.verify_checksum ) ;
  87.     new_line () ;
  88.     new_line () ;
  89. }
  90.  
  91. Void
  92. print_word ( ch )
  93. word    ch ;
  94. {
  95.     extern char        *vocab_ptr ;
  96.  
  97.     *vocab_ptr++ = (char)ch ;
  98. }
  99.  
  100. Void
  101. show_vocab ( opt )
  102. word    opt ;
  103. {
  104.     extern header        data_head ;
  105.     extern word            num_vocab_words ;
  106.     extern word            vocab_entry_size ;
  107.     extern word            strt_vocab_table ;
  108.     extern byte_ptr        base_ptr ;
  109.     extern proc_ptr        PrintChar ;
  110.     extern char            vocab_buffer[] ;
  111.     extern char            *vocab_ptr ;
  112.     extern int            screen_width ;
  113.     extern int            print_mode ;
  114.     extern int            single_mode ;
  115.     extern Void            print_word () ;
  116.  
  117.     proc_ptr            old_printchar ;
  118.     byte_ptr            ptr ;
  119.     word                page ;
  120.     word                offset ;
  121.     word                count ;
  122.     int                    words_per_line ;
  123.     int                    i ;
  124.  
  125.     display ( "INFOCOM Adventure - Vocab List." ) ;
  126.     new_line () ;
  127.     new_line () ;
  128.     print_item ( "Number of Words: $",num_vocab_words ) ;
  129.     new_line () ;
  130.  
  131.     old_printchar = PrintChar ;
  132.     PrintChar = print_word ;
  133.     vocab_ptr = vocab_buffer ;
  134.     for ( i = 0 ; i < (int)VOCAB_BUFFER_SIZE ; i++ )
  135.         *vocab_ptr++ = ' ' ;
  136.     *vocab_ptr = '\0' ;
  137.  
  138.     words_per_line = screen_width / (int)VOCAB_BUFFER_SIZE ;
  139.     count = 0 ;
  140.     ptr = base_ptr + strt_vocab_table ;
  141.     while ( count < num_vocab_words )
  142.     {
  143.         page = ( ptr - base_ptr ) / (int)BLOCK_SIZE ;
  144.         offset = ( ptr - base_ptr ) % (int)BLOCK_SIZE ;
  145.  
  146.         print_mode = single_mode = 0 ;
  147.         vocab_ptr = vocab_buffer ;
  148.         if ( data_head.z_code_version <= VERSION_3 )
  149.         {
  150.             for ( i = 0 ; i < (int)STD_ENCODED_SIZE ; i++ )
  151.                 decode ( get_word ( &page,&offset ) ) ;
  152.         }
  153.         else
  154.         {
  155.             for ( i = 0 ; i < (int)PLUS_ENCODED_SIZE ; i++ )
  156.                 decode ( get_word ( &page,&offset ) ) ;
  157.         }
  158.         while ( *vocab_ptr != '\0' )
  159.             *vocab_ptr++ = ' ' ;
  160.         display ( vocab_buffer ) ;
  161.  
  162.         if ( opt & EXTENDED_VOCAB )
  163.         {
  164.             if ( data_head.z_code_version <= VERSION_3 )
  165.             {
  166.                 for (i = 0; i < (int)(vocab_entry_size - (STD_ENCODED_SIZE * 2)); i++)
  167.                 {
  168.                     display ( "\t$" ) ;
  169.                     BYTE_DISPLAY ( get_byte ( &page,&offset ) ) ;
  170.                 }
  171.             }
  172.             else
  173.             {
  174.                 for (i = 0; i < (int)(vocab_entry_size - (PLUS_ENCODED_SIZE * 2)); i++)
  175.                 {
  176.                     display ( "\t$" ) ;
  177.                     BYTE_DISPLAY ( get_byte ( &page,&offset ) ) ;
  178.                 }
  179.             }
  180.             ++count ;
  181.             new_line () ;
  182.         }
  183.         else
  184.         {
  185.             if ( ((int)++count % words_per_line) == 0 )
  186.                 new_line () ;
  187.         }
  188.  
  189.         ptr += vocab_entry_size ;
  190.     }
  191.     new_line () ;
  192.     new_line () ;
  193.     PrintChar = old_printchar ;
  194. }
  195.  
  196. boolean
  197. prop_name ( obj_num )
  198. word    obj_num ;
  199. {
  200.     extern header            data_head ;
  201.     extern byte_ptr            base_ptr ;
  202.     extern std_object_ptr    std_obj_list ;
  203.     extern plus_object_ptr    plus_obj_list ;
  204.  
  205.     std_object_ptr            std_obj ;
  206.     plus_object_ptr            plus_obj ;
  207.     byte_ptr                p ;
  208.  
  209.     if ( data_head.z_code_version <= VERSION_3 )
  210.     {
  211.         std_obj = STD_OBJ_ADDR ( obj_num ) ;
  212.         p = base_ptr + ((word)(std_obj -> prop_ptr[0]) << 8) + (std_obj -> prop_ptr[1]) ;
  213.         if ( *p )
  214.             return ( TRUE ) ;
  215.     }
  216.     else
  217.     {
  218.         plus_obj = PLUS_OBJ_ADDR ( obj_num ) ;
  219.         p = base_ptr + ((word)(plus_obj -> prop_ptr[0]) << 8) + (plus_obj -> prop_ptr[1]) ;
  220.         if ( *p )
  221.             return ( TRUE ) ;
  222.     }
  223.     return ( FALSE ) ;
  224. }
  225.  
  226. Void
  227. show_std_props ( obj_num )
  228. word    obj_num ;
  229. {
  230.     extern std_object_ptr    std_obj_list ;
  231.     extern property            std_prop_addr () ;
  232.  
  233.     property                p ;
  234.     byte                    p_num ;
  235.     byte                    p_len ;
  236.  
  237.     new_line () ;
  238.     p = std_prop_addr ( STD_OBJ_ADDR ( obj_num ) ) ;
  239.     while ( ( p_num = STD_PROPERTY_NUMBER ( p ) ) != 0 )
  240.     {
  241.         p_len = STD_PROPERTY_LENGTH ( p ) ;
  242.         ++p ;
  243.         display ( "\t -> property   : $" ) ;
  244.         BYTE_DISPLAY ( p_num ) ;
  245.         display ( " [" ) ;
  246.         while ( p_len-- )
  247.         {
  248.             display ( " $" ) ;
  249.             BYTE_DISPLAY ( *p++ ) ;
  250.         }
  251.         display ( " ]" ) ;
  252.         new_line () ;
  253.     }
  254. }
  255.  
  256. Void
  257. show_plus_props ( obj_num )
  258. word    obj_num ;
  259. {
  260.     extern plus_object_ptr    plus_obj_list ;
  261.     extern property            plus_prop_addr () ;
  262.  
  263.     property                p ;
  264.     byte                    p_num ;
  265.     byte                    p_len ;
  266.     byte                    mode ;
  267.  
  268.     new_line () ;
  269.     p = plus_prop_addr ( PLUS_OBJ_ADDR ( obj_num ) ) ;
  270.     while ( ( p_num = PLUS_PROPERTY_NUMBER ( p ) ) != 0 )
  271.     {
  272.         mode = *p++ ;
  273.         if ( mode & NEXT_BYTE_IS_LENGTH )
  274.             p_len = PLUS_PROPERTY_LENGTH ( p++ ) ;
  275.         else
  276.         {
  277.             if ( mode & PLUS_WORD_MASK )
  278.                 p_len = 2 ;
  279.             else
  280.                 p_len = 1 ;
  281.         }
  282.         display ( "\t -> property   : $" ) ;
  283.         BYTE_DISPLAY ( p_num ) ;
  284.         display ( " [" ) ;
  285.         while ( p_len-- )
  286.         {
  287.             display ( " $" ) ;
  288.             BYTE_DISPLAY ( *p++ ) ;
  289.         }
  290.         display ( " ]" ) ;
  291.         new_line () ;
  292.     }
  293. }
  294.  
  295. Void
  296. show_objects ( version,opt )
  297. byte    version ;
  298. word    opt ;
  299. {
  300.     extern header                data_head ;
  301.     extern std_object_ptr        std_obj_list ;
  302.     extern plus_object_ptr        plus_obj_list ;
  303.     extern byte_ptr                base_ptr ;
  304.  
  305.     register std_object_ptr        std_obj ;
  306.     register plus_object_ptr    plus_obj ;
  307.     word                        i,j ;
  308.     int                            n_objs ;
  309.  
  310.     display ( "INFOCOM Adventure - Object List." ) ;
  311.     new_line () ;
  312.     new_line () ;
  313.     if ( data_head.z_code_version <= VERSION_3 )
  314.     {
  315.         std_obj = STD_OBJ_ADDR ( 1 ) ;
  316.         n_objs = (( std_obj -> prop_ptr[0] << BITS_PER_BYTE ) + std_obj -> prop_ptr[1] - ( (byte_ptr)std_obj - base_ptr )) / (unsigned int)STD_OBJ_SIZE ;
  317.     }
  318.     else
  319.     {
  320.         plus_obj = PLUS_OBJ_ADDR ( 1 ) ;
  321.         n_objs = (( plus_obj -> prop_ptr[0] << BITS_PER_BYTE ) + plus_obj -> prop_ptr[1] - ( (byte_ptr)plus_obj - base_ptr )) / (unsigned int)PLUS_OBJ_SIZE ;
  322.     }
  323.     print_item ( "Number of Objects: $",(word)n_objs ) ;
  324.     new_line () ;
  325.     for ( i = 1 ; i <= (word)n_objs ; i++ )
  326.     {
  327.         display ( "Object $" ) ;
  328.         hex_display ( i ) ;
  329.         display ( " : " ) ;
  330.  
  331.         if ( version <= VERSION_3 )
  332.         {
  333.             if ( prop_name ( i ) )
  334.                 std_p_obj ( i ) ;
  335.             else
  336.                 display ( "<No Name>" ) ;
  337.             new_line () ;
  338.             display ( "\t -> attributes : " ) ;
  339.             std_obj = STD_OBJ_ADDR ( i ) ;
  340.             for ( j = 0 ; j < 4 ; j++ )
  341.                 bit_byte ( std_obj -> attributes[j] ) ;
  342.             new_line () ;
  343.             print_item ( "\t -> location   : $",(word)std_obj -> location[0] ) ;
  344.             print_item ( "\t -> link       : $",(word)std_obj -> link[0] ) ;
  345.             print_item ( "\t -> holds      : $",(word)std_obj -> holds[0] ) ;
  346.             print_item ( "\t -> prop_ptr   : $",(word)((std_obj -> prop_ptr[0] << BITS_PER_BYTE) | (std_obj -> prop_ptr[1])) ) ;
  347.             if ( opt & SHOW_PROPS )
  348.                 show_std_props ( i ) ;
  349.         }
  350.         else
  351.         {
  352.             if ( prop_name ( i ) )
  353.                 plus_p_obj ( i ) ;
  354.             else
  355.                 display ( "<No Name>" ) ;
  356.             new_line () ;
  357.             display ( "\t -> attributes : " ) ;
  358.             plus_obj = PLUS_OBJ_ADDR ( i ) ;
  359.             for ( j = 0 ; j < 6 ; j++ )
  360.                 bit_byte ( plus_obj -> attributes[j] ) ;
  361.             new_line () ;
  362.             print_item ( "\t -> location   : $",(word)((plus_obj -> location[0] << BITS_PER_BYTE) | (plus_obj -> location[1])) ) ;
  363.             print_item ( "\t -> link       : $",(word)((plus_obj -> link[0] << BITS_PER_BYTE) | (plus_obj -> link[1])) ) ;
  364.             print_item ( "\t -> holds      : $",(word)((plus_obj -> holds[0] << BITS_PER_BYTE) | (plus_obj -> holds[1])) ) ;
  365.             print_item ( "\t -> prop_ptr   : $",(word)((plus_obj -> prop_ptr[0] << BITS_PER_BYTE) | (plus_obj -> prop_ptr[1])) ) ;
  366.             if ( opt & SHOW_PROPS )
  367.                 show_plus_props ( i ) ;
  368.         }
  369.         new_line () ;
  370.     }
  371. }
  372.  
  373. Void
  374. bit_byte ( bits )
  375. byte    bits ;
  376. {
  377.     register byte    i ;
  378.  
  379.     for ( i = FIRST_ATTRIBUTE ; i ; i >>= 1 )
  380.         out_char( bits & i ? '1' : '0' ) ;
  381.     out_char( ' ' ) ;
  382. }
  383.  
  384. Void
  385. show_tree ( version )
  386. byte    version ;
  387. {
  388.     extern header                data_head ;
  389.     extern std_object_ptr        std_obj_list ;
  390.     extern plus_object_ptr        plus_obj_list ;
  391.     extern byte_ptr                base_ptr ;
  392.  
  393.     register std_object_ptr        std_obj ;
  394.     register plus_object_ptr    plus_obj ;
  395.     word                        location ;
  396.     word                        i ;
  397.     int                            n_objs ;
  398.  
  399.     display ( "INFOCOM Adventure - Object Tree." ) ;
  400.     new_line () ;
  401.     new_line () ;
  402.     if ( data_head.z_code_version <= VERSION_3 )
  403.     {
  404.         std_obj = STD_OBJ_ADDR ( 1 ) ;
  405.         n_objs = (( std_obj -> prop_ptr[0] << BITS_PER_BYTE ) + std_obj -> prop_ptr[1] - ( (byte_ptr)std_obj - base_ptr )) / (unsigned int)STD_OBJ_SIZE ;
  406.     }
  407.     else
  408.     {
  409.         plus_obj = PLUS_OBJ_ADDR ( 1 ) ;
  410.         n_objs = (( plus_obj -> prop_ptr[0] << BITS_PER_BYTE ) + plus_obj -> prop_ptr[1] - ( (byte_ptr)plus_obj - base_ptr )) / (unsigned int)PLUS_OBJ_SIZE ;
  411.     }
  412.     print_item ( "Number of Objects: $",(word)n_objs ) ;
  413.     new_line () ;
  414.     new_line () ;
  415.     for ( i = 1 ; i <= (word)n_objs ; i++ )
  416.     {
  417.         if ( version <= VERSION_3 )
  418.         {
  419.             std_obj = STD_OBJ_ADDR ( i ) ;
  420.             location = (word)( std_obj -> location[0] ) ;
  421.         }
  422.         else
  423.         {
  424.             plus_obj = PLUS_OBJ_ADDR ( i ) ;
  425.             location = ( plus_obj -> location[0] << BITS_PER_BYTE ) | ( plus_obj -> location[1] ) ;
  426.         }
  427.         if ( location == 0 )
  428.         {
  429.             obtree ( version,i,0 ) ;
  430.             new_line () ;
  431.         }
  432.     }
  433. }
  434.  
  435. Void
  436. obtree ( version,o1,level )
  437. byte    version ;
  438. word    o1 ;
  439. int        level ;
  440. {
  441.     extern std_object_ptr        std_obj_list ;
  442.     extern plus_object_ptr        plus_obj_list ;
  443.  
  444.     register std_object_ptr        std_obj ;
  445.     register plus_object_ptr    plus_obj ;
  446.     register word                temp ;
  447.     int                            i ;
  448.  
  449.     for ( i = level ; i ; i-- )
  450.         out_char( '\t' ) ;
  451.     display ( "$" ) ;
  452.     hex_display ( o1 ) ;
  453.     display ( " : " ) ;
  454.  
  455.     if ( version <= VERSION_3 )
  456.     {
  457.         if ( prop_name ( o1 ) )
  458.             std_p_obj ( o1 ) ;
  459.         else
  460.             display ( "<No Name>" ) ;
  461.         new_line () ;
  462.         std_obj = STD_OBJ_ADDR ( o1 ) ;
  463.         if ( std_obj -> holds[0] )
  464.             obtree ( version,(word)( std_obj -> holds[0] ),level + 1 ) ;
  465.         if ( std_obj -> link[0] )
  466.             obtree ( version,(word)( std_obj -> link[0] ),level ) ;
  467.     }
  468.     else
  469.     {
  470.         if ( prop_name ( o1 ) )
  471.             plus_p_obj ( o1 ) ;
  472.         else
  473.             display ( "<No Name>" ) ;
  474.         new_line () ;
  475.         plus_obj = PLUS_OBJ_ADDR ( o1 ) ;
  476.         temp = ( plus_obj -> holds[0] << BITS_PER_BYTE ) | ( plus_obj -> holds[1] ) ;
  477.         if ( temp )
  478.             obtree ( version,temp,level+1 ) ;
  479.         temp = ( plus_obj -> link[0] << BITS_PER_BYTE ) | ( plus_obj -> link[1] ) ;
  480.         if ( temp )
  481.             obtree ( version,temp,level ) ;
  482.     }
  483. }
  484.