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);
}