home *** CD-ROM | disk | FTP | other *** search
/ Crawly Crypt Collection 2 / crawlyvol2.bin / program / c / itf_src / object.c < prev    next >
C/C++ Source or Header  |  1992-12-22  |  11KB  |  501 lines
  1. /*
  2. **    File:    object.c
  3. **
  4. **    (C)opyright 1987-1992 InfoTaskforce.
  5. */
  6.  
  7. #include    "infocom.h"
  8.  
  9. Void
  10. std_transfer ( o1,o2 )
  11. word    o1 ;
  12. word    o2 ;
  13. {
  14.     extern std_object_ptr        std_obj_list ;
  15.     extern boolean                xfer ;
  16.  
  17.     register std_object_ptr        obj1 ;
  18.     register std_object_ptr        obj2 ;
  19.  
  20.     std_remove_obj ( o1 ) ;
  21.     obj1 = STD_OBJ_ADDR ( o1 ) ;
  22.     obj2 = STD_OBJ_ADDR ( o2 ) ;
  23.     obj1 -> link[0] = obj2 -> holds[0] ;
  24.     obj1 -> location[0] = (byte) o2 ;
  25.     obj2 -> holds[0] = (byte) o1 ;
  26. #ifdef    CHEAT
  27.     if ( xfer )
  28.     { /* patch level 1 installed  --mlk */
  29.         print_char ( (word)'[' ) ;
  30.         std_p_obj ( o1 ) ;
  31.         print_char ( (word)' ' ) ;
  32.         print_char ( (word)'-' ) ;
  33.         print_char ( (word)'>' ) ;
  34.         print_char ( (word)' ' ) ;
  35.         std_p_obj ( o2 ) ;
  36.         print_char ( (word)']' ) ;
  37.         new_line () ;
  38.     }
  39. #endif    /* CHEAT */
  40. }
  41.  
  42. Void
  43. plus_transfer ( o1,o2 )
  44. word    o1 ;
  45. word    o2 ;
  46. {
  47.     extern plus_object_ptr        plus_obj_list ;
  48.     extern boolean                xfer ;
  49.  
  50.     register plus_object_ptr    obj1 ;
  51.     register plus_object_ptr    obj2 ;
  52.  
  53.     plus_remove_obj ( o1 ) ;
  54.     obj1 = PLUS_OBJ_ADDR ( o1 ) ;
  55.     obj2 = PLUS_OBJ_ADDR ( o2 ) ;
  56.     obj1 -> link[0] = obj2 -> holds[0] ;
  57.     obj1 -> link[1] = obj2 -> holds[1] ;
  58.     obj1 -> location[0] = (byte)( o2 >> BITS_PER_BYTE ) ;
  59.     obj1 -> location[1] = (byte) o2 ;
  60.     obj2 -> holds[0] = (byte)( o1 >> BITS_PER_BYTE ) ;
  61.     obj2 -> holds[1] = (byte) o1 ;
  62. #ifdef    CHEAT
  63.     if ( xfer )
  64.     { /* patch level 1 installed  -mlk */
  65.         print_char ( (word)'[' ) ;
  66.         plus_p_obj ( o1 ) ;
  67.         print_char ( (word)' ' ) ;
  68.         print_char ( (word)'-' ) ;
  69.         print_char ( (word)'>' ) ;
  70.         print_char ( (word)' ' ) ;
  71.         plus_p_obj ( o2 ) ;
  72.         print_char ( (word)']' ) ;
  73.         new_line () ;
  74.     }
  75. #endif    /* CHEAT */
  76. }
  77.  
  78. Void
  79. std_remove_obj ( obj_num )
  80. word    obj_num ;
  81. {
  82.     extern std_object_ptr        std_obj_list ;
  83.  
  84.     register std_object_ptr        obj1 ;
  85.     register std_object_ptr        obj2 ;
  86.  
  87.     obj1 = STD_OBJ_ADDR ( obj_num ) ;
  88.     if ( obj1 -> location[0] != 0 )
  89.     {
  90.         obj2 = STD_OBJ_ADDR ((word)(obj1 -> location[0])) ;
  91.         if ( obj2 -> holds[0] == (byte)obj_num )
  92.             obj2 -> holds[0] = obj1 -> link[0] ;
  93.         else
  94.         {
  95.             obj2 = STD_OBJ_ADDR ((word)(obj2 -> holds[0])) ;
  96.             while ( obj2 -> link[0] != (byte)obj_num )
  97.                 obj2 = STD_OBJ_ADDR ((word)(obj2 -> link[0])) ;
  98.             obj2 -> link[0] = obj1 -> link[0] ;
  99.         }
  100.         obj1 -> location[0] = 0 ;
  101.         obj1 -> link[0] = 0 ;
  102.     }
  103. }
  104.  
  105. Void
  106. plus_remove_obj ( obj_num )
  107. word    obj_num ;
  108. {
  109.     extern plus_object_ptr        plus_obj_list ;
  110.  
  111.     register plus_object_ptr    obj1 ;
  112.     register plus_object_ptr    obj2 ;
  113.     register word                temp ;
  114.  
  115.     obj1 = PLUS_OBJ_ADDR ( obj_num ) ;
  116.     temp = ((obj1 -> location[0]) << BITS_PER_BYTE) | (obj1 -> location[1]) ;
  117.     if ( temp != 0 )
  118.     {
  119.         obj2 = PLUS_OBJ_ADDR ( temp ) ;
  120.         temp = ((obj2 -> holds[0]) << BITS_PER_BYTE) | (obj2 -> holds[1]) ;
  121.         if ( temp == obj_num )
  122.         {
  123.             obj2 -> holds[0] = obj1 -> link[0] ;
  124.             obj2 -> holds[1] = obj1 -> link[1] ;
  125.         }
  126.         else
  127.         {
  128.             temp = ((obj2 -> holds[0]) << BITS_PER_BYTE) | (obj2 -> holds[1]) ;
  129.             obj2 = PLUS_OBJ_ADDR ( temp ) ;
  130.             temp = ((obj2 -> link[0]) << BITS_PER_BYTE) | (obj2 -> link[1]) ;
  131.             while ( temp != obj_num )
  132.             {
  133.                 obj2 = PLUS_OBJ_ADDR ( temp ) ;
  134.                 temp = ((obj2 -> link[0]) << BITS_PER_BYTE) | (obj2 -> link[1]);
  135.             }
  136.             obj2 -> link[0] = obj1 -> link[0] ;
  137.             obj2 -> link[1] = obj1 -> link[1] ;
  138.         }
  139.         obj1 -> location[0] = 0 ;
  140.         obj1 -> location[1] = 0 ;
  141.         obj1 -> link[0] = 0 ;
  142.         obj1 -> link[1] = 0 ;
  143.     }
  144. }
  145.  
  146. Void
  147. std_test_attr ( obj_num,attr )
  148. word    obj_num ;
  149. word    attr ;
  150. {
  151.     extern std_object_ptr        std_obj_list ;
  152.     extern boolean                attribute ;
  153.  
  154.     register std_object_ptr        obj ;
  155.     register byte                attr_bit ;
  156.     register int                i ;
  157.  
  158.     obj = STD_OBJ_ADDR ( obj_num ) ;
  159.     attr_bit = FIRST_ATTRIBUTE ;
  160.     for ( i = 0 ; i < (int)(attr % BITS_PER_BYTE) ; i++ )
  161.         attr_bit >>= 1 ;
  162. #ifdef    CHEAT
  163.     if ( attribute )
  164.     { /* patch level 1 installed  --mlk */
  165.         print_char ( (word)'[' ) ;
  166.         std_p_obj ( obj_num ) ;
  167.         print_char ( (word)'(' ) ;
  168.         print_num ( attr ) ;
  169.         print_char ( (word)')' ) ;
  170.         print_char ( (word)' ' ) ;
  171.         print_char ( (word)'=' ) ;
  172.         print_char ( (word)'=' ) ;
  173.         print_char ( (word)' ' ) ;
  174.         if ( obj -> attributes[attr / BITS_PER_BYTE] & attr_bit )
  175.             print_num ( 1 ) ;
  176.         else
  177.             print_num ( 0 ) ;
  178.         print_char ( (word)']' ) ;
  179.         new_line () ;
  180.     }
  181. #endif    /* CHEAT */
  182.     if ( obj -> attributes[attr / BITS_PER_BYTE] & attr_bit )
  183.         ret_value ( TRUE ) ;
  184.     else
  185.         ret_value ( FALSE ) ;
  186. }
  187.  
  188. Void
  189. plus_test_attr ( obj_num,attr )
  190. word    obj_num ;
  191. word    attr ;
  192. {
  193.     extern plus_object_ptr        plus_obj_list ;
  194.     extern boolean                attribute ;
  195.  
  196.     register plus_object_ptr    obj ;
  197.     register byte                attr_bit ;
  198.     register int                i ;
  199.  
  200.     obj = PLUS_OBJ_ADDR ( obj_num ) ;
  201.     attr_bit = FIRST_ATTRIBUTE ;
  202.     for ( i = 0 ; i < (int)(attr % BITS_PER_BYTE) ; i++ )
  203.         attr_bit >>= 1 ;
  204. #ifdef    CHEAT
  205.     if ( attribute )
  206.     { /* patch level 1 installed  -mlk */
  207.         print_char ( (word)'[' ) ;
  208.         plus_p_obj ( obj_num ) ;
  209.         print_char ( (word)'(' ) ;
  210.         print_num ( attr ) ;
  211.         print_char ( (word)')' ) ;
  212.         print_char ( (word)' ' ) ;
  213.         print_char ( (word)'=' ) ;
  214.         print_char ( (word)'=' ) ;
  215.         print_char ( (word)' ' ) ;
  216.         if ( obj -> attributes[attr / BITS_PER_BYTE] & attr_bit )
  217.             print_num ( 1 ) ;
  218.         else
  219.             print_num ( 0 ) ;
  220.         print_char ( (word)']' ) ;
  221.         new_line () ;
  222.     }
  223. #endif    /* CHEAT */
  224.     if ( obj -> attributes[attr / BITS_PER_BYTE] & attr_bit )
  225.         ret_value ( TRUE ) ;
  226.     else
  227.         ret_value ( FALSE ) ;
  228. }
  229.  
  230. Void
  231. std_set_attr ( obj_num,attr )
  232. word    obj_num ;
  233. word    attr ;
  234. {
  235.     extern std_object_ptr        std_obj_list ;
  236.     extern boolean                attribute ;
  237.  
  238.     register std_object_ptr        obj ;
  239.     register byte                attr_bit ;
  240.     register int                i ;
  241.  
  242.     obj = STD_OBJ_ADDR ( obj_num ) ;
  243.     attr_bit = FIRST_ATTRIBUTE ;
  244.     for ( i = 0 ; i < (int)(attr % BITS_PER_BYTE) ; i++ )
  245.         attr_bit >>= 1 ;
  246.     obj -> attributes[attr / BITS_PER_BYTE] |= attr_bit ;
  247. #ifdef    CHEAT
  248.     if ( attribute )
  249.     { /* patch level 1 installed  -mlk */
  250.         print_char ( (word)'[' ) ;
  251.         std_p_obj ( obj_num ) ;
  252.         print_char ( (word)'(' ) ;
  253.         print_num ( attr ) ;
  254.         print_char ( (word)')' ) ;
  255.         print_char ( (word)' ' ) ;
  256.         print_char ( (word)':' ) ;
  257.         print_char ( (word)'=' ) ;
  258.         print_char ( (word)' ' ) ;
  259.         print_num ( 1 ) ;
  260.         print_char ( (word)']' ) ;
  261.         new_line () ;
  262.     }
  263. #endif    /* CHEAT */
  264. }
  265.  
  266. Void
  267. plus_set_attr ( obj_num,attr )
  268. word    obj_num ;
  269. word    attr ;
  270. {
  271.     extern plus_object_ptr        plus_obj_list ;
  272.     extern boolean                attribute ;
  273.  
  274.     register plus_object_ptr    obj ;
  275.     register byte                attr_bit ;
  276.     register int                i ;
  277.  
  278.     obj = PLUS_OBJ_ADDR ( obj_num ) ;
  279.     attr_bit = FIRST_ATTRIBUTE ;
  280.     for ( i = 0 ; i < (int)(attr % BITS_PER_BYTE) ; i++ )
  281.         attr_bit >>= 1 ;
  282.     obj -> attributes[attr / BITS_PER_BYTE] |= attr_bit ;
  283. #ifdef    CHEAT
  284.     if ( attribute )
  285.     { /* patch level 1 installed  -mlk */
  286.         print_char ( (word)'[' ) ;
  287.         plus_p_obj ( obj_num ) ;
  288.         print_char ( (word)'(' ) ;
  289.         print_num ( attr ) ;
  290.         print_char ( (word)')' ) ;
  291.         print_char ( (word)' ' ) ;
  292.         print_char ( (word)':' ) ;
  293.         print_char ( (word)'=' ) ;
  294.         print_char ( (word)' ' ) ;
  295.         print_num ( 1 ) ;
  296.         print_char ( (word)']' ) ;
  297.         new_line () ;
  298.     }
  299. #endif    /* CHEAT */
  300. }
  301.  
  302. Void
  303. std_clr_attr ( obj_num,attr )
  304. word    obj_num ;
  305. word    attr ;
  306. {
  307.     extern std_object_ptr        std_obj_list ;
  308.     extern boolean                attribute ;
  309.  
  310.     register std_object_ptr        obj ;
  311.     register byte                attr_bit ;
  312.     register int                i ;
  313.  
  314.     obj = STD_OBJ_ADDR ( obj_num ) ;
  315.     attr_bit = FIRST_ATTRIBUTE ;
  316.     for ( i = 0 ; i < (int)(attr % BITS_PER_BYTE) ; i++ )
  317.         attr_bit >>= 1 ;
  318.     obj -> attributes[attr / BITS_PER_BYTE] &= ( ~attr_bit ) ;
  319. #ifdef    CHEAT
  320.     if ( attribute )
  321.     { /* patch level 1 installed  -mlk */
  322.         print_char ( (word)'[' ) ;
  323.         std_p_obj ( obj_num ) ;
  324.         print_char ( (word)'(' ) ;
  325.         print_num ( attr ) ;
  326.         print_char ( (word)')' ) ;
  327.         print_char ( (word)' ' ) ;
  328.         print_char ( (word)':' ) ;
  329.         print_char ( (word)'=' ) ;
  330.         print_char ( (word)' ' ) ;
  331.         print_num ( 0 ) ;
  332.         print_char ( (word)']' ) ;
  333.         new_line () ;
  334.     }
  335. #endif    /* CHEAT */
  336. }
  337.  
  338. Void
  339. plus_clr_attr ( obj_num,attr )
  340. word    obj_num ;
  341. word    attr ;
  342. {
  343.     extern plus_object_ptr        plus_obj_list ;
  344.     extern boolean                attribute ;
  345.  
  346.     register plus_object_ptr    obj ;
  347.     register byte                attr_bit ;
  348.     register int                i ;
  349.  
  350.     obj = PLUS_OBJ_ADDR ( obj_num ) ;
  351.     attr_bit = FIRST_ATTRIBUTE ;
  352.     for ( i = 0 ; i < (int)(attr % BITS_PER_BYTE) ; i++ )
  353.         attr_bit >>= 1 ;
  354.     obj -> attributes[attr / BITS_PER_BYTE] &= ( ~attr_bit ) ;
  355. #ifdef    CHEAT
  356.     if ( attribute )
  357.     { /* level 1 patch installed  -mlk */
  358.         print_char ( (word)'[' ) ;
  359.         plus_p_obj ( obj_num ) ;
  360.         print_char ( (word)'(' ) ;
  361.         print_num ( attr ) ;
  362.         print_char ( (word)')' ) ;
  363.         print_char ( (word)' ' ) ;
  364.         print_char ( (word)':' ) ;
  365.         print_char ( (word)'=' ) ;
  366.         print_char ( (word)' ' ) ;
  367.         print_num ( 0 ) ;
  368.         print_char ( (word)']' ) ;
  369.         new_line () ;
  370.     }
  371. #endif    /* CHEAT */
  372. }
  373.  
  374. Void
  375. std_get_loc ( obj_num )
  376. word    obj_num ;
  377. {
  378.     extern std_object_ptr        std_obj_list ;
  379.  
  380.     register std_object_ptr        obj ;
  381.  
  382.     obj = STD_OBJ_ADDR ( obj_num ) ;
  383.     store ((word)(obj -> location[0])) ;
  384. }
  385.  
  386. Void
  387. plus_get_loc ( obj_num )
  388. word    obj_num ;
  389. {
  390.     extern plus_object_ptr        plus_obj_list ;
  391.  
  392.     register plus_object_ptr    obj ;
  393.  
  394.     obj = PLUS_OBJ_ADDR ( obj_num ) ;
  395.     store ((word)((obj -> location[0]) << BITS_PER_BYTE )|(obj -> location[1]));
  396. }
  397.  
  398. Void
  399. std_get_holds ( obj_num )
  400. word    obj_num ;
  401. {
  402.     extern std_object_ptr        std_obj_list ;
  403.  
  404.     register std_object_ptr        obj ;
  405.     register word                temp ;
  406.  
  407.     obj = STD_OBJ_ADDR ( obj_num ) ;
  408.     temp = (word)( obj -> holds[0] ) ;
  409.     store ( temp ) ;
  410.     if ( temp )
  411.         ret_value ( TRUE ) ;
  412.     else
  413.         ret_value ( FALSE ) ;
  414. }
  415.  
  416. Void
  417. plus_get_holds ( obj_num )
  418. word    obj_num ;
  419. {
  420.     extern plus_object_ptr        plus_obj_list ;
  421.  
  422.     register plus_object_ptr    obj ;
  423.     register word                temp ;
  424.  
  425.     obj = PLUS_OBJ_ADDR ( obj_num ) ;
  426.     temp = ((obj -> holds[0]) << BITS_PER_BYTE ) | (obj -> holds[1]) ;
  427.     store ( temp ) ;
  428.     if ( temp )
  429.         ret_value ( TRUE ) ;
  430.     else
  431.         ret_value ( FALSE ) ;
  432. }
  433.  
  434. Void
  435. std_get_link ( obj_num )
  436. word    obj_num ;
  437. {
  438.     extern std_object_ptr        std_obj_list ;
  439.  
  440.     register std_object_ptr        obj ;
  441.     register word                temp ;
  442.  
  443.     obj = STD_OBJ_ADDR ( obj_num ) ;
  444.     temp = (word)( obj -> link[0] ) ;
  445.     store ( temp ) ;
  446.     if ( temp )
  447.         ret_value ( TRUE ) ;
  448.     else
  449.         ret_value ( FALSE ) ;
  450. }
  451.  
  452. Void
  453. plus_get_link ( obj_num )
  454. word    obj_num ;
  455. {
  456.     extern plus_object_ptr        plus_obj_list ;
  457.  
  458.     register plus_object_ptr    obj ;
  459.     register word                temp ;
  460.  
  461.     obj = PLUS_OBJ_ADDR ( obj_num ) ;
  462.     temp = ((obj -> link[0]) << BITS_PER_BYTE ) | (obj -> link[1]) ;
  463.     store ( temp ) ;
  464.     if ( temp )
  465.         ret_value ( TRUE ) ;
  466.     else
  467.         ret_value ( FALSE ) ;
  468. }
  469.  
  470. Void
  471. std_check_loc ( o1,o2 )
  472. word    o1 ;
  473. word    o2 ;
  474. {
  475.     extern std_object_ptr        std_obj_list ;
  476.  
  477.     register std_object_ptr        obj ;
  478.  
  479.     obj = STD_OBJ_ADDR ( o1 ) ;
  480.     if ( obj -> location[0] == (byte)o2 )
  481.         ret_value ( TRUE ) ;
  482.     else
  483.         ret_value ( FALSE ) ;
  484. }
  485.  
  486. Void
  487. plus_check_loc ( o1,o2 )
  488. word    o1 ;
  489. word    o2 ;
  490. {
  491.     extern plus_object_ptr        plus_obj_list ;
  492.  
  493.     register plus_object_ptr    obj ;
  494.  
  495.     obj = PLUS_OBJ_ADDR ( o1 ) ;
  496.     if ((word)(((obj -> location[0]) << BITS_PER_BYTE ) | (obj -> location[1])) == o2 )
  497.         ret_value ( TRUE ) ;
  498.     else
  499.         ret_value ( FALSE ) ;
  500. }
  501.