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

   1 /*
   2  *  Empire - A multi-player, client/server Internet based war game.
   3  *  Copyright (C) 1986-2000, Dave Pare, Jeff Bailey, Thomas Ruschak,
   4  *                           Ken Stevens, Steve McClure
   5  *
   6  *  This program 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 2 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, write to the Free Software
  18  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  *  ---
  21  *
  22  *  See the "LEGAL", "LICENSE", "CREDITS" and "README" files for all the
  23  *  related information and legal notices. It is expected that any future
  24  *  projects/authors will amend these files as needed.
  25  *
  26  *  ---
  27  *
  28  *  tran.c: Transport nuclear devices and planes
  29  *
  30  *  Known contributors to this file:
  31  *     Steve McClure, 2000
  32  *
  33  */
  34
  35 #include <string.h>
  36 #include "misc.h"
  37 #include "player.h"
  38 #include "var.h"
  39 #include "sect.h"
  40 #include "nuke.h"
  41 #include "xy.h"
  42 #include "nsc.h"
  43 #include "plane.h"
  44 #include "ship.h"
  45 #include "file.h"
  46 #include "nat.h"
  47 #include "land.h"
  48 #include "commands.h"
  49
  50 #include <stdio.h>
  51
  52 static int tran_map(s_char *what, coord curx, coord cury, s_char *arg);
  53 static int tran_nuke(void);
  54 static int tran_plane(void);
  55
  56 int
  57 tran(void)
  58 {
  59     s_char *what;
  60     s_char buf[1024];
  61
  62     what =
  63         getstarg(player->argp[1], "transport what (nuke or plane): ", buf);
  64     if (what == 0)
  65         return RET_SYN;
  66     if (*what == 'n')
  67         return tran_nuke();
  68     else if (*what == 'p')
  69         return tran_plane();
  70     return RET_SYN;
  71 }
  72
  73 /*
  74  * Kinda silly; only moves the first nuke.
  75  * Maybe nukes should be made into commodities?
  76  */
  77 static int
  78 tran_nuke(void)
  79 {
  80     struct nchrstr *ncp;
  81     int len;
  82     coord x, y;
  83     coord dstx, dsty;
  84     int found;
  85     s_char *p;
  86     int i;
  87     int nuketype;
  88     int moving;
  89     struct nukstr nuke;
  90     struct sctstr sect;
  91     struct sctstr endsect;
  92     int mcost, dam;
  93     struct nstr_item nstr;
  94     s_char buf[1024];
  95
  96     if (!(p = getstarg(player->argp[2], "from sector : ", buf)))
  97         return RET_SYN;
  98     if (!sarg_xy(p, &x, &y))
  99         return RET_SYN;
 100     if (!getsect(x, y, &sect) || !player->owner) {
 101         pr("Not yours\n");
 102         return RET_FAIL;
 103     }
 104 #if 0
 105     if (!snxtitem_xy(&nstr, EF_NUKE, sect.sct_x, sect.sct_y)) {
 106         pr("There are no nukes in %s\n",
 107            xyas(sect.sct_x, sect.sct_y, player->cnum));
 108         return RET_FAIL;
 109     }
 110 #else
 111     snxtitem_xy(&nstr, EF_NUKE, sect.sct_x, sect.sct_y);
 112 #endif
 113     found = 0;
 114     while (nxtitem(&nstr, (caddr_t)&nuke)) {
 115         if (player->owner) {
 116             found = 1;
 117             break;
 118         }
 119     }
 120     if (!found) {
 121         pr("There are no nukes in %s\n",
 122            xyas(sect.sct_x, sect.sct_y, player->cnum));
 123         return RET_FAIL;
 124     }
 125     if (!(p = getstarg(player->argp[3], "warhead type : ", buf)))
 126         return RET_SYN;
 127     if (!check_sect_ok(&sect))
 128         return RET_FAIL;
 129     len = strlen(p);
 130     for (i = 0, ncp = nchr; i < N_MAXNUKE; i++, ncp++) {
 131         if (strncmp(ncp->n_name, p, len) == 0)
 132             break;
 133     }
 134     if (i >= N_MAXNUKE) {
 135         pr("No such nuke type!\n");
 136         return RET_SYN;
 137     }
 138     nuketype = i;
 139     if (!nuke.nuk_types[nuketype]) {
 140         pr("No %s nukes in %s\n",
 141            ncp->n_name, xyas(sect.sct_x, sect.sct_y, player->cnum));
 142         return RET_FAIL;
 143     }
 144     p = getstarg(player->argp[4], "number of warheads : ", buf);
 145     if (!check_sect_ok(&sect))
 146         return RET_FAIL;
 147     if (p == 0 || *p == 0 || (moving = atoi(p)) < 0)
 148         return RET_FAIL;
 149     if (moving > nuke.nuk_types[nuketype]) {
 150         moving = nuke.nuk_types[nuketype];
 151         if (moving)
 152             pr("only moving %d\n", moving);
 153         else
 154             return RET_FAIL;
 155     }
 156     /*
 157      * military control necessary to move
 158      * goodies in occupied territory.
 159      */
 160     if (sect.sct_oldown != player->cnum) {
 161         int tot_mil = 0;
 162         struct nstr_item ni;
 163         struct lndstr land;
 164         snxtitem_xy(&ni, EF_LAND, sect.sct_x, sect.sct_y);
 165         while (nxtitem(&ni, (s_char *)&land)) {
 166             if (land.lnd_own == player->cnum)
 167                 tot_mil += total_mil(&land);
 168         }
 169         if ((sect.sct_item[I_MILIT] + tot_mil) * 10 < sect.sct_item[I_CIVIL]) {
 170             pr("Military control required to move goods.\n");
 171             return RET_FAIL;
 172         }
 173     }
 174     dam = 0;
 175     mcost = move_ground((s_char *)&nuke, &sect, &endsect,
 176                         (double)ncp->n_weight * moving,
 177                         player->argp[5], tran_map, 0, &dam);
 178
 179     if (mcost < 0)
 180         return 0;
 181
 182     if (mcost > 0)
 183         pr("Total movement cost = %d\n", mcost);
 184     else
 185         pr("No mobility used\n");
 186
 187     dstx = endsect.sct_x;
 188     dsty = endsect.sct_y;
 189     /*
 190      * decrement mobility from src sector
 191      */
 192     getsect(nuke.nuk_x, nuke.nuk_y, &sect);
 193     sect.sct_mobil -= mcost;
 194     if (sect.sct_mobil < 0)
 195         sect.sct_mobil = 0;
 196     putsect(&sect);
 197     /*
 198      * update old nuke
 199      */
 200     if (!getnuke(nuke.nuk_uid, &nuke)) {
 201         pr("Could not find that stockpile again.\n");
 202         return RET_FAIL;
 203     }
 204     if (nuke.nuk_types[nuketype] < moving || nuke.nuk_own != player->cnum) {
 205         pr("Stockpile changed!\n");
 206         return RET_FAIL;
 207     }
 208     nuk_delete(&nuke, nuketype, moving);
 209     nuk_add(dstx, dsty, nuketype, moving);
 210     return RET_OK;
 211 }
 212
 213 static int
 214 tran_plane(void)
 215 {
 216     int srcx, srcy;
 217     int dstx, dsty;
 218     int mcost;
 219     int weight, count;
 220     int first;
 221     int type, dam;
 222     struct nstr_item nstr;
 223     struct plnstr plane;
 224     struct sctstr sect;
 225     struct sctstr endsect;
 226
 227     first = 1;
 228     weight = 0;
 229     count = 0;
 230     if (!snxtitem(&nstr, EF_PLANE, player->argp[2]))
 231         return RET_SYN;
 232     /*
 233      * First do some sanity checks: make sure that they are all in the,
 234      * same sector, not on ships, owned, etc.
 235      * No one could seriously want to move planes in parallel from
 236      * several sectors!
 237      */
 238     while (nxtitem(&nstr, (s_char *)&plane)) {
 239         if (!player->owner)
 240             continue;
 241         type = plane.pln_type;
 242         if (plane.pln_ship >= 0) {
 243             pr("%s is at sea and can't be transported\n", prplane(&plane));
 244             return RET_FAIL;
 245         } else if (plane.pln_harden != 0) {
 246             pr("%s has been hardened and can't be transported\n",
 247                prplane(&plane));
 248             return RET_FAIL;
 249         } else if ((plane.pln_flags & PLN_LAUNCHED) &&
 250                    (plchr[type].pl_flags & P_O)) {
 251             pr("%s is in space and can't be transported\n",
 252                prplane(&plane));
 253             return RET_FAIL;
 254         }
 255         if (first == 1) {
 256             srcx = plane.pln_x;
 257             srcy = plane.pln_y;
 258             first = 0;
 259         } else {
 260             if (plane.pln_x != srcx || plane.pln_y != srcy) {
 261                 pr("All planes must be in the same sector.\n");
 262                 return RET_FAIL;
 263             }
 264         }
 265         weight += plchr[type].pl_lcm + (plchr[type].pl_hcm * 2);
 266         ++count;
 267     }
 268     if (first == 1) {
 269         /* no planes */
 270         return RET_FAIL;
 271     }
 272     getsect(srcx, srcy, &sect);
 273     /*
 274      * military control necessary to move
 275      * goodies in occupied territory.
 276      */
 277     if (sect.sct_oldown != player->cnum) {
 278         int tot_mil = 0;
 279         struct nstr_item ni;
 280         struct lndstr land;
 281         snxtitem_xy(&ni, EF_LAND, sect.sct_x, sect.sct_y);
 282         while (nxtitem(&ni, (s_char *)&land))
 283             tot_mil += total_mil(&land);
 284         if ((sect.sct_item[I_MILIT] + tot_mil) * 10 < sect.sct_item[I_CIVIL]) {
 285             pr("Military control required to move goods.\n");
 286             return RET_FAIL;
 287         }
 288     }
 289     dam = 1;
 290     mcost = move_ground((s_char *)&plane, &sect, &endsect,
 291                         (double)weight,
 292                         player->argp[3], tran_map, 0, &dam);
 293     dam /= count;
 294     if (mcost < 0)
 295         return 0;
 296
 297     dstx = endsect.sct_x;
 298     dsty = endsect.sct_y;
 299     snxtitem_rewind(&nstr);
 300     while (nxtitem(&nstr, (s_char *)&plane)) {
 301         if (!player->owner)
 302             continue;
 303         if (dam) {
 304             planedamage(&plane, dam);
 305             pr("\t%s takes %d\n", prplane(&plane), dam);
 306         }
 307         plane.pln_x = dstx;
 308         plane.pln_y = dsty;
 309         plane.pln_mission = 0;
 310         putplane(plane.pln_uid, &plane);
 311     }
 312     if (mcost > 0)
 313         pr("Total movement cost = %d\n", mcost);
 314     else
 315         pr("No mobility used\n");
 316     sect.sct_mobil -= mcost;
 317     if (sect.sct_mobil < 0)
 318         sect.sct_mobil = 0;
 319     putsect(&sect);
 320     return RET_OK;
 321 }
 322
 323 /*
 324  * Pretty tacky, but it works.
 325  * If more commands start doing this, then
 326  * rewrite map to do the right thing.
 327  */
 328 /* I think this is no longer used, check subs/move.c:move_ground() */
 329 /*ARGSUSED*/
 330 static int
 331 tran_map(s_char *what, coord curx, coord cury, s_char *arg)
 332 {
 333     player->argp[1] = arg;
 334     player->condarg = 0;
 335     return map();
 336 }