sail/dr_2.c

   1 /*      $NetBSD: dr_2.c,v 1.5 1997/10/13 19:43:23 christos 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. All advertising materials mentioning features or use of this software
  16  *    must display the following acknowledgement:
  17  *      This product includes software developed by the University of
  18  *      California, Berkeley and its contributors.
  19  * 4. Neither the name of the University nor the names of its contributors
  20  *    may be used to endorse or promote products derived from this software
  21  *    without specific prior written permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  33  * SUCH DAMAGE.
  34  */
  35
  36 #include <sys/cdefs.h>
  37 #ifndef lint
  38 #if 0
  39 static char sccsid[] = "@(#)dr_2.c      8.1 (Berkeley) 5/31/93";
  40 #else
  41 __RCSID("$NetBSD: dr_2.c,v 1.5 1997/10/13 19:43:23 christos Exp $");
  42 #endif
  43 #endif /* not lint */
  44
  45 #include "driver.h"
  46 #include <stdlib.h>
  47
  48 #define couldwin(f,t) (f->specs->crew2 > t->specs->crew2 * 1.5)
  49
  50 void
  51 thinkofgrapples()
  52 {
  53         struct ship *sp, *sq;
  54         char friendly;
  55
  56         foreachship(sp) {
  57                 if (sp->file->captain[0] || sp->file->dir == 0)
  58                         continue;
  59                 foreachship(sq) {
  60                         friendly = sp->nationality == capship(sq)->nationality;
  61                         if (!friendly) {
  62                                 if (sp->file->struck || sp->file->captured != 0)
  63                                         continue;
  64                                 if (range(sp, sq) != 1)
  65                                         continue;
  66                                 if (grappled2(sp, sq))
  67                                         if (toughmelee(sp, sq, 0, 0))
  68                                                 ungrap(sp, sq);
  69                                         else
  70                                                 grap(sp, sq);
  71                                 else if (couldwin(sp, sq)) {
  72                                         grap(sp, sq);
  73                                         sp->file->loadwith = L_GRAPE;
  74                                 }
  75                         } else
  76                                 ungrap(sp, sq);
  77                 }
  78         }
  79 }
  80
  81 void
  82 checkup()
  83 {
  84         struct ship *sp, *sq;
  85         char explode, sink;
  86
  87         foreachship(sp) {
  88                 if (sp->file->dir == 0)
  89                         continue;
  90                 explode = sp->file->explode;
  91                 sink = sp->file->sink;
  92                 if (explode != 1 && sink != 1)
  93                         continue;
  94                 if (die() < 5)
  95                         continue;
  96                 Write(sink == 1 ? W_SINK : W_EXPLODE, sp, 0, 2, 0, 0, 0);
  97                 Write(W_DIR, sp, 0, 0, 0, 0, 0);
  98                 if (snagged(sp))
  99                         foreachship(sq)
 100                                 cleansnag(sp, sq, 1);
 101                 if (sink != 1) {
 102                         makesignal(sp, "exploding!", (struct ship *)0);
 103                         foreachship(sq) {
 104                                 if (sp != sq && sq->file->dir && range(sp, sq) < 4)
 105                                         table(RIGGING, L_EXPLODE, sp->specs->guns/13, sq, sp, 6);
 106                         }
 107                 } else
 108                         makesignal(sp, "sinking!", (struct ship *)0);
 109         }
 110 }
 111
 112 void
 113 prizecheck()
 114 {
 115         struct ship *sp;
 116
 117         foreachship(sp) {
 118                 if (sp->file->captured == 0)
 119                         continue;
 120                 if (sp->file->struck || sp->file->dir == 0)
 121                         continue;
 122                 if (sp->specs->crew1 + sp->specs->crew2 + sp->specs->crew3 > sp->file->pcrew * 6) {
 123                         Write(W_SIGNAL, sp, 1,
 124                                 (long)"prize crew overthrown", 0, 0, 0);
 125                         Write(W_POINTS, sp->file->captured, 0, sp->file->captured->file->points - 2 * sp->specs->pts, 0, 0, 0);
 126                         Write(W_CAPTURED, sp, 0, -1, 0, 0, 0);
 127                 }
 128         }
 129 }
 130
 131 int
 132 strend(str)
 133 char *str;
 134 {
 135         char *p;
 136
 137         for (p = str; *p; p++)
 138                 ;
 139         return p == str ? 0 : p[-1];
 140 }
 141
 142 void
 143 closeon(from, to, command, ta, ma, af)
 144 struct ship *from, *to;
 145 char command[];
 146 int ma, ta, af;
 147 {
 148         int high;
 149         char temp[10];
 150
 151         temp[0] = command[0] = '\0';
 152         high = -30000;
 153         try(command, temp, ma, ta, af, ma, from->file->dir, from, to, &high, 0);
 154 }
 155
 156 int dtab[] = {0,1,1,2,3,4,4,5};         /* diagonal distances in x==y */
 157
 158 int
 159 score(movement, ship, to, onlytemp)
 160 char movement[];
 161 struct ship *ship, *to;
 162 char onlytemp;
 163 {
 164         char drift;
 165         int row, col, dir, total, ran;
 166         struct File *fp = ship->file;
 167
 168         if ((dir = fp->dir) == 0)
 169                 return 0;
 170         row = fp->row;
 171         col = fp->col;
 172         drift = fp->drift;
 173         move(movement, ship, &fp->dir, &fp->row, &fp->col, &drift);
 174         if (!*movement)
 175                 (void) strcpy(movement, "d");
 176
 177         ran = range(ship, to);
 178         total = -50 * ran;
 179         if (ran < 4 && gunsbear(ship, to))
 180                 total += 60;
 181         if ((ran = portside(ship, to, 1) - fp->dir) == 4 || ran == -4)
 182                 total = -30000;
 183
 184         if (!onlytemp) {
 185                 fp->row = row;
 186                 fp->col = col;
 187                 fp->dir = dir;
 188         }
 189         return total;
 190 }
 191
 192 void
 193 move(p, ship, dir, row, col, drift)
 194 char *p;
 195 struct ship *ship;
 196 unsigned char *dir;
 197 short *row, *col;
 198 char *drift;
 199 {
 200         int dist;
 201         char moved = 0;
 202
 203         for (; *p; p++) {
 204                 switch (*p) {
 205                 case 'r':
 206                         if (++*dir == 9)
 207                                 *dir = 1;
 208                         break;
 209                 case 'l':
 210                         if (--*dir == 0)
 211                                 *dir = 8;
 212                         break;
 213                 case '1': case '2': case '3': case '4':
 214                 case '5': case '6': case '7':
 215                         moved++;
 216                         if (*dir % 2 == 0)
 217                                 dist = dtab[*p - '0'];
 218                         else
 219                                 dist = *p - '0';
 220                         *row -= dr[*dir] * dist;
 221                         *col -= dc[*dir] * dist;
 222                         break;
 223                 }
 224         }
 225         if (!moved) {
 226                 if (windspeed != 0 && ++*drift > 2) {
 227                         if ((ship->specs->class >= 3 && !snagged(ship))
 228                             || (turn & 1) == 0) {
 229                                 *row -= dr[winddir];
 230                                 *col -= dc[winddir];
 231                         }
 232                 }
 233         } else
 234                 *drift = 0;
 235 }
 236
 237 void
 238 try(command, temp, ma, ta, af, vma, dir, f, t, high, rakeme)
 239 struct ship *f, *t;
 240 int ma, ta, af, *high, rakeme;
 241 char command[], temp[];
 242 {
 243         int new, n;
 244         char st[4];
 245 #define rakeyou (gunsbear(f, t) && !gunsbear(t, f))
 246
 247         if ((n = strend(temp)) < '1' || n > '9')
 248                 for (n = 1; vma - n >= 0; n++) {
 249                         (void) sprintf(st, "%d", n);
 250                         (void) strcat(temp, st);
 251                         new = score(temp, f, t, rakeme);
 252                         if (new > *high && (!rakeme || rakeyou)) {
 253                                 *high = new;
 254                                 (void) strcpy(command, temp);
 255                         }
 256                         try(command, temp, ma-n, ta, af, vma-n,
 257                                 dir, f, t, high, rakeme);
 258                         rmend(temp);
 259                 }
 260         if ((ma > 0 && ta > 0 && (n = strend(temp)) != 'l' && n != 'r') || !strlen(temp)) {
 261                 (void) strcat(temp, "r");
 262                 new = score(temp, f, t, rakeme);
 263                 if (new > *high && (!rakeme || (gunsbear(f, t) && !gunsbear(t, f)))) {
 264                         *high = new;
 265                         (void) strcpy(command, temp);
 266                 }
 267                 try(command, temp, ma-1, ta-1, af, min(ma-1, maxmove(f, (dir == 8 ? 1 : dir+1), 0)), (dir == 8 ? 1 : dir+1),f,t,high,rakeme);
 268                 rmend(temp);
 269         }
 270         if ((ma > 0 && ta > 0 && (n = strend(temp)) != 'l' && n != 'r') || !strlen(temp)){
 271                 (void) strcat(temp, "l");
 272                 new = score(temp, f, t, rakeme);
 273                 if (new > *high && (!rakeme || (gunsbear(f, t) && !gunsbear(t, f)))){
 274                         *high = new;
 275                         (void) strcpy(command, temp);
 276                 }
 277                 try(command, temp, ma-1, ta-1, af, (min(ma-1,maxmove(f, (dir-1 ? dir-1 : 8), 0))), (dir-1 ? dir -1 : 8), f, t, high, rakeme);
 278                 rmend(temp);
 279         }
 280 }
 281
 282 void
 283 rmend(str)
 284 char *str;
 285 {
 286         char *p;
 287
 288         for (p = str; *p; p++)
 289                 ;
 290         if (p != str)
 291                 *--p = 0;
 292 }