git.pond.sub.org Git - empserver/blob - src/lib/commands/sona.c

   1 /*
   2  *  Empire - A multi-player, client/server Internet based war game.
   3  *  Copyright (C) 1986-2020, Dave Pare, Jeff Bailey, Thomas Ruschak,
   4  *                Ken Stevens, Steve McClure, Markus Armbruster
   5  *
   6  *  Empire is free software: you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation, either version 3 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18  *
  19  *  ---
  20  *
  21  *  See files README, COPYING and CREDITS in the root of the source
  22  *  tree for related information and legal notices.  It is expected
  23  *  that future projects/authors will amend these files as needed.
  24  *
  25  *  ---
  26  *
  27  *  sona.c: Sonar from a sub (or other sonar-equipped ship)
  28  *
  29  *  Known contributors to this file:
  30  *     Jim Griffith, 1989
  31  *     Ken Stevens, 1995
  32  *     Markus Armbruster, 2004-2015
  33  */
  34
  35 #include <config.h>
  36
  37 #include "chance.h"
  38 #include "commands.h"
  39 #include "map.h"
  40 #include "optlist.h"
  41 #include "path.h"
  42 #include "plane.h"
  43 #include "retreat.h"
  44 #include "ship.h"
  45
  46 static int blankrow(char *);
  47
  48 int
  49 sona(void)
  50 {
  51     struct nstr_item ni, nit;
  52     struct sctstr sect;
  53     struct shpstr ship;
  54     struct shpstr targ;
  55     struct natstr *natp;
  56     struct mchrstr *mcp;
  57     struct mchrstr *tmcp;
  58     struct nstr_sect ns;
  59     int range;
  60     int visib, pingrange;
  61     int srange;
  62     int vrange;
  63     int dist;
  64     int x, y;
  65     int cx, cy;
  66     int changed = 0;
  67     int row;
  68     /* Where these are used are non-re-entrant, so we keep 'em around */
  69     static char **rad = NULL;
  70     static char *radbuf = NULL;
  71     static signed char **vis = NULL;
  72     static signed char *visbuf = NULL;
  73
  74     if (!snxtitem(&ni, EF_SHIP, player->argp[1], NULL))
  75         return RET_SYN;
  76     if (!radbuf)
  77         radbuf = malloc(WORLD_Y * MAPWIDTH(1));
  78     if (!visbuf)
  79         visbuf = malloc(WORLD_Y * MAPWIDTH(1));
  80     if (!rad && radbuf) {
  81         rad = malloc(WORLD_Y * sizeof(char *));
  82         if (rad) {
  83             for (x = 0; x < WORLD_Y; x++) {
  84                 rad[x] = &radbuf[(WORLD_X + 1) * x];
  85             }
  86         }
  87     }
  88     if (!vis && visbuf) {
  89         vis = malloc(WORLD_Y * sizeof(signed char *));
  90         if (vis) {
  91             for (x = 0; x < WORLD_Y; x++) {
  92                 vis[x] = &visbuf[(WORLD_X + 1) * x];
  93             }
  94         }
  95     }
  96     if (!radbuf || !visbuf || !rad || !vis) {
  97         pr("Memory error, tell the deity.\n");
  98         logerror("malloc failed in sona\n");
  99         return RET_FAIL;
 100     }
 101     while (nxtitem(&ni, &ship)) {
 102         if (!player->owner)
 103             continue;
 104         mcp = &mchr[(int)ship.shp_type];
 105         if (!(mcp->m_flags & M_SONAR))
 106             continue;
 107         getsect(ship.shp_x, ship.shp_y, &sect);
 108         if (sect.sct_type != SCT_WATER)
 109             continue;
 110         range = (int)techfact(ship.shp_tech, mcp->m_vrnge);
 111         srange = MIN(7, 7 * range * ship.shp_effic / 200);
 112         pr("%s at %s efficiency %d%%, max range %d\n",
 113            prship(&ship),
 114            xyas(ship.shp_x, ship.shp_y, player->cnum),
 115            ship.shp_effic, srange);
 116         snxtsct_dist(&ns, ship.shp_x, ship.shp_y, srange);
 117         blankfill(radbuf, &ns.range, 1);
 118         while (nxtsct(&ns, &sect)) {
 119             if (player->owner || sect.sct_type == SCT_WATER)
 120                 rad[ns.dy][ns.dx] = dchr[sect.sct_type].d_mnem;
 121             else {
 122                 rad[ns.dy][ns.dx] = '?';
 123             }
 124         }
 125         snxtsct_dist(&ns, ship.shp_x, ship.shp_y, srange);
 126         cx = deltx(&ns.range, ship.shp_x);
 127         cy = delty(&ns.range, ship.shp_y);
 128         while (nxtsct(&ns, &sect)) {
 129             if (!line_of_sight(rad, cx, cy, ns.dx, ns.dy)) {
 130                 rad[ns.dy][ns.dx] = ' ';
 131                 continue;
 132             }
 133             if (ship.shp_tech >= 310 && sect.sct_type == SCT_WATER) {
 134                 if (sect.sct_mines) {
 135                     pr("Sonar detects %d mines in %s!\n",
 136                        sect.sct_mines,
 137                        xyas(sect.sct_x, sect.sct_y, player->cnum));
 138                     rad[ns.dy][ns.dx] = 'X';
 139                 }
 140             }
 141             changed |= map_set(player->cnum, sect.sct_x, sect.sct_y,
 142                                rad[ns.dy][ns.dx], 0);
 143
 144         }
 145         memset(visbuf, 0, (WORLD_Y * (WORLD_X + 1)));
 146         snxtitem_dist(&nit, EF_SHIP, ship.shp_x, ship.shp_y, range);
 147         while (nxtitem(&nit, &targ)) {
 148             if (targ.shp_own == player->cnum || targ.shp_own == 0)
 149                 continue;
 150             tmcp = &mchr[(int)targ.shp_type];
 151             visib = shp_visib(&targ);
 152             pingrange = MIN(7, MAX(visib, 10) * range / 10);
 153             vrange = pingrange * ship.shp_effic / 200;
 154             dist = mapdist(targ.shp_x, targ.shp_y, ship.shp_x, ship.shp_y);
 155             pingrange = (MAX(pingrange, 2) * targ.shp_effic) / 100;
 156             if (dist > pingrange)
 157                 continue;
 158             if (tmcp->m_flags & M_SONAR && targ.shp_own) {
 159                 natp = getnatp(targ.shp_own);
 160                 if (natp->nat_flags & NF_SONAR)
 161                     wu(0, targ.shp_own,
 162                        "Sonar ping from %s detected by %s!\n",
 163                        xyas(ship.shp_x, ship.shp_y,
 164                             targ.shp_own), prship(&targ));
 165                 if (targ.shp_rflags & RET_SONARED)
 166                     retreat_ship(&targ, targ.shp_own, 's');
 167             }
 168             if (dist > vrange)
 169                 continue;
 170             x = deltx(&ns.range, (int)targ.shp_x);
 171             y = delty(&ns.range, (int)targ.shp_y);
 172             if (rad[y][x] != dchr[SCT_WATER].d_mnem && rad[y][x] != 'X')
 173                 continue;
 174             if (tmcp->m_flags & M_SUB &&
 175                 relations_with(targ.shp_own, player->cnum) < FRIENDLY) {
 176                 if (mcp->m_vrnge + visib < 8)
 177                     pr("Sonar detects sub #%d @ %s\n",
 178                        targ.shp_uid,
 179                        xyas(targ.shp_x, targ.shp_y, player->cnum));
 180                 else if (mcp->m_vrnge + visib < 10)
 181                     pr("Sonar detects %s @ %s\n",
 182                        prship(&targ),
 183                        xyas(targ.shp_x, targ.shp_y, player->cnum));
 184                 else
 185                     pr("Sonar detects %s %s @ %s\n",
 186                        cname(targ.shp_own), prship(&targ),
 187                        xyas(targ.shp_x, targ.shp_y, player->cnum));
 188             } else
 189                 pr("Sonar detects %s %s @ %s\n",
 190                    cname(targ.shp_own), prship(&targ),
 191                    xyas(targ.shp_x, targ.shp_y, player->cnum));
 192
 193             if (visib > vis[y][x]) {
 194                 vis[y][x] = visib;
 195                 /* &~0x20 makes it a cap letter */
 196                 rad[y][x] = (*mchr[(int)targ.shp_type].m_name) & ~0x20;
 197             }
 198         }
 199         if (!player->argp[2]) {
 200             rad[cy][cx] = '0';
 201             for (row = 0; row < ns.range.height; row++)
 202                 if (!blankrow(rad[row]))
 203                     pr("%s\n", rad[row]);
 204         }
 205         pr("\n");
 206
 207     }
 208     if (changed)
 209         writemap(player->cnum);
 210     return RET_OK;
 211 }
 212
 213 void
 214 plane_sona(struct emp_qelem *plane_list, int x, int y,
 215            struct shiplist **head)
 216 {
 217     struct plnstr *pp;
 218     struct plchrstr *pcp;
 219     struct mchrstr *tmcp;
 220     struct shpstr *targ, s;
 221     struct natstr *natp;
 222     struct emp_qelem *qp;
 223     struct emp_qelem *next;
 224     struct plist *ip;
 225     struct sctstr sect;
 226     int found = 0;
 227     int range, i, vis;
 228     int pingrange;
 229     int vrange;
 230     int dist;
 231
 232     getsect(x, y, &sect);
 233     if ((sect.sct_type != SCT_WATER) && (sect.sct_type != SCT_HARBR))
 234         return;
 235     for (qp = plane_list->q_forw; qp != plane_list; qp = next) {
 236         next = qp->q_forw;
 237         ip = (struct plist *)qp;
 238         pp = &ip->plane;
 239         pcp = ip->pcp;
 240         if (!(pcp->pl_flags & P_A))     /* if it isn't an ASW plane */
 241             continue;
 242         range = (int)techfact(pp->pln_tech, (100.0 - pln_acc(pp)) / 10.0);
 243         for (i = 0; getship(i, &s); i++) {
 244             targ = &s;
 245             if (targ->shp_own == pp->pln_own || targ->shp_own == 0)
 246                 continue;
 247             if (on_shiplist(targ->shp_uid, *head))
 248                 continue;
 249             tmcp = &mchr[(int)targ->shp_type];
 250             if (!(tmcp->m_flags & M_SUB))
 251                 continue;
 252             if (!pct_chance(pln_identchance(pp, shp_hardtarget(targ),
 253                                             EF_SHIP)))
 254                 continue;
 255             vis = shp_visib(targ);
 256             pingrange = MAX(vis, 10) * range / 10;
 257             vrange = pingrange * (pp->pln_effic / 200.0);
 258             dist = mapdist(targ->shp_x, targ->shp_y, x, y);
 259             pingrange = (MAX(pingrange, 2) * targ->shp_effic);
 260             pingrange = roundavg(pingrange / 100.0);
 261             if (dist > pingrange)
 262                 continue;
 263             if (tmcp->m_flags & M_SONAR && targ->shp_own) {
 264                 natp = getnatp(targ->shp_own);
 265                 if (natp->nat_flags & NF_SONAR)
 266                     wu(0, targ->shp_own,
 267                        "Sonar ping from %s detected by %s!\n",
 268                        xyas(x, y, targ->shp_own), prship(targ));
 269             }
 270             if ((dist > vrange))
 271                 continue;
 272             add_shiplist(targ->shp_uid, head);
 273             if (!found) {
 274                 pr("Sonar contact in %s\n", xyas(x, y, player->cnum));
 275                 found = 1;
 276             }
 277             if (relations_with(targ->shp_own, pp->pln_own) < FRIENDLY &&
 278                 !pct_chance(pln_identchance(pp, shp_hardtarget(targ),
 279                                             EF_SHIP)))
 280                 if (!pct_chance(pln_identchance(pp, shp_hardtarget(targ),
 281                                                 EF_SHIP)))
 282                     pr("sub #%d %s\n", targ->shp_uid,
 283                        xyas(targ->shp_x, targ->shp_y, player->cnum));
 284                 else
 285                     pr("%s %s\n", prship(targ),
 286                        xyas(targ->shp_x, targ->shp_y, player->cnum));
 287             else
 288                 pr("%s %s @ %s\n", cname(targ->shp_own), prship(targ),
 289                    xyas(targ->shp_x, targ->shp_y, player->cnum));
 290         }
 291     }
 292     if (found)
 293         pr("\n");
 294 }
 295
 296 /*
 297  * line_of_sight() - is there a "straight" all water path from (x,y) to (tx,ty)
 298  * Ken & Irina Stevens, 1995
 299  */
 300
 301 #define DOT(ax,ay,bx,by) ((ax)*(bx) + (ay)*(by))
 302 #define LEN(x,y) ((x)*(x) + (y)*(y))
 303 #define DIST(ax,ay,bx,by) LEN(bx - ax, by -ay)
 304
 305 int
 306 line_of_sight(char **rad, int ax, int ay, int bx, int by)
 307 {
 308     int dxn = XNORM(bx - ax);
 309     int dyn = YNORM(by - ay);
 310     int dx = dxn > WORLD_X / 2 ? dxn - WORLD_X : dxn;
 311     int dy = dyn > WORLD_Y / 2 ? dyn - WORLD_Y : dyn;
 312     int dlen = LEN(dx, dy);
 313     int n;
 314     int cx = 0;
 315     int cy = 0;
 316     int tx, ty;                 /* test point */
 317     double cd_dist = dlen;      /* closest distance from c to vector d */
 318     double md_dist;             /* minimum distance from t to vector d */
 319     double td_dist;             /* distance from t to vector d */
 320     double td_proj;             /* the projection of t onto vector d */
 321     int closest;                /* index of closest */
 322     int blocked = 0;
 323     struct sctstr *sectp;
 324
 325     while (cd_dist) {
 326         if (blocked)
 327             return 0;
 328         md_dist = 100;          /* will always be <= 2 */
 329         closest = -1;
 330         for (n = 1; n <= 6; ++n) {      /* Directions */
 331             tx = cx + diroff[n][0];
 332             ty = cy + diroff[n][1];
 333             if (DIST(tx, ty, dx, dy) >= cd_dist)
 334                 continue;
 335             td_proj = (double)DOT(tx, ty, dx, dy) / dlen;
 336             td_dist = DIST(tx, ty, td_proj * dx, td_proj * dy);
 337             if (td_dist < md_dist) {
 338                 md_dist = td_dist;
 339                 closest = n;
 340             }
 341         }
 342         if (CANT_HAPPEN(closest < 0))
 343             return 0;
 344         cx = cx + diroff[closest][0];
 345         cy = cy + diroff[closest][1];
 346         if (rad) {
 347             blocked = (rad[YNORM(ay + cy)][XNORM(ax + cx)]
 348                        != dchr[SCT_WATER].d_mnem);
 349         } else {
 350             sectp = getsectp((ax + cx), (ay + cy));
 351             if (sectp) {
 352                 if (sectp->sct_type == SCT_WATER ||
 353                     sectp->sct_type == SCT_BSPAN) {
 354                     blocked = 0;
 355                 } else {
 356                     blocked = 1;
 357                 }
 358             }
 359         }
 360         cd_dist = DIST(cx, cy, dx, dy);
 361     }
 362     return 1;
 363 }
 364
 365 static int
 366 blankrow(char *s)
 367 {
 368     while (*s) {
 369         if (*s != ' ')
 370             return 0;
 371         ++s;
 372     }
 373     return 1;
 374 }