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