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-2012, 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  */
  33
  34 #include <config.h>
  35
  36 #include "commands.h"
  37 #include "map.h"
  38 #include "optlist.h"
  39 #include "path.h"
  40 #include "plane.h"
  41 #include "retreat.h"
  42 #include "ship.h"
  43
  44 static int blankrow(char *);
  45
  46 int
  47 sona(void)
  48 {
  49     struct nstr_item ni, nit;
  50     struct sctstr sect;
  51     struct shpstr ship;
  52     struct shpstr targ;
  53     struct natstr *natp;
  54     struct mchrstr *mcp;
  55     struct mchrstr *tmcp;
  56     struct nstr_sect ns;
  57     int range;
  58     int visib, pingrange;
  59     int srange;
  60     int vrange;
  61     int dist;
  62     int x, y;
  63     int cx, cy;
  64     int changed = 0;
  65     int row;
  66     /* Where these are used are non-re-entrant, so we keep 'em around */
  67     static char **rad = NULL;
  68     static char *radbuf = NULL;
  69     static signed char **vis = NULL;
  70     static signed char *visbuf = NULL;
  71
  72     if (!snxtitem(&ni, EF_SHIP, player->argp[1], NULL))
  73         return RET_SYN;
  74     if (!radbuf)
  75         radbuf = malloc(WORLD_Y * MAPWIDTH(1));
  76     if (!visbuf)
  77         visbuf = malloc(WORLD_Y * MAPWIDTH(1));
  78     if (!rad && radbuf) {
  79         rad = malloc(WORLD_Y * sizeof(char *));
  80         if (rad) {
  81             for (x = 0; x < WORLD_Y; x++) {
  82                 rad[x] = &radbuf[(WORLD_X + 1) * x];
  83             }
  84         }
  85     }
  86     if (!vis && visbuf) {
  87         vis = malloc(WORLD_Y * sizeof(signed char *));
  88         if (vis) {
  89             for (x = 0; x < WORLD_Y; x++) {
  90                 vis[x] = &visbuf[(WORLD_X + 1) * x];
  91             }
  92         }
  93     }
  94     if (!radbuf || !visbuf || !rad || !vis) {
  95         pr("Memory error, tell the deity.\n");
  96         logerror("malloc failed in sona\n");
  97         return RET_FAIL;
  98     }
  99     while (nxtitem(&ni, &ship)) {
 100         if (!player->owner)
 101             continue;
 102         mcp = &mchr[(int)ship.shp_type];
 103         if (!(mcp->m_flags & M_SONAR))
 104             continue;
 105         getsect(ship.shp_x, ship.shp_y, &sect);
 106         if (sect.sct_type != SCT_WATER)
 107             continue;
 108         range = (int)techfact(ship.shp_tech, mcp->m_vrnge);
 109         srange = MIN(7, 7 * range * ship.shp_effic / 200);
 110         pr("%s at %s efficiency %d%%, max range %d\n",
 111            prship(&ship),
 112            xyas(ship.shp_x, ship.shp_y, player->cnum),
 113            ship.shp_effic, srange);
 114         snxtsct_dist(&ns, ship.shp_x, ship.shp_y, srange);
 115         blankfill(radbuf, &ns.range, 1);
 116         while (nxtsct(&ns, &sect)) {
 117             if (player->owner || sect.sct_type == SCT_WATER)
 118                 rad[ns.dy][ns.dx] = dchr[sect.sct_type].d_mnem;
 119             else {
 120                 rad[ns.dy][ns.dx] = '?';
 121             }
 122         }
 123         snxtsct_dist(&ns, ship.shp_x, ship.shp_y, srange);
 124         cx = deltx(&ns.range, ship.shp_x);
 125         cy = delty(&ns.range, ship.shp_y);
 126         while (nxtsct(&ns, &sect)) {
 127             if (!line_of_sight(rad, cx, cy, ns.dx, ns.dy)) {
 128                 rad[ns.dy][ns.dx] = ' ';
 129                 continue;
 130             }
 131             if (ship.shp_tech >= 310 && sect.sct_type == SCT_WATER) {
 132                 if (sect.sct_mines) {
 133                     pr("Sonar detects %d mines in %s!\n",
 134                        sect.sct_mines,
 135                        xyas(sect.sct_x, sect.sct_y, player->cnum));
 136                     rad[ns.dy][ns.dx] = 'X';
 137                 }
 138             }
 139             changed |= map_set(player->cnum, sect.sct_x, sect.sct_y,
 140                                rad[ns.dy][ns.dx], 0);
 141
 142         }
 143         memset(visbuf, 0, (WORLD_Y * (WORLD_X + 1)));
 144         snxtitem_dist(&nit, EF_SHIP, ship.shp_x, ship.shp_y, range);
 145         while (nxtitem(&nit, &targ)) {
 146             if (targ.shp_own == player->cnum || targ.shp_own == 0)
 147                 continue;
 148             tmcp = &mchr[(int)targ.shp_type];
 149             visib = shp_visib(&targ);
 150             pingrange = MIN(7, MAX(visib, 10) * range / 10);
 151             vrange = pingrange * ship.shp_effic / 200;
 152             dist = mapdist(targ.shp_x, targ.shp_y, ship.shp_x, ship.shp_y);
 153             pingrange = (MAX(pingrange, 2) * targ.shp_effic) / 100;
 154             if (dist > pingrange)
 155                 continue;
 156             if (tmcp->m_flags & M_SONAR && targ.shp_own) {
 157                 natp = getnatp(targ.shp_own);
 158                 if (natp->nat_flags & NF_SONAR)
 159                     wu(0, targ.shp_own,
 160                        "Sonar ping from %s detected by %s!\n",
 161                        xyas(ship.shp_x, ship.shp_y,
 162                             targ.shp_own), prship(&targ));
 163                 if (targ.shp_rflags & RET_SONARED) {
 164                     retreat_ship(&targ, 's');
 165                     putship(targ.shp_uid, &targ);
 166                 }
 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 (roll(100) > 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                 roll(100) > pln_identchance(pp, shp_hardtarget(targ),
 279                                             EF_SHIP))
 280                 if (roll(100) > 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 }