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

   1 /*
   2  *  Empire - A multi-player, client/server Internet based war game.
   3  *  Copyright (C) 1986-2014, 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  *  torp.c: Fire torpedoes at enemy ships
  28  *
  29  *  Known contributors to this file:
  30  *     Dave Pare
  31  *     Thomas Ruschak, 1992
  32  *     Ken Stevens, 1995
  33  *     Steve McClure, 2000
  34  *     Markus Armbruster, 2004-2010
  35  */
  36
  37 #include <config.h>
  38
  39 #include "chance.h"
  40 #include "commands.h"
  41 #include "news.h"
  42 #include "retreat.h"
  43 #include "ship.h"
  44
  45 static void anti_torp(int f, int ntorping, int vshipown);
  46 static void fire_dchrg(struct shpstr *, struct shpstr *, int);
  47 static int fire_torp(struct shpstr *, struct shpstr *, int);
  48
  49 int
  50 torp(void)
  51 {
  52     natid vshipown;
  53     int range;
  54     int dam;
  55     int subno;
  56     int victno;
  57     int erange;
  58     double hitchance;
  59     struct shpstr vship;
  60     struct shpstr sub;
  61     char *ptr;
  62     struct nstr_item nbst;
  63     char buf[1024];
  64     int ntorping = 0;
  65     char prompt[128];
  66
  67     if (!snxtitem(&nbst, EF_SHIP, player->argp[1], "From ship(s)? "))
  68         return RET_SYN;
  69     while (nxtitem(&nbst, &sub)) {
  70         if (sub.shp_own != player->cnum)
  71             continue;
  72         if ((mchr[(int)sub.shp_type].m_flags & M_TORP) == 0)
  73             continue;
  74         if (sub.shp_item[I_GUN] == 0
  75             || sub.shp_item[I_SHELL] < SHP_TORP_SHELLS)
  76             continue;
  77         if (sub.shp_item[I_MILIT] < 1)
  78             continue;
  79         if (sub.shp_effic < 60)
  80             continue;
  81         if (sub.shp_mobil <= 0)
  82             continue;
  83         ntorping++;
  84     }
  85     pr("%d ships are eligible to torp\n", ntorping);
  86     snxtitem_rewind(&nbst);
  87     while (nxtitem(&nbst, &sub)) {
  88         if (!sub.shp_own)
  89             continue;
  90         if (sub.shp_own != player->cnum) {
  91             continue;
  92         }
  93         if ((mchr[(int)sub.shp_type].m_flags & M_TORP) == 0) {
  94             pr("Ship # %d: A %s can't fire torpedoes!\n",
  95                sub.shp_uid, mchr[(int)sub.shp_type].m_name);
  96             continue;
  97         }
  98         if (sub.shp_item[I_GUN] == 0
  99             || sub.shp_item[I_SHELL] < SHP_TORP_SHELLS) {
 100             pr("Ship #%d has insufficient armament\n", sub.shp_uid);
 101             continue;
 102         }
 103         if (sub.shp_item[I_MILIT] < 1) {
 104             pr("Ship #%d has insufficient crew\n", sub.shp_uid);
 105             continue;
 106         }
 107         if (sub.shp_effic < 60) {
 108             pr("Ship #%d torpedo tubes inoperative.\n", sub.shp_uid);
 109             continue;
 110         }
 111         if (sub.shp_mobil <= 0) {
 112             pr("Ship #%d has insufficient mobility\n", sub.shp_uid);
 113             continue;
 114         }
 115         subno = sub.shp_uid;
 116         sprintf(prompt, "Ship %d, target? ", sub.shp_uid);
 117         if (!(ptr = getstarg(player->argp[2], prompt, buf)))
 118             return RET_SYN;
 119         if (!check_ship_ok(&sub))
 120             return RET_FAIL;
 121         if ((victno = atoi(ptr)) < 0)
 122             return RET_SYN;
 123         if (!getship(victno, &vship))
 124             return RET_FAIL;
 125         if (!vship.shp_own)
 126             return RET_FAIL;
 127         vshipown = vship.shp_own;
 128         if (victno == subno) {
 129             pr("Shooting yourself, eh?  How strange...\n");
 130             continue;
 131         }
 132         if (mchr[(int)vship.shp_type].m_flags & M_SUB) {
 133             if (!(mchr[(int)sub.shp_type].m_flags & M_SUBT)) {
 134                 pr("You can't torpedo a submarine!\n");
 135                 continue;
 136             }
 137         }
 138         dam = shp_torp(&sub, 1);
 139         sub.shp_mission = 0;
 140         putship(sub.shp_uid, &sub);
 141         if (CANT_HAPPEN(dam < 0)) {
 142             pr("Ship #%d has insufficient armament\n", sub.shp_uid);
 143             continue;
 144         }
 145
 146         if ((mchr[(int)sub.shp_type].m_flags & M_SUB) == 0)
 147             anti_torp(sub.shp_uid, ntorping, vshipown);
 148         getship(sub.shp_uid, &sub);
 149         if (sub.shp_own == 0)
 150             continue;
 151
 152         erange = roundrange(torprange(&sub));
 153         pr("Effective torpedo range is %d.0\n", erange);
 154         pr("Whooosh... ");
 155         getship(victno, &vship);
 156         vshipown = vship.shp_own;
 157         range = mapdist(sub.shp_x, sub.shp_y, vship.shp_x, vship.shp_y);
 158         hitchance = shp_torp_hitchance(&sub, range);
 159         if (range <= erange) {
 160             pr("Hitchance = %d%%\n", (int)(hitchance * 100));
 161         }
 162         /* Now, can the torpedo even get there? */
 163         if (!line_of_sight(NULL, sub.shp_x, sub.shp_y,
 164                            vship.shp_x, vship.shp_y)) {
 165             pr("BOOM!... Torpedo slams into land before reaching target.\n");
 166             /* We only tell the victim if we were within range. */
 167             if (range <= erange) {
 168                 if (vshipown != 0)
 169                     wu(0, vshipown, "Torpedo sighted @ %s by %s\n",
 170                        xyas(sub.shp_x, sub.shp_y, vshipown),
 171                        prship(&vship));
 172             }
 173         } else if (range > erange) {
 174             pr("Out of range\n");
 175         } else if (chance(hitchance)) {
 176             pr("BOOM!...\n");
 177             if (vshipown != 0)
 178                 wu(0, vshipown, "%s in %s torpedoed %s for %d damage.\n",
 179                    prsub(&sub), xyas(sub.shp_x, sub.shp_y, vshipown),
 180                    prship(&vship), dam);
 181             if (vship.shp_rflags & RET_TORPED) {
 182                 retreat_ship(&vship, 't');
 183                 shipdamage(&vship, dam);
 184             } else
 185                 shipdamage(&vship, dam);
 186             pr("Torpedo hit %s for %d damage.\n", prship(&vship), dam);
 187
 188             if (vship.shp_effic < SHIP_MINEFF)
 189                 pr("%s sunk!\n", prship(&vship));
 190             putship(vship.shp_uid, &vship);
 191             if (mchr[(int)sub.shp_type].m_flags & M_SUB)
 192                 nreport(vshipown, N_TORP_SHIP, 0, 1);
 193             else
 194                 nreport(vshipown, N_SHIP_TORP, player->cnum, 1);
 195         } else {
 196             pr("Missed\n");
 197             if (vshipown != 0)
 198                 wu(0, vshipown, "Torpedo sighted @ %s by %s\n",
 199                    xyas(sub.shp_x, sub.shp_y, vshipown), prship(&vship));
 200         }
 201
 202         if (mchr[(int)sub.shp_type].m_flags & M_SUB)
 203             anti_torp(sub.shp_uid, ntorping, vshipown);
 204     }
 205     return RET_OK;
 206 }
 207
 208 static void
 209 anti_torp(int f, int ntorping, int vshipown)
 210 {
 211     struct shpstr sub;
 212     struct shpstr dd;
 213     int x;
 214
 215     getship(f, &sub);
 216
 217     if (sub.shp_own == vshipown)
 218         return;
 219
 220     if ((mchr[(int)sub.shp_type].m_flags & M_SUB) == 0)
 221         pr("Starting our attack run...\n");
 222
 223     x = 0;
 224     while (getship(x++, &dd) && sub.shp_effic >= SHIP_MINEFF) {
 225         if (dd.shp_own == 0)
 226             continue;
 227         if (dd.shp_own != vshipown)
 228             continue;
 229
 230         if (!fire_torp(&dd, &sub, ntorping))
 231             fire_dchrg(&dd, &sub, ntorping);
 232     }
 233 }
 234
 235 static void
 236 fire_dchrg(struct shpstr *sp, struct shpstr *targ, int ntargets)
 237 {
 238     int range, erange, dam;
 239
 240     erange = roundrange(shp_fire_range(sp));
 241     range = mapdist(sp->shp_x, sp->shp_y, targ->shp_x, targ->shp_y);
 242     if (range > erange)
 243         return;
 244
 245     if ((mchr[(int)targ->shp_type].m_flags & M_SUB) == 0) {
 246         /* Return fire to a torpedo boat */
 247         if (mchr[sp->shp_type].m_flags & M_SUB)
 248             return;             /* sub deck gun can't return fire */
 249         dam = shp_fire(sp);
 250         putship(sp->shp_uid, sp);
 251         if (dam < 0)
 252             return;
 253         if (ntargets > 2)
 254             dam /= ntargets / 2;
 255
 256         pr_beep();
 257         pr("Kaboom!!! Incoming shells!\n");
 258         if (sp->shp_own != 0)
 259             wu(0, sp->shp_own,
 260                "%s fired at %s\n", prship(sp), prship(targ));
 261         pr_beep();
 262         pr("BLAM! %d damage!\n", dam);
 263     } else {
 264         /* Return fire to a submarine */
 265         dam = shp_dchrg(sp);
 266         putship(sp->shp_uid, sp);
 267         if (dam < 0)
 268             return;
 269         if (ntargets > 2)
 270             dam /= ntargets / 2;
 271
 272         pr("\nCAPTAIN!  !!Depth charges!!...\n");
 273         if (sp->shp_own != 0)
 274             wu(0, sp->shp_own,
 275                "%s depth charged %s\n", prship(sp), prsub(targ));
 276         pr("click...WHAM!  %d damage!\n", dam);
 277     }
 278     shipdamage(targ, dam);
 279     putship(targ->shp_uid, targ);
 280 }
 281
 282 static int
 283 fire_torp(struct shpstr *sp, struct shpstr *targ, int ntargets)
 284 {
 285     int range, erange, dam;
 286
 287     if ((mchr[targ->shp_type].m_flags & M_SUB)
 288         && (mchr[sp->shp_type].m_flags & M_SUBT) == 0)
 289         return 0;               /* need sub-torp to torpedo a sub */
 290
 291     erange = roundrange(torprange(sp));
 292     range = mapdist(sp->shp_x, sp->shp_y, targ->shp_x, targ->shp_y);
 293     if (range > erange)
 294         return 0;
 295
 296     if (!line_of_sight(NULL, sp->shp_x, sp->shp_y,
 297                        targ->shp_x, targ->shp_y))
 298         return 0;
 299     dam = shp_torp(sp, 1);
 300     putship(sp->shp_uid, sp);
 301     if (dam < 0)
 302         return 0;
 303
 304     pr("Captain! Torpedoes sighted!\n");
 305
 306     if (chance(shp_torp_hitchance(sp, range))) {
 307         pr("BOOM!...\n");
 308         if (sp->shp_own != 0)
 309             wu(0, sp->shp_own, "%s @ %s torpedoed %s\n",
 310                prship(sp),
 311                xyas(sp->shp_x, sp->shp_y, sp->shp_own), prsub(targ));
 312         if (ntargets > 2)
 313             dam /= ntargets / 2;
 314
 315         shipdamage(targ, dam);
 316         putship(targ->shp_uid, targ);
 317
 318         if (mchr[(int)sp->shp_type].m_flags & M_SUB)
 319             nreport(targ->shp_own, N_TORP_SHIP, 0, 1);
 320         else
 321             nreport(targ->shp_own, N_SHIP_TORP, sp->shp_own, 1);
 322     } else {
 323         pr("Missed!\n");
 324         if (sp->shp_own != 0)
 325             wu(0, sp->shp_own,
 326                "%s missed %s with a torp at %s\n",
 327                prship(sp), prsub(targ),
 328                xyas(sp->shp_x, sp->shp_y, sp->shp_own));
 329     }
 330
 331     return 1;
 332 }
 333
 334 char *
 335 prsub(struct shpstr *sp)
 336 {
 337     if (mchr[(int)sp->shp_type].m_flags & M_SUB)
 338         return "sub";
 339     else
 340         return prship(sp);
 341 }