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

   1 /*
   2  *  Empire - A multi-player, client/server Internet based war game.
   3  *  Copyright (C) 1986-2007, 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 files README, COPYING and CREDITS in the root of the source
  23  *  tree for related information and legal notices.  It is expected
  24  *  that future projects/authors will amend these files as needed.
  25  *
  26  *  ---
  27  *
  28  *  retr.c: Set retreat conditionals for ships
  29  *
  30  *  Known contributors to this file:
  31  *     Ken Stevens, 1995
  32  *     Steve McClure, 2000
  33  */
  34
  35 #include <config.h>
  36
  37 #include <ctype.h>
  38 #include "commands.h"
  39 #include "land.h"
  40 #include "path.h"
  41 #include "retreat.h"
  42 #include "ship.h"
  43
  44 int
  45 retr(void)
  46 {
  47     char *pq, *fl;
  48     int nships;
  49     struct nstr_item ni;
  50     struct shpstr ship;
  51     int isfleet = 0;
  52     int rflags = -2;
  53     int zero;
  54     unsigned i;
  55     char buf1[1024];
  56     char buf2[1024];
  57
  58     if (!snxtitem(&ni, EF_SHIP, player->argp[1]))
  59         return RET_SYN;
  60     nships = 0;
  61     if (player->argp[1] != NULL)
  62         if (isalpha(player->argp[1][0]))
  63             isfleet = RET_GROUP;
  64     if (player->argp[2] != NULL)
  65         pq = getstarg(player->argp[2], "Retreat path? ", buf1);
  66     else
  67         pq = NULL;
  68
  69     if (pq != NULL) {
  70         fl = getstarg(player->argp[3],
  71                       "Retreat conditions [i|t|s|h|b|d|u|c]? ", buf2);
  72         if (!fl)
  73             return RET_SYN;
  74         rflags = 0 | isfleet;
  75
  76         for (i = 0; i < strlen(fl); i++) {
  77             switch (fl[i]) {
  78             case 'I':
  79             case 'i':
  80                 rflags |= RET_INJURED;
  81                 break;
  82             case 'T':
  83             case 't':
  84                 rflags |= RET_TORPED;
  85                 break;
  86             case 'S':
  87             case 's':
  88                 rflags |= RET_SONARED;
  89                 break;
  90             case 'H':
  91             case 'h':
  92                 rflags |= RET_HELPLESS;
  93                 break;
  94             case 'B':
  95             case 'b':
  96                 rflags |= RET_BOMBED;
  97                 break;
  98             case 'D':
  99             case 'd':
 100                 rflags |= RET_DCHRGED;
 101                 break;
 102             case 'U':
 103             case 'u':
 104                 rflags |= RET_BOARDED;
 105                 break;
 106             case 'C':
 107             case 'c':
 108                 rflags = -1;
 109                 break;
 110             default:
 111                 pr("bad condition\n");
 112                 /* fall through */
 113             case '?':
 114                 pr("i\tretreat when injured\n");
 115                 pr("t\tretreat when torped\n");
 116                 pr("s\tretreat when sonared\n");
 117                 pr("h\tretreat when helpless\n");
 118                 pr("b\tretreat when bombed\n");
 119                 pr("d\tretreat when depth-charged\n");
 120                 pr("u\tretreat when boarded\n");
 121             }
 122         }
 123         if (rflags == isfleet) {
 124             pr("Must give retreat conditions!\n");
 125             return RET_FAIL;
 126         }
 127     }
 128
 129     if (rflags == -1)
 130         pq = NULL;
 131
 132     zero = (rflags == -1);
 133     if (zero)
 134         rflags = 0;
 135
 136     while (nxtitem(&ni, &ship)) {
 137         if (!player->owner || ship.shp_own == 0)
 138             continue;
 139         if (zero)
 140             memset(ship.shp_rpath, 0, sizeof(ship.shp_rpath));
 141
 142         if (pq != NULL) {
 143             strncpy(ship.shp_rpath, pq, sizeof(ship.shp_rpath) - 1);
 144             putship(ship.shp_uid, &ship);
 145         }
 146         if (rflags >= 0) {
 147             ship.shp_rflags = rflags;
 148             putship(ship.shp_uid, &ship);
 149         }
 150         if (nships++ == 0) {
 151             if (player->god)
 152                 pr("own ");
 153             pr("shp#     ship type       x,y   fl path       as flt? flags\n");
 154         }
 155         if (player->god)
 156             pr("%3d ", ship.shp_own);
 157         pr("%4d ", ni.cur);
 158         pr("%-16.16s ", mchr[(int)ship.shp_type].m_name);
 159         prxy("%4d,%-4d ", ship.shp_x, ship.shp_y, player->cnum);
 160         pr("%1.1s", &ship.shp_fleet);
 161         pr(" %-11s", ship.shp_rpath);
 162         if (ship.shp_rflags & RET_GROUP)
 163             pr("Yes     ");
 164         else
 165             pr("        ");
 166         if (ship.shp_rflags & RET_INJURED)
 167             pr("I");
 168         if (ship.shp_rflags & RET_TORPED)
 169             pr("T");
 170         if (ship.shp_rflags & RET_SONARED)
 171             pr("S");
 172         if (ship.shp_rflags & RET_HELPLESS)
 173             pr("H");
 174         if (ship.shp_rflags & RET_BOMBED)
 175             pr("B");
 176         if (ship.shp_rflags & RET_DCHRGED)
 177             pr("D");
 178         if (ship.shp_rflags & RET_BOARDED)
 179             pr("U");
 180         pr("\n");
 181     }
 182     if (nships == 0) {
 183         if (player->argp[1])
 184             pr("%s: No ship(s)\n", player->argp[1]);
 185         else
 186             pr("%s: No ship(s)\n", "");
 187         return RET_FAIL;
 188     } else
 189         pr("%d ship%s\n", nships, splur(nships));
 190     return RET_OK;
 191 }
 192
 193 int
 194 lretr(void)
 195 {
 196     char *pq, *fl;
 197     int nunits;
 198     struct nstr_item ni;
 199     struct lndstr land;
 200     int isarmy = 0;
 201     int rflags = -2;
 202     int zero;
 203     char buf1[1024];
 204     char buf2[1024];
 205     unsigned i;
 206
 207     if (!snxtitem(&ni, EF_LAND, player->argp[1]))
 208         return RET_SYN;
 209     nunits = 0;
 210     if (player->argp[1] != NULL)
 211         if (isalpha(player->argp[1][0]))
 212             isarmy = RET_GROUP;
 213     if (player->argp[2] != NULL)
 214         pq = getstarg(player->argp[2], "Retreat path? ", buf1);
 215     else
 216         pq = NULL;
 217     if (pq != NULL) {
 218         fl = getstarg(player->argp[3], "Retreat conditions [i|h|b|c]? ",
 219                       buf2);
 220         if (!fl)
 221             return RET_SYN;
 222         rflags = 0 | isarmy;
 223
 224         for (i = 0; i < strlen(fl); i++) {
 225             switch (fl[i]) {
 226             case 'I':
 227             case 'i':
 228                 rflags |= RET_INJURED;
 229                 break;
 230             case 'H':
 231             case 'h':
 232                 rflags |= RET_HELPLESS;
 233                 break;
 234             case 'B':
 235             case 'b':
 236                 rflags |= RET_BOMBED;
 237                 break;
 238             case 'C':
 239             case 'c':
 240                 rflags = -1;
 241                 break;
 242             default:
 243                 pr("bad condition\n");
 244                 /* fall through */
 245             case '?':
 246                 pr("i\tretreat when injured\n");
 247                 pr("h\tretreat when helpless\n");
 248                 pr("b\tretreat when bombed\n");
 249             }
 250         }
 251         if (rflags == isarmy) {
 252             pr("Must give retreat conditions!\n");
 253             return RET_FAIL;
 254         }
 255     }
 256
 257     if (rflags == -1)
 258         pq = NULL;
 259
 260     zero = (rflags == -1);
 261     if (zero)
 262         rflags = 0;
 263
 264     while (nxtitem(&ni, &land)) {
 265         if (!player->owner || land.lnd_own == 0)
 266             continue;
 267         if (zero)
 268             memset(land.lnd_rpath, 0, sizeof(land.lnd_rpath));
 269
 270         if (pq != NULL) {
 271             strncpy(land.lnd_rpath, pq, sizeof(land.lnd_rpath) - 1);
 272             putland(land.lnd_uid, &land);
 273         }
 274         if (rflags >= 0) {
 275             land.lnd_rflags = rflags;
 276             putland(land.lnd_uid, &land);
 277         }
 278
 279         if (nunits++ == 0) {
 280             if (player->god)
 281                 pr("own ");
 282             pr("lnd#     unit type       x,y   ar path       as army? flags\n");
 283         }
 284         if (player->god)
 285             pr("%3d ", land.lnd_own);
 286         pr("%4d ", ni.cur);
 287         pr("%-16.16s ", lchr[(int)land.lnd_type].l_name);
 288         prxy("%4d,%-4d ", land.lnd_x, land.lnd_y, player->cnum);
 289         pr("%1.1s", &land.lnd_army);
 290         pr(" %-11s", land.lnd_rpath);
 291         if (land.lnd_rflags & RET_GROUP)
 292             pr("Yes      ");
 293         else
 294             pr("         ");
 295         if (land.lnd_rflags & RET_INJURED)
 296             pr("I");
 297         if (land.lnd_rflags & RET_TORPED)
 298             pr("T");
 299         if (land.lnd_rflags & RET_SONARED)
 300             pr("S");
 301         if (land.lnd_rflags & RET_HELPLESS)
 302             pr("H");
 303         if (land.lnd_rflags & RET_BOMBED)
 304             pr("B");
 305         if (land.lnd_rflags & RET_DCHRGED)
 306             pr("D");
 307         if (land.lnd_rflags & RET_BOARDED)
 308             pr("U");
 309         pr("\n");
 310     }
 311     if (nunits == 0) {
 312         if (player->argp[1])
 313             pr("%s: No unit(s)\n", player->argp[1]);
 314         else
 315             pr("%s: No unit(s)\n", "");
 316         return RET_FAIL;
 317     }
 318     pr("%d unit%s\n", nunits, splur(nunits));
 319     return RET_OK;
 320 }