empire/empserver
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

sail: Remove option SAIL

Browse source 
SAIL has issues:

* Sail orders are executed at the update.  Crafty players can use them
  to get around the update window.

* The route is fixed at command time.  You can't let the update find
  the best route, like it does for distribution.

* The info pages documenting it amount to almost 100 non-blank lines
  formatted.  They claim you can follow friendly ships.  This is
  wrong.  They also show incorrect follow syntax.  Unlikely to be the
  only errors.

* Few players use it.  Makes it a nice hidey-hole for bugs.  Here are
  two nice ones:

  - If follow's second argument is negative, the code attempts to
    follow an uninitialized ship.  Could well be a remote hole.

  - If ship #1 follows #2 follows #3 follows #2, the update goes into
    an infinite loop.

* It's more than 500 lines of rather crufty code nobody wants to
  touch.  Thanks to a big effort in Empire 2, it shares some code with
  the navigation command.  It still duplicates other navigation code.
  The sharing complicates fixing the bugs demonstrated by
  navi-march-test.

Reviewing, fixing and testing this mess isn't worth the opportunity
cost.  Remove it instead.  Drop commands follow, mquota, sail and
unsail.  Drop ship selectors mquota, path, follow.

struct shpstr shrinks some more, on my system from 160 to 120 bytes.

Signed-off-by: Markus Armbruster <armbru@pond.sub.org>
This commit is contained in:
Markus Armbruster 2014-12-24 21:42:51 +01:00
parent 48e656c057
commit dc73207a99
37 changed files with 297 additions and 1157 deletions
Download patch file Download diff file Expand all files Collapse all files

7
src/lib/commands/edit.c
View file

@ -884,7 +884,7 @@ edit_ship(struct shpstr *ship, char *key, char *p)
{
struct mchrstr *mcp = &mchr[ship->shp_type];
int arg = atoi(p);
int old_uid, ret;
int ret;
switch (*key) {
case 'U':
@ -893,13 +893,8 @@ edit_ship(struct shpstr *ship, char *key, char *p)
case 'E':
case 'M':
case 'F':
old_uid = ship->shp_uid;
ret = edit_unit((struct empobj *)ship, key, p,
SHIP_MINEFF, "fleet", 0);
if (ret == RET_OK && ship->shp_uid != old_uid) {
if (ship->shp_follow == old_uid)
ship->shp_follow = ship->shp_uid;
}
return ret;
case 't':
arg = ef_elt_byname(EF_SHIP_CHR, p);

97
src/lib/commands/foll.c
View file

@ -1,97 +0,0 @@
/*
* Empire - A multi-player, client/server Internet based war game.
* Copyright (C) 1986-2014, Dave Pare, Jeff Bailey, Thomas Ruschak,
* Ken Stevens, Steve McClure, Markus Armbruster
*
* Empire is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* ---
*
* See files README, COPYING and CREDITS in the root of the source
* tree for related information and legal notices. It is expected
* that future projects/authors will amend these files as needed.
*
* ---
*
* foll.c: Set leader of a set of ships
*
* Known contributors to this file:
* Robert Forsman
*/
#include <config.h>
#include "commands.h"
#include "optlist.h"
#include "ship.h"
int
foll(void)
{
struct shpstr ship;
char *cp;
int good, leader, count = 0;
coord x, y;
struct nstr_item nstr;
char buf[1024];
if (!opt_SAIL) {
pr("The SAIL option is not enabled, so this command is not valid.\n");
return RET_FAIL;
}
if (!snxtitem(&nstr, EF_SHIP, player->argp[1], NULL))
return RET_SYN;
cp = getstarg(player->argp[2], "leader? ", buf);
if (!cp)
cp = "";
good = sscanf(cp, "%d", &leader);
if (!good)
return RET_SYN;
getship(leader, &ship);
if (relations_with(ship.shp_own, player->cnum) < FRIENDLY) {
pr("That ship won't let you follow.\n");
return RET_FAIL;
}
x = ship.shp_x;
y = ship.shp_y;
while (nxtitem(&nstr, &ship)) {
if (!player->owner)
continue;
if (ship.shp_x != x || ship.shp_y != y) {
pr("Ship #%d not in same sector as #%d\n",
ship.shp_uid, leader);
continue;
}
if (ship.shp_uid == leader) {
pr("Ship #%d can't follow itself!\n", leader);
continue;
}
count++;
ship.shp_mission = 0;
*ship.shp_path = 'f';
ship.shp_path[1] = 0;
ship.shp_follow = leader;
pr("Ship #%d follows #%d.\n", ship.shp_uid, leader);
putship(ship.shp_uid, &ship);
}
if (count == 0) {
if (player->argp[1])
pr("%s: No ship(s)\n", player->argp[1]);
else
pr("%s: No ship(s)\n", "");
return RET_FAIL;
} else
pr("%d ship%s\n", count, splur(count));
return RET_OK;
}

109
src/lib/commands/mobq.c
View file

@ -1,109 +0,0 @@
/*
* Empire - A multi-player, client/server Internet based war game.
* Copyright (C) 1986-2014, Dave Pare, Jeff Bailey, Thomas Ruschak,
* Ken Stevens, Steve McClure, Markus Armbruster
*
* Empire is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* ---
*
* See files README, COPYING and CREDITS in the root of the source
* tree for related information and legal notices. It is expected
* that future projects/authors will amend these files as needed.
*
* ---
*
* mobq.c: Set the sailing mobility quota for a ship
*
* Known contributors to this file:
* Robert Forsman
*/
#include <config.h>
#include "commands.h"
#include "optlist.h"
#include "ship.h"
int
mobq(void)
{
struct shpstr ship;
char *cp, *oldmq;
int good, mobquota, count = 0;
struct nstr_item nstr;
char buf[1024];
if (!opt_SAIL) {
pr("The SAIL option is not enabled, so this command is not valid.\n");
return RET_FAIL;
}
if (!snxtitem(&nstr, EF_SHIP, player->argp[1], NULL))
return RET_SYN;
oldmq = player->argp[2];
if (oldmq) {
good = sscanf(oldmq, "%d", &mobquota);
if (!good)
return RET_SYN;
if (mobquota < 0 || mobquota > ship_mob_max) {
pr("Bad mobility quota value %d.\n", mobquota);
return RET_SYN;
}
if (mobquota + (ship_mob_scale * (float)etu_per_update) >
ship_mob_max) {
pr("warning: %d less than optimal\n", mobquota);
}
}
while (nxtitem(&nstr, &ship)) {
if (!player->owner)
continue;
if (!oldmq)
pr("Ship #%d at %s. Old value %d.\n", ship.shp_uid,
xyas(ship.shp_x, ship.shp_y, player->cnum),
ship.shp_mobquota);
cp = getstarg(player->argp[2], "mobility quota? ", buf);
if (!cp)
return RET_SYN;
if (!check_ship_ok(&ship))
continue;
good = sscanf(cp, "%d", &mobquota);
if (!good) {
pr("Huh?\n");
continue;
}
if (!oldmq) {
if (mobquota < 0 || mobquota > ship_mob_max) {
pr("Bad mobility quota value %d.\n", mobquota);
continue;
}
if (mobquota + (ship_mob_scale * (float)etu_per_update) >
ship_mob_max) {
pr("warning: %d less than optimal\n", mobquota);
}
}
ship.shp_mobquota = mobquota;
count++;
putship(ship.shp_uid, &ship);
}
if (count == 0) {
if (player->argp[1])
pr("%s: No ship(s)\n", player->argp[1]);
else
pr("%s: No ship(s)\n", "");
return RET_FAIL;
} else
pr("%d ship%s\n", count, splur(count));
return RET_OK;
}

147
src/lib/commands/sail.c
View file

@ -1,147 +0,0 @@
/*
* Empire - A multi-player, client/server Internet based war game.
* Copyright (C) 1986-2014, Dave Pare, Jeff Bailey, Thomas Ruschak,
* Ken Stevens, Steve McClure, Markus Armbruster
*
* Empire is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* ---
*
* See files README, COPYING and CREDITS in the root of the source
* tree for related information and legal notices. It is expected
* that future projects/authors will amend these files as needed.
*
* ---
*
* sail.c: Set sail path for leaders
*
* Known contributors to this file:
* Robert Forsman
*/
#include <config.h>
#include "commands.h"
#include "optlist.h"
#include "path.h"
#include "ship.h"
static int
show_sail(struct nstr_item *nstr)
{
int count = 0;
struct shpstr ship;
while (nxtitem(nstr, &ship)) {
if (!player->owner || ship.shp_own == 0)
continue;
if (count++ == 0) {
if (player->god)
pr("own ");
pr("shp# ship type x,y ");
pr("mobil mobquota follows path\n");
}
if (player->god)
pr("%3d ", ship.shp_own);
pr("%4d ", ship.shp_uid);
pr("%-16.16s ", mchr[(int)ship.shp_type].m_name);
prxy("%4d,%-4d ", ship.shp_x, ship.shp_y);
pr("%3d ", ship.shp_mobil);
pr(" %3d ", ship.shp_mobquota);
pr(" %3d ", ship.shp_follow);
if (ship.shp_path[0]) {
pr("%s", ship.shp_path);
}
pr("\n");
if (ship.shp_name[0] != 0) {
if (player->god)
pr(" ");
pr(" %s\n", ship.shp_name);
}
}
if (count == 0) {
if (player->argp[1])
pr("%s: No ship(s)\n", player->argp[1]);
else
pr("%s: No ship(s)\n", "");
return RET_FAIL;
} else
pr("%d ship%s\n", count, splur(count));
return RET_OK;
}
static int
cmd_unsail_ship(struct nstr_item *nstr)
{
struct shpstr ship;
int count = 0;
while (nxtitem(nstr, &ship)) {
if (!player->owner || ship.shp_own == 0)
continue;
if (ship.shp_path[0]) {
pr("Ship #%d unsailed\n", ship.shp_uid);
count++;
ship.shp_path[0] = 0;
putship(ship.shp_uid, &ship);
}
}
return RET_OK;
}
static int
cmd_sail_ship(struct nstr_item *nstr)
{
char *cp;
struct shpstr ship;
char navpath[MAX_PATH_LEN];
while (nxtitem(nstr, &ship)) {
if (!player->owner || ship.shp_own == 0)
continue;
pr("Ship #%d at %s\n", ship.shp_uid,
xyas(ship.shp_x, ship.shp_y, player->cnum));
cp = getpath(navpath, player->argp[2],
ship.shp_x, ship.shp_y, 0, 0, MOB_SAIL);
if (!cp)
return RET_FAIL;
if (!check_ship_ok(&ship))
continue;
strncpy(ship.shp_path, cp, sizeof(ship.shp_path) - 1);
ship.shp_mission = 0;
putship(ship.shp_uid, &ship);
}
return RET_OK;
}
int
sail(void)
{
char *cp;
struct nstr_item nstr;
if (!opt_SAIL) {
pr("The SAIL option is not enabled, so this command is not valid.\n");
return RET_FAIL;
}
if (!snxtitem(&nstr, EF_SHIP, player->argp[1], NULL))
return RET_SYN;
cp = player->argp[2];
if (*player->argp[0] == 'u' || (cp && !strcmp(cp, "-")))
return cmd_unsail_ship(&nstr);
if (cp && *cp == 'q')
return show_sail(&nstr);
return cmd_sail_ship(&nstr);
}

4
src/lib/common/nsc.c
View file

@ -236,10 +236,6 @@ struct castr ship_ca[] = {
EF_PLAGUE_STAGES, NSC_DEITY},
{"ptime", fldoff(shp_ptime), NSC_SHORT, 0, NULL, EF_BAD, NSC_DEITY},
{"access", fldoff(shp_access), NSC_SHORT, 0, NULL, EF_BAD, 0},
{"mquota", fldoff(shp_mobquota), NSC_UCHAR, 0, NULL, EF_BAD, 0},
{"path", fldoff(shp_path), NSC_STRINGY, MAXSHPPATH, NULL, EF_BAD, 0},
/* follow can point to dead ship; avoid ca_table for now */
{"follow", fldoff(shp_follow), NSC_INT, 0, NULL, EF_BAD, 0},
{"name", fldoff(shp_name), NSC_STRINGY, MAXSHPNAMLEN, NULL,
EF_BAD, 0},
/* should let builder access xbuilt, ybuilt, but can't express that: */

3
src/lib/global/options.c
View file

@ -28,7 +28,7 @@
*
* Known contributors to this file:
* Steve McClure, 1998
* Markus Armbruster, 2005-2011
* Markus Armbruster, 2005-2014
*/
#include <config.h>
@ -56,6 +56,5 @@ int opt_NO_FORT_FIRE = 0;
int opt_NO_PLAGUE = 1;
int opt_RAILWAYS = 1;
int opt_RES_POP = 0;
int opt_SAIL = 1;
int opt_SUPER_BARS = 0;
int opt_TECH_POP = 0;

4
src/lib/player/empmod.c
View file

@ -114,7 +114,6 @@ struct cmndstr player_coms[] = {
{"fleetadd <FLEET> <SHIPS>", 0, flee, C_MOD, NORM},
{"fly <cargo-PLANES> <fighter-PLANES> <ap-SECT> <PATH|DESTINATION> <COM>",
2, fly, C_MOD, NORM + MONEY + CAP},
{"follow <leader> <SHIPS>", 1, foll, C_MOD, NORM + CAP},
{"force", 0, force, C_MOD, GOD},
{"fortify <UNITS> <MOB>", 1, fort, C_MOD, NORM + CAP},
{"give <COMM> <SECTS> <NUM>", 0, give, C_MOD, GOD},
@ -162,7 +161,6 @@ struct cmndstr player_coms[] = {
{"motd", 0, show_motd, 0, 0},
{"move <COMM> <SECT> <NUM> <PATH|DESTINATION>",
1, move, C_MOD, NORM + CAP},
{"mquota <SHIPS> <value>", 2, mobq, C_MOD, NORM + CAP},
{"name <SHIPS> <NAME>", 0, name, C_MOD, NORM},
{"nation [as-COUNTRY]", 0, nati, 0, 0},
{"navigate <SHIPS> <PATH|DESTINATION>", 1, navi, C_MOD, NORM + CAP},
@ -211,7 +209,6 @@ struct cmndstr player_coms[] = {
1, retr, C_MOD, NORM + CAP},
{"route <COMM> <SECTS>", 1, rout, C_MOD, NORM},
{"sabotage <UNITS>", 1, sabo, C_MOD, NORM + MONEY + CAP},
{"sail <SHIPS> <PATH>", 1, sail, C_MOD, NORM + CAP},
{"satellite <PLANE> [<se|sh|l> [?cond&cond&...]]",
1, sate, C_MOD, NORM + CAP},
{"sbmap <SECTS|SHIP> [s|l|n|p|r|t|*|h]", 0, map, C_MOD, NORM},
@ -267,7 +264,6 @@ struct cmndstr player_coms[] = {
{"turn <\"on\"|\"off\"|\"mess\">", 0, turn, C_MOD, GOD},
{"unload <COMM|\"land\"|\"plane\"> <SHIPS> <NUM|UNIT|PLANE>",
1, load, C_MOD, NORM + CAP},
{"unsail <SHIPS>", 1, sail, C_MOD, NORM + CAP},
{"update", 0, upda, 0, 0},
{"upgrade <s|p|l> <SHIPS|PLANES|UNITS>",
1, upgr, C_MOD, NORM + MONEY + CAP},

9
src/lib/subs/retreat.c
View file

@ -136,15 +136,6 @@ retreat_ship1(struct shpstr *sp, char code, int orig)
struct mchrstr *mcp;
int changed;
if (opt_SAIL) {
/* can't retreat a ship that's sailin, bad things happend */
if (*sp->shp_path) {
wu(0, sp->shp_own,
"%s %s,\nbut had sailing orders, and couldn't retreat!\n",
prship(sp), conditions[findcondition(code)].desc[orig]);
return 0;
}
}
/* check crew - uws don't count */
if (sp->shp_item[I_MILIT] == 0 && sp->shp_item[I_CIVIL] == 0) {
wu(0, sp->shp_own,

7
src/lib/subs/shpsub.c
View file

@ -132,13 +132,6 @@ shp_nav(struct emp_qelem *list, double *minmobp, double *maxmobp,
free(mlp);
continue;
}
if (opt_SAIL) {
if (*sp->shp_path && !update_running) {
shp_stays(actor, "has a sail path", mlp);
mpr(actor, "Use `sail <#> -' to reset\n");
continue;
}
}
/* check crew - uws don't count */
if (sp->shp_item[I_MILIT] == 0 && sp->shp_item[I_CIVIL] == 0) {
shp_stays(actor, "is crewless", mlp);

3
src/lib/subs/unitsub.c
View file

@ -338,9 +338,6 @@ unit_wipe_orders(struct empobj *unit)
switch (unit->ef_type) {
case EF_SHIP:
sp = (struct shpstr *)unit;
sp->shp_mobquota = 0;
sp->shp_path[0] = 0;
sp->shp_follow = sp->shp_uid;
sp->shp_rflags = 0;
sp->shp_rpath[0] = 0;
break;

347
src/lib/update/sail.c
View file

@ -1,347 +0,0 @@
/*
* Empire - A multi-player, client/server Internet based war game.
* Copyright (C) 1986-2014, Dave Pare, Jeff Bailey, Thomas Ruschak,
* Ken Stevens, Steve McClure, Markus Armbruster
*
* Empire is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* ---
*
* See files README, COPYING and CREDITS in the root of the source
* tree for related information and legal notices. It is expected
* that future projects/authors will amend these files as needed.
*
* ---
*
* sail.c: Sail ships during the update
*
* Known contributors to this file:
* Doug Hay
* Robert Forsman
* Ken Stevens, 1995
* Steve McClure, 1998-2000
*/
#include <config.h>
#include <math.h>
#include "nsc.h"
#include "path.h"
#include "update.h"
#include "empobj.h"
#include "unit.h"
struct fltelemstr {
int num;
int own;
double mobil, mobcost;
struct fltelemstr *next;
};
struct fltheadstr {
int leader;
signed char real_q;
/* defines for the real_q member */
#define LEADER_VIRTUAL 0
#define LEADER_REAL 1
#define LEADER_WRONGSECT 2
coord x, y;
natid own;
unsigned maxmoves;
struct fltelemstr *head;
struct fltheadstr *next;
};
static void fltp_to_list(struct fltheadstr *, struct emp_qelem *);
static void
cost_ship(struct shpstr *sp, struct fltelemstr *ep, struct fltheadstr *fp)
{
double mobcost = shp_mobcost(sp);
int howfar;
howfar = 0;
if (mobcost > 0) {
howfar = (int)sp->shp_mobil - (int)sp->shp_mobquota;
howfar = ceil((howfar / mobcost));
}
if (howfar < 0)
howfar = 0;
#ifdef SAILDEBUG
wu(0, fp->own,
"Ship #%d can move %d spaces on mobility %d (cost/sect %f)\n",
sp->shp_uid, howfar, sp->shp_mobil, mobcost);
#endif
if ((unsigned)howfar < fp->maxmoves)
fp->maxmoves = howfar;
ep->mobil = sp->shp_mobil;
ep->mobcost = mobcost;
}
static int
sail_find_fleet(struct fltheadstr **head, struct shpstr *sp)
{
struct fltheadstr *fltp;
struct shpstr *ap;
struct fltelemstr *this;
int len = 0;
int follow = -1;
int stop;
char *cp;
if (sp->shp_own == 0)
return 0;
/* If this ship is following, find the head of the follow list. */
for (ap = sp; ap; len++, ap = getshipp(follow)) {
follow = ap->shp_follow;
/* Not same owner */
if (ap->shp_own != sp->shp_own) {
wu(0, sp->shp_own,
"Ship #%d, following #%d, which you don't own.\n",
sp->shp_uid, ap->shp_uid);
return 0;
}
/* Not a follower. */
if (ap->shp_path[0] != 'f')
break;
/* Following itself */
if (follow == ap->shp_uid || follow == sp->shp_uid)
break;
}
if (!ap) {
wu(0, sp->shp_own,
"Ship #%d, following #%d, which you don't own.\n",
sp->shp_uid, follow);
return 0;
}
/* This should prevent infinite loops. */
if (len >= 10) {
wu(0, sp->shp_own,
"Ship #%d, too many follows (circular follow?).\n",
sp->shp_uid);
return 0;
}
for (stop = 0, cp = ap->shp_path; !stop && *cp; cp++) {
switch (*cp) {
case 'y':
case 'u':
case 'g':
case 'j':
case 'b':
case 'n':
case 'h':
case 't':
break;
default:
stop = 1;
}
}
/* we found a non-valid char in the path. */
if (*cp) {
wu(0, ap->shp_own, "invalid char '\\%03o' in path of ship %d\n",
(unsigned char)*cp, ap->shp_uid);
*cp = 0;
}
/* if this ship is not sailing anywhere then ignore it. */
if (!*ap->shp_path)
return 0;
/* Find the fleet structure we belong to. */
for (fltp = *head; fltp && fltp->leader != follow; fltp = fltp->next) ;
if (!fltp) {
fltp = malloc(sizeof(*fltp));
memset(fltp, 0, sizeof(*fltp));
/* Fix the links. */
fltp->next = *head;
*head = fltp;
/* Set the leader. */
fltp->leader = ap->shp_uid;
fltp->real_q = LEADER_REAL;
fltp->x = ap->shp_x;
fltp->y = ap->shp_y;
fltp->own = ap->shp_own;
fltp->maxmoves = 500;
}
/* If the fleet is not in the same sector as us, no go. */
if ((fltp->x != sp->shp_x) || (fltp->y != sp->shp_y)) {
wu(0, sp->shp_own,
"Ship %d not in same sector as its sailing fleet\n",
sp->shp_uid);
fltp->real_q = LEADER_WRONGSECT;
return 0;
}
this = malloc(sizeof(*this));
memset(this, 0, sizeof(*this));
this->num = sp->shp_uid;
this->own = sp->shp_own;
this->next = fltp->head;
fltp->head = this;
cost_ship(sp, this, fltp);
return 1;
}
static int
sail_nav_fleet(struct fltheadstr *fltp)
{
struct fltelemstr *fe;
struct shpstr *sp, ship;
struct sctstr *sectp;
int error = 0;
char *s, *p;
natid own;
struct emp_qelem ship_list;
int dir;
#ifdef SAILDEBUG
switch (fltp->real_q) {
case LEADER_VIRTUAL:
s = "leaderless";
break;
case LEADER_REAL:
s = "real";
break;
case LEADER_WRONGSECT:
s = "scattered";
break;
default:
s = "inconsistent";
}
wu(0, fltp->own,
"Fleet lead by %d is %s, can go %d spaces\n contains ships:",
fltp->leader, s, fltp->maxmoves);
for (fe = fltp->head; fe; fe = fe->next)
wu(0, fltp->own, " %d", fe->num);
wu(0, fltp->own, "\n");
#endif
sectp = getsectp(fltp->x, fltp->y);
for (fe = fltp->head; fe; fe = fe->next) {
sp = getshipp(fe->num);
if (sp->shp_item[I_MILIT] == 0 && sp->shp_item[I_CIVIL] == 0) {
wu(0, fltp->own,
" ship #%d (%s) is crewless and can't go on\n",
fe->num, cname(fe->own));
error = 1;
}
if (shp_check_nav(sp, sectp) == NAV_CANAL) {
wu(0, fltp->own,
"Your ship #%d (%s) is too big to fit through the canal.\n",
fe->num, cname(fe->own));
error = 1;
}
}
if (error)
return 0;
sp = getshipp(fltp->leader);
sectp = getsectp(fltp->x, fltp->y);
if (shp_check_nav(sp, sectp) != NAVOK)
wu(0, fltp->own, "Your fleet lead by %d is trapped by land.\n",
fltp->leader);
sp = getshipp(fltp->leader);
own = sp->shp_own;
fltp_to_list(fltp, &ship_list); /* hack -KHS 1995 */
for (s = sp->shp_path; *s && fltp->maxmoves > 0; s++) {
dir = diridx(*s);
if (0 != shp_nav_one_sector(&ship_list, dir, own, 0))
fltp->maxmoves = 1;
--fltp->maxmoves;
}
shp_nav_put(&ship_list, own);
getship(sp->shp_uid, &ship);
fltp->x = ship.shp_x;
fltp->y = ship.shp_y;
for (p = &ship.shp_path[0]; *s; p++, s++)
*p = *s;
*p = 0;
putship(ship.shp_uid, &ship);
#ifdef SAILDEBUG
if (sp->shp_path[0]) {
wu(0, fltp->own,
"Fleet lead by #%d nav'd to %s, path left = %s\n",
fltp->leader, xyas(fltp->x, fltp->y, fltp->own), &sp->shp_path);
} else
wu(0, fltp->own,
"Fleet lead by #%d nav'd to %s, finished.\n",
fltp->leader, xyas(fltp->x, fltp->y, fltp->own));
wu(0, sp->shp_own, "Ship #%d has %d mobility now.\n",
fe->num, (int)fe->mobil);
#endif
return 1;
}
void
sail_ship(natid cn)
{
struct shpstr *sp;
struct fltheadstr *head = NULL;
struct fltheadstr *fltp;
int n;
for (n = 0; NULL != (sp = getshipp(n)); n++)
if (sp->shp_own == cn) {
sail_find_fleet(&head, sp);
}
/* see what the fleets fall out into */
for (fltp = head; fltp; fltp = fltp->next) {
if (sail_nav_fleet(fltp))
wu(0, fltp->own, "Your fleet lead by ship #%d has reached %s.\n",
fltp->leader, xyas(fltp->x, fltp->y, fltp->own));
}
/* Free up the memory, 'cause I want to. */
for (fltp = head; fltp;) {
struct fltelemstr *fe;
struct fltheadstr *saveh;
saveh = fltp->next;
for (fe = fltp->head; fe;) {
struct fltelemstr *saveel;
saveel = fe->next;
free(fe);
fe = saveel;
}
free(fltp);
fltp = saveh;
}
}
/* The following is a total hack by Ken Stevens to cut down dramatically on repeated code 1995 */
static void
fltp_to_list(struct fltheadstr *fltp, struct emp_qelem *list)
{
struct fltelemstr *fe;
struct ulist *mlp;
emp_initque(list);
for (fe = fltp->head; fe; fe = fe->next) {
mlp = shp_insque(getshipp(fe->num), list);
ef_mark_fresh(EF_SHIP, &mlp->unit.ship);
mlp->mobil = fe->mobil;
}
}

4
src/lib/update/ship.c
View file

@ -82,10 +82,6 @@ prod_ship(int etus, int natnum, struct bp *bp, int build)
np->nat_money = start_money;
}
if (opt_SAIL) {
if (build && !player->simulation) /* make sure to only sail once */
sail_ship(natnum);
}
return k;
}