home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Source Code 1993 July / THE_SOURCE_CODE_CD_ROM.iso / bsd_srcs / games / sail / pl_6.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-04-08  |  4.8 KB  |  197 lines
  1. /*
  2.  * Copyright (c) 1983 Regents of the University of California.
  3.  * All rights reserved.
  4.  *
  5.  * Redistribution and use in source and binary forms, with or without
  6.  * modification, are permitted provided that the following conditions
  7.  * are met:
  8.  * 1. Redistributions of source code must retain the above copyright
  9.  *    notice, this list of conditions and the following disclaimer.
  10.  * 2. Redistributions in binary form must reproduce the above copyright
  11.  *    notice, this list of conditions and the following disclaimer in the
  12.  *    documentation and/or other materials provided with the distribution.
  13.  * 3. All advertising materials mentioning features or use of this software
  14.  *    must display the following acknowledgement:
  15.  *    This product includes software developed by the University of
  16.  *    California, Berkeley and its contributors.
  17.  * 4. Neither the name of the University nor the names of its contributors
  18.  *    may be used to endorse or promote products derived from this software
  19.  *    without specific prior written permission.
  20.  *
  21.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  22.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  25.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31.  * SUCH DAMAGE.
  32.  */
  33.  
  34. #ifndef lint
  35. static char sccsid[] = "@(#)pl_6.c    5.4 (Berkeley) 6/1/90";
  36. #endif /* not lint */
  37.  
  38. #include "player.h"
  39.  
  40. repair()
  41. {
  42.     char c;
  43.     register char *repairs;
  44.     register struct shipspecs *ptr = mc;
  45.     register int count;
  46.  
  47. #define FIX(x, m) (m - ptr->x > count \
  48.     ? (ptr->x += count, count = 0) : (count -= m - ptr->x, ptr->x = m))
  49.  
  50.     if (repaired || loaded || fired || changed || turned()) {
  51.         Signal("No hands free to repair", (struct ship *)0);
  52.         return;
  53.     }
  54.     c = sgetch("Repair (hull, guns, rigging)? ", (struct ship *)0, 1);
  55.     switch (c) {
  56.         case 'h':
  57.             repairs = &mf->RH;
  58.             break;
  59.         case 'g':
  60.             repairs = &mf->RG;
  61.             break;
  62.         case 'r':
  63.             repairs = &mf->RR;
  64.             break;
  65.         default:
  66.             Signal("Avast heaving!", (struct ship *)0);
  67.             return;
  68.     }
  69.     if (++*repairs >= 3) {
  70.         count = 2;
  71.         switch (c) {
  72.         case 'h': {
  73.             int max = ptr->guns/4;
  74.             if (ptr->hull < max) {
  75.                 FIX(hull, max);
  76.                 Write(W_HULL, ms, 0, ptr->hull, 0, 0, 0);
  77.             }
  78.             break;
  79.             }
  80.         case 'g':
  81.             if (ptr->gunL < ptr->gunR) {
  82.                 int max = ptr->guns/5 - ptr->carL;
  83.                 if (ptr->gunL < max) {
  84.                     FIX(gunL, max);
  85.                     Write(W_GUNL, ms, 0, ptr->gunL,
  86.                         ptr->carL, 0, 0);
  87.                 }
  88.             } else {
  89.                 int max = ptr->guns/5 - ptr->carR;
  90.                 if (ptr->gunR < max) {
  91.                     FIX(gunR, max);
  92.                     Write(W_GUNR, ms, 0, ptr->gunR,
  93.                         ptr->carR, 0, 0);
  94.                 }
  95.             }
  96.             break;
  97.         case 'r':
  98. #define X 2
  99.             if (ptr->rig4 >= 0 && ptr->rig4 < X) {
  100.                 FIX(rig4, X);
  101.                 Write(W_RIG4, ms, 0, ptr->rig4, 0, 0, 0);
  102.             }
  103.             if (count && ptr->rig3 < X) {
  104.                 FIX(rig3, X);
  105.                 Write(W_RIG3, ms, 0, ptr->rig3, 0, 0, 0);
  106.             }
  107.             if (count && ptr->rig2 < X) {
  108.                 FIX(rig2, X);
  109.                 Write(W_RIG2, ms, 0, ptr->rig2, 0, 0, 0);
  110.             }
  111.             if (count && ptr->rig1 < X) {
  112.                 FIX(rig1, X);
  113.                 Write(W_RIG1, ms, 0, ptr->rig1, 0, 0, 0);
  114.             }
  115.             break;
  116.         }
  117.         if (count == 2) {
  118.             Signal("Repairs completed.", (struct ship *)0);
  119.             *repairs = 2;
  120.         } else {
  121.             *repairs = 0;
  122.             blockalarm();
  123.             draw_stat();
  124.             unblockalarm();
  125.         }
  126.     }
  127.     blockalarm();
  128.     draw_slot();
  129.     unblockalarm();
  130.     repaired = 1;
  131. }
  132.  
  133. turned()
  134. {
  135.     register char *p;
  136.  
  137.     for (p = movebuf; *p; p++)
  138.         if (*p == 'r' || *p == 'l')
  139.             return 1;
  140.     return 0;
  141. }
  142.  
  143. loadplayer()
  144. {
  145.     char c;
  146.     register loadL, loadR, ready, load;
  147.  
  148.     if (!mc->crew3) {
  149.         Signal("Out of crew", (struct ship *)0);
  150.         return;
  151.     }
  152.     loadL = mf->loadL;
  153.     loadR = mf->loadR;
  154.     if (!loadL && !loadR) {
  155.         c = sgetch("Load which broadside (left or right)? ",
  156.             (struct ship *)0, 1);
  157.         if (c == 'r')
  158.             loadL = 1;
  159.         else
  160.             loadR = 1;
  161.     }
  162.     if (!loadL && loadR || loadL && !loadR) {
  163.         c = sgetch("Reload with (round, double, chain, grape)? ",
  164.             (struct ship *)0, 1);
  165.         switch (c) {
  166.         case 'r':
  167.             load = L_ROUND;
  168.             ready = 0;
  169.             break;
  170.         case 'd':
  171.             load = L_DOUBLE;
  172.             ready = R_DOUBLE;
  173.             break;
  174.         case 'c':
  175.             load = L_CHAIN;
  176.             ready = 0;
  177.             break;
  178.         case 'g':
  179.             load = L_GRAPE;
  180.             ready = 0;
  181.             break;
  182.         default:
  183.             Signal("Broadside not loaded.",
  184.                 (struct ship *)0);
  185.             return;
  186.         }
  187.         if (!loadR) {
  188.             mf->loadR = load;
  189.             mf->readyR = ready|R_LOADING;
  190.         } else {
  191.             mf->loadL = load;
  192.             mf->readyL = ready|R_LOADING;
  193.         }
  194.         loaded = 1;
  195.     }
  196. }
  197.