struct dchrstr *sct_dcp;
struct mchrstr *shp_mcp;
struct lchrstr *lnd_lcp;
- s_char shp_name[MAXSHPNAMLEN];
+ char shp_name[MAXSHPNAMLEN];
int relations_checked;
};
extern int io_inputwaiting(struct iop *);
extern int io_outputwaiting(struct iop *);
extern int io_output(struct iop *, int);
-extern int io_peek(struct iop *, s_char *, int);
-extern int io_read(struct iop *, s_char *, int);
-extern int io_write(struct iop *, s_char *, int, int);
+extern int io_peek(struct iop *, char *, int);
+extern int io_read(struct iop *, char *, int);
+extern int io_write(struct iop *, char *, int, int);
extern int io_output_all(struct iop *);
-extern int io_gets(struct iop *, s_char *, int);
-extern int io_puts(struct iop *, s_char *);
+extern int io_gets(struct iop *, char *, int);
+extern int io_puts(struct iop *, char *);
extern int io_shutdown(struct iop *, int);
extern int io_error(struct iop *);
extern int io_eof(struct iop *);
#else
extern int ioq_makeiov(struct ioqueue *ioq, struct iovec *iov, int cc);
#endif
-extern int ioq_peek(struct ioqueue *ioq, s_char *buf, int cc);
+extern int ioq_peek(struct ioqueue *ioq, char *buf, int cc);
extern int ioq_dequeue(struct ioqueue *ioq, int cc);
-extern void ioq_append(struct ioqueue *ioq, s_char *buf, int cc);
+extern void ioq_append(struct ioqueue *ioq, char *buf, int cc);
extern int ioq_qsize(struct ioqueue *ioq);
-extern int ioq_gets(struct ioqueue *ioq, s_char *buf, int cc);
-extern int ioq_puts(struct ioqueue *ioq, s_char *buf);
+extern int ioq_gets(struct ioqueue *ioq, char *buf, int cc);
+extern int ioq_puts(struct ioqueue *ioq, char *buf);
#endif
extern void lnd_sweep(struct emp_qelem *, int, int, natid);
extern int lnd_interdict(struct emp_qelem *, coord, coord, natid);
extern void lnd_sel(struct nstr_item *, struct emp_qelem *);
-extern void lnd_mess(s_char *, struct llist *);
+extern void lnd_mess(char *, struct llist *);
extern int lnd_check_mines(struct emp_qelem *);
extern double lnd_mobcost(struct lndstr *, struct sctstr *, int);
-extern s_char *lnd_path(int, struct lndstr *, s_char *);
+extern char *lnd_path(int, struct lndstr *, char *);
extern int attack_val(int, struct lndstr *);
extern int total_mil(struct lndstr *);
extern int defense_val(struct lndstr *);
extern int lnd_getmil(struct lndstr *);
-extern void lnd_print(struct llist *, s_char *);
-extern void lnd_delete(struct llist *, s_char *);
+extern void lnd_print(struct llist *, char *);
+extern void lnd_delete(struct llist *, char *);
extern int lnd_take_casualty(int, struct llist *, int);
extern void lnd_submil(struct lndstr *, int);
extern void lnd_takemob(struct emp_qelem *, double);
extern int lnd_spyval(struct lndstr *);
-extern int intelligence_report(int, struct lndstr *, int, s_char *);
+extern int intelligence_report(int, struct lndstr *, int, char *);
extern int count_sect_units(struct sctstr *);
extern void count_units(struct shpstr *);
extern void lnd_count_units(struct lndstr *);
#define MAPWIDTH(persec) ((WORLD_X/2)*(persec + 1)+1)
-extern void blankfill(s_char *, register struct range *, int);
+extern void blankfill(char *, struct range *, int);
/* src/lib/subs/border.c */
extern int map_set(natid, coord, coord, s_char, int);
extern void writebmap(natid);
extern void writemap(natid);
/* src/lib/subs/border.c */
-extern void border(struct range *, s_char *, s_char *);
+extern void border(struct range *, char *, char *);
#define MAP_SHIP bit(0)
#define MAP_LAND bit(1)
/* src/lib/subs/aircombat.c */
extern void ac_planedamage(struct plist *, natid, int, natid, int,
- int, s_char *);
+ int, char *);
extern void ac_intercept(struct emp_qelem *, struct emp_qelem *,
struct emp_qelem *, natid, coord, coord);
extern void ac_combat_headers(natid, natid);
extern void ac_fireflak(struct emp_qelem *, natid, natid, int);
extern int ac_flak_dam(int);
extern void ac_encounter(struct emp_qelem *, struct emp_qelem *, coord,
- coord, s_char *, int, int,
+ coord, char *, int, int,
struct emp_qelem *, struct emp_qelem *);
extern int ac_isflying(struct plnstr *, struct emp_qelem *);
extern int do_evade(struct emp_qelem *, struct emp_qelem *);
extern int count_pop(int);
extern int scuttle_tradeship(struct shpstr *, int);
extern void scuttle_ship(struct shpstr *);
-extern void resnoise(struct sctstr *sptr, int public_amt, s_char *name,
+extern void resnoise(struct sctstr *sptr, int public_amt, char *name,
int old, int new);
extern int line_of_sight(char **rad, int ax, int ay, int bx, int by);
extern void plane_sona(struct emp_qelem *, int, int, struct shiplist **);
-extern s_char *prsub(struct shpstr *);
+extern char *prsub(struct shpstr *);
extern int check_trade(void);
extern int ontradingblock(int, void *);
extern void trdswitchown(int, void *, int);
extern int draw_map(int, s_char, int, struct nstr_sect *);
extern int unit_map(int, int, struct nstr_sect *, s_char *);
extern int bmaps_intersect(natid, natid);
-extern int share_bmap(natid, natid, struct nstr_sect *, s_char, s_char *);
+extern int share_bmap(natid, natid, struct nstr_sect *, char, char *);
/* move.c */
/* in path.h */
/* nstr_subs.c */
extern void bp_enable_cachepath(void);
extern void bp_disable_cachepath(void);
extern void bp_clear_cachepath(void);
-extern s_char *BestDistPath(s_char *, struct sctstr *, struct sctstr *,
- double *, int);
-extern s_char *BestLandPath(s_char *, struct sctstr *, struct sctstr *,
- double *, int);
-extern s_char *BestShipPath(s_char *, int, int, int, int, int);
-extern s_char *BestAirPath(s_char *, int, int, int, int);
-extern double pathcost(struct sctstr *, s_char *, int);
+extern char *BestDistPath(char *, struct sctstr *, struct sctstr *,
+ double *, int);
+extern char *BestLandPath(char *, struct sctstr *, struct sctstr *,
+ double *, int);
+extern char *BestShipPath(char *, int, int, int, int, int);
+extern char *BestAirPath(char *, int, int, int, int);
+extern double pathcost(struct sctstr *, char *, int);
/* res_pop.c */
extern int max_population(float, int, int);
extern int max_pop(float, struct sctstr *);
extern int deltax(int, int);
extern int deltay(int, int);
extern int mapdist(int, int, int, int);
-extern s_char *effadv(int);
-extern int onearg(s_char *, s_char *);
+extern char *effadv(int);
+extern int onearg(char *, char *);
extern int parse(char *, char **, char **, char *, char **);
extern int ldround(double, int);
extern int roundintby(int, int);
extern int scthash(register int, register int, int);
extern int tcp_listen(char *, char *, size_t *);
-extern s_char *numstr(s_char buf[], int n);
+extern char *numstr(char buf[], int n);
/* plur.c */
-extern s_char *esplur(int n);
-extern s_char *splur(int n);
-extern s_char *iesplur(int n);
+extern char *esplur(int n);
+extern char *splur(int n);
+extern char *iesplur(int n);
extern char *plurize(char *buf, int max_len, int n);
/* more in misc.h */
/* login.c */
extern void player_login(void *);
/* nat.c */
-extern int natbyname(s_char *, natid *);
-extern int natpass(int, s_char *);
+extern int natbyname(char *, natid *);
+extern int natpass(int, char *);
/* player.c */
extern struct player *player; /* current player's context */
extern char *praddr(struct player *);
* src/lib/subs/ *.c
*/
/* askyn.c */
-extern int confirm(s_char *);
-extern int askyn(s_char *);
+extern int confirm(char *);
+extern int askyn(char *);
/* bsanct.c */
extern void bsanct(void);
/* caploss.c */
-extern void caploss(struct sctstr *, natid, s_char *);
+extern void caploss(struct sctstr *, natid, char *);
/* chkmoney.c */
-extern int chkmoney(long, long, s_char *);
-extern int check_cost(int, int, long, int *, s_char *);
+extern int chkmoney(long, long, char *);
+extern int check_cost(int, int, long, int *, char *);
/* cnumb.c */
extern int cnumb(char *);
/* coastal.c */
/* getele.c */
extern int getele(char *, char *);
/* land.c */
-extern s_char *prland(struct lndstr *);
+extern char *prland(struct lndstr *);
extern int lnd_postread(int, void *);
extern int lnd_prewrite(int, void *);
extern void lnd_init(int, void *);
extern int asw_shipsatxy(coord, coord, int, int, struct plnstr *,
struct shiplist **);
extern int num_shipsatxy(coord, coord, int, int);
-extern int islist(s_char *);
+extern int islist(char *);
/* src/lib/subs/mission.c */
-extern s_char *mission_name(short);
-extern s_char *nameofitem(struct genitem *, int);
+extern char *mission_name(short);
+extern char *nameofitem(struct genitem *, int);
extern int collateral_damage(coord, coord, int, struct emp_qelem *);
extern int mission_pln_equip(struct plist *, struct ichrstr *, int,
s_char);
-extern int ground_interdict(coord, coord, natid, s_char *);
-extern int unit_interdict(coord, coord, natid, s_char *, int, int);
+extern int ground_interdict(coord, coord, natid, char *);
+extern int unit_interdict(coord, coord, natid, char *, int, int);
extern int off_support(coord, coord, natid, natid);
extern int def_support(coord, coord, natid, natid);
extern int oprange(struct genitem *, int, int *);
/* mslsub.c */
extern int msl_intercept(coord, coord, natid, int, int, int, int);
extern int msl_equip(struct plnstr *);
-extern int msl_hit(struct plnstr *, int, int, int, int, s_char *,
+extern int msl_hit(struct plnstr *, int, int, int, int, char *,
coord, coord, int);
extern void msl_sel(struct emp_qelem *, coord, coord, natid, int,
int, int);
extern int msl_launch_mindam(struct emp_qelem *, coord, coord, int,
- int, int, s_char *, int, int);
+ int, int, char *, int, int);
/* mtch.c */
-extern int comtch(register s_char *, struct cmndstr *, int);
+extern int comtch(char *, struct cmndstr *, int);
/* natarg.c */
extern struct natstr *natargp(char *, char *);
extern int natarg(char *, char *);
/* nxtsct.c */
extern int nxtsct(struct nstr_sect *, struct sctstr *);
/* plane.c */
-extern s_char *prplane(struct plnstr *);
+extern char *prplane(struct plnstr *);
extern int pln_postread(int, void *);
extern int pln_prewrite(int, void *);
extern void pln_init(int, void *);
extern int sct_postread(int, void *);
extern int sct_prewrite(int, void *);
extern void item_prewrite(short *);
-extern int issector(s_char *);
+extern int issector(char *);
/* ship.c */
-extern s_char *prship(struct shpstr *);
+extern char *prship(struct shpstr *);
extern int shp_postread(int, void *);
extern int shp_prewrite(int, void *);
extern void shp_init(int, void *);
extern void shp_sel(struct nstr_item *, struct emp_qelem *);
extern void shp_nav(struct emp_qelem *, double *, double *, int *, natid);
extern int shp_sweep(struct emp_qelem *, int, natid);
-extern s_char *shp_path(int, struct shpstr *, s_char *);
+extern char *shp_path(int, struct shpstr *, char *);
extern void shp_put(struct emp_qelem *, natid);
extern void shp_list(struct emp_qelem *);
extern int shp_check_nav(struct sctstr *, struct shpstr *);
/* deliver.c */
extern void dodeliver(struct sctstr *);
/* distribute.c */
-extern int dodistribute(struct sctstr *, int, s_char *, double, double);
+extern int dodistribute(struct sctstr *, int, char *, double, double);
/* finish.c */
extern void finish_sects(int);
/* human.c */
time_t tel_date; /* when sent */
};
-extern s_char *mailbox(s_char *buf, natid cn);
+extern char *mailbox(char *buf, natid cn);
#endif
extern int trade_check_ok(struct trdstr *, union trdgenstr *);
extern int trade_check_item_ok(union trdgenstr *);
-extern s_char *trade_nameof(struct trdstr *, union trdgenstr *);
+extern char *trade_nameof(struct trdstr *, union trdgenstr *);
extern int trade_desc(struct trdstr *, union trdgenstr *);
extern int trade_getitem(struct trdstr *, union trdgenstr *);
extern long get_couval(int);
struct plnstr pl;
struct plnstr start; /* Used for sanity checking */
struct nukstr nuke;
- s_char *p;
+ char *p;
int pno;
int nuketype;
int found;
struct nstr_item ni;
- s_char buf[1024];
+ char buf[1024];
int disarm = **player->argp == 'd';
- s_char *prompt = disarm ? "Disarm plane: " : "Arm plane: ";
+ char *prompt = disarm ? "Disarm plane: " : "Arm plane: ";
if (!(p = getstarg(player->argp[1], prompt, buf)) || !*p)
return RET_SYN;
{
struct lndstr land;
int count;
- s_char *cp;
- s_char c;
+ char *cp;
+ char c;
struct nstr_item nstr;
struct nstr_item ni;
struct lndstr land2;
- s_char buf[1024];
+ char buf[1024];
cp = getstarg(player->argp[1], "army? ", buf);
if (cp == 0)
int a_spy = 0; /* the best assaulter scout */
double osupport = 1.0; /* assault support */
double dsupport = 1.0; /* defense support */
- s_char *p;
- s_char buf[1024];
+ char *p;
+ char buf[1024];
int n;
int ourtotal;
struct emp_qelem *qp, *next;
double osupport = 1.0; /* attack support */
double dsupport = 1.0; /* defense support */
int last, n;
- s_char *p;
- s_char buf[1024];
+ char *p;
+ char buf[1024];
int rel;
att_combat_init(def, EF_SECTOR);
int
bdes(void)
{
- s_char *p, d;
+ char *p, d;
struct nstr_sect nstr;
struct sctstr sect;
- s_char prompt[128];
- s_char buf[1024];
+ char prompt[128];
+ char buf[1024];
int changed = 0;
if (!snxtsct(&nstr, player->argp[1]))
best(void)
{
double cost;
- s_char *s;
+ char *s;
struct sctstr s1, s2;
struct nstr_sect nstr, nstr2;
- s_char buf[1024];
+ char buf[1024];
if (!snxtsct(&nstr, player->argp[1]))
return RET_SYN;
struct lndstr land;
struct nstr_item ni;
int foundland;
- s_char *p;
- s_char buf[1024];
+ char *p;
+ char buf[1024];
att_combat_init(def, EF_SHIP);
/*
int
bomb(void)
{
- s_char *p;
+ char *p;
int mission_flags;
coord tx, ty;
coord ax, ay;
int ap_to_target;
struct ichrstr *ip;
- s_char flightpath[MAX_PATH_LEN];
+ char flightpath[MAX_PATH_LEN];
struct nstr_item ni_bomb;
struct nstr_item ni_esc;
struct sctstr target;
struct emp_qelem esc_list;
int wantflags;
struct sctstr ap_sect;
- s_char mission;
+ char mission;
int rel;
struct natstr *natp;
- s_char buf[1024];
+ char buf[1024];
wantflags = 0;
if (!snxtitem(&ni_bomb, EF_PLANE, player->argp[1]))
int nships;
int type;
int bad;
- s_char *p;
+ char *p;
struct plist *plp;
int nsubs;
int nunits;
struct natstr *natp;
int rel;
- s_char buf[1024];
+ char buf[1024];
int i;
bad = 0;
struct plist *plp;
struct mchrstr *mcp;
int dam;
- s_char *q;
+ char *q;
int n;
struct emp_qelem *qp;
int shipno;
struct shpstr ship;
int nships = 0;
struct shiplist *head = NULL;
- s_char buf[1024];
- s_char prompt[128];
+ char buf[1024];
+ char prompt[128];
int hitchance;
int nukedam;
int flak;
plane_bomb(struct emp_qelem *list, struct sctstr *target)
{
int dam;
- s_char *q;
+ char *q;
int n;
natid own;
struct plnstr plane;
int planeno;
int ignore;
struct plist *plp;
- s_char prompt[128];
- s_char buf[1024];
+ char prompt[128];
+ char buf[1024];
int hitchance;
int nukedam;
int nplanes;
land_bomb(struct emp_qelem *list, struct sctstr *target)
{
int dam;
- s_char *q;
+ char *q;
int n;
natid own;
- s_char prompt[128];
- s_char buf[1024];
+ char prompt[128];
+ char buf[1024];
struct lndstr land;
struct emp_qelem *qp;
int unitno;
int flak)
{
int disp;
- s_char dmess[255];
+ char dmess[255];
int eff;
struct shpstr ship;
struct lndstr land;
struct mchrstr *mp;
struct plchrstr *pp;
struct nchrstr *np;
- s_char *p;
+ char *p;
int gotsect = 0;
int built;
int number;
- s_char buf[1024];
+ char buf[1024];
natp = getnatp(player->cnum);
if ((p =
if (player->argp[4]) {
number = atoi(player->argp[4]);
if (number > 20) {
- s_char bstr[80];
+ char bstr[80];
sprintf(bstr,
"Are you sure that you want to build %s of them? ",
player->argp[4]);
int newx, newy;
int avail;
int nx, ny, i, good = 0;
- s_char *p;
- s_char buf[1024];
+ char *p;
+ char buf[1024];
if (opt_EASY_BRIDGES == 0) { /* must have a bridge head or tower */
if (sp->sct_type != SCT_BTOWER) {
int val;
int newx, newy;
int avail;
- s_char *p;
- s_char buf[1024];
+ char *p;
+ char buf[1024];
int good;
int i;
int nx;
time_t now;
double tally;
double canspend;
- s_char buf[1024];
+ char buf[1024];
if (!opt_MARKET) {
pr("The market is disabled.\n");
natid to;
int n;
int is_sector = 0, is_ship = 0;
- s_char *p;
+ char *p;
struct nstr_sect ns;
struct nstr_item ni;
struct natstr *natp;
- s_char buf[1024];
+ char buf[1024];
if ((p = getstarg(player->argp[1], "Cede what? ", buf)) == 0)
return RET_SYN;
int
chan(void)
{
- s_char *temp;
+ char *temp;
struct natstr *natp;
- register s_char *p;
+ char *p;
natid cn;
int charge;
int nonb;
int btucost;
- s_char buf[1024];
+ char buf[1024];
struct natstr *us;
if ((p =
comm(void)
{
struct sctstr sect;
- s_char dirstr[12];
+ char dirstr[12];
int nsect;
int n;
struct nstr_sect nstr;
struct ltcomstr {
int type; /* EF_LOAN or EF_TREATY */
int num; /* number */
- s_char *name; /* "loan" or "treaty" */
- s_char *Name; /* "Loan" or "Treaty" */
+ char *name; /* "loan" or "treaty" */
+ char *Name; /* "Loan" or "Treaty" */
natid proposer; /* country offering */
natid proposee; /* country offered to */
natid mailee; /* who gets mail about it */
cons_choose(struct ltcomstr *ltcp)
{
static int lon_or_trt[] = { EF_LOAN, EF_TREATY, EF_BAD };
- s_char *p;
+ char *p;
struct lonstr *lp;
struct trtstr *tp;
- s_char prompt[128];
- s_char buf[1024];
+ char prompt[128];
+ char buf[1024];
memset(ltcp, 0, sizeof(*ltcp));
if (getstarg(player->argp[1], "loan or treaty? ", buf) == 0)
int nsect;
int n;
struct nstr_sect nstr;
- s_char dirstr[12];
+ char dirstr[12];
if (!snxtsct(&nstr, player->argp[1]))
return RET_SYN;
int rel;
int who;
struct nstr_item ni;
- s_char *p;
- s_char buf[1024];
+ char *p;
+ char buf[1024];
if (!(p = getstarg(player->argp[1],
"alliance, friendly, neutrality, hostility, or war? ",
int thresh;
int sx, sy;
struct nstr_sect nstr;
- s_char buf[1024];
- s_char prompt[128];
- s_char *p;
+ char buf[1024];
+ char prompt[128];
+ char *p;
if ((ich = whatitem(player->argp[1], "deliver what? ")) == 0)
return RET_SYN;
*/
static long do_demo(struct natstr *natp, struct nstr_sect nstr, int number,
- s_char *p, int for_real);
+ char *p, int for_real);
int
demo(void)
long cash;
long cost;
int number;
- s_char *p;
- s_char buf[1024];
+ char *p;
+ char buf[1024];
struct nstr_sect nstr;
natp = getnatp(player->cnum);
}
static long
-do_demo(struct natstr *natp, struct nstr_sect nstr, int number, s_char *p,
+do_demo(struct natstr *natp, struct nstr_sect nstr, int number, char *p,
int for_real)
{
struct sctstr sect;
#include "optlist.h"
#include "commands.h"
-static long do_desi(struct natstr *natp, s_char *sects, s_char *deschar,
+static long do_desi(struct natstr *natp, char *sects, char *deschar,
long int cash, int for_real);
int
}
static long
-do_desi(struct natstr *natp, s_char *sects, s_char *deschar, long int cash,
+do_desi(struct natstr *natp, char *sects, char *deschar, long int cash,
int for_real)
{
int n;
- s_char *p;
+ char *p;
int breaksanct;
int cap_x;
int cap_y;
struct nstr_sect nstr;
struct sctstr sect;
struct sctstr check;
- s_char prompt[128];
- s_char buf[1024];
+ char prompt[128];
+ char buf[1024];
long cost = 0;
int changed = 0;
int warned = 0;
{
struct sctstr sect, dsect, tsect;
struct nstr_sect nstr;
- s_char *path, *p;
+ char *path, *p;
double move_cost = 0.0;
coord dstx, dsty;
- s_char buf[1024];
+ char buf[1024];
if (!snxtsct(&nstr, player->argp[1]))
return RET_SYN;
coord ax, ay;
int ap_to_target;
struct ichrstr *ip;
- s_char flightpath[MAX_PATH_LEN];
+ char flightpath[MAX_PATH_LEN];
struct nstr_item ni_bomb;
struct nstr_item ni_esc;
struct sctstr target;
struct emp_qelem esc_list;
int wantflags;
struct sctstr ap_sect;
- s_char buf[1024];
+ char buf[1024];
wantflags = 0;
if (!snxtitem(&ni_bomb, EF_PLANE, player->argp[1]))
dump(void)
{
struct sctstr sect;
- s_char dirstr[20];
+ char dirstr[20];
int nsect;
int n, i;
struct nstr_sect nstr;
int milwant;
int totalmil;
long reserve;
- s_char *p;
+ char *p;
int quota;
- s_char prompt[128];
- s_char buf[1024];
+ char prompt[128];
+ char buf[1024];
if (!snxtsct(&nstr, player->argp[1]))
return RET_SYN;
{
struct shpstr ship;
int count;
- s_char *cp;
- s_char c;
+ char *cp;
+ char c;
struct nstr_item nstr;
struct nstr_item ni;
struct shpstr ship2;
- s_char buf[1024];
+ char buf[1024];
cp = getstarg(player->argp[1], "fleet? ", buf);
if (cp == 0)
coord ax, ay;
int ap_to_target;
struct ichrstr *ip;
- s_char flightpath[MAX_PATH_LEN];
+ char flightpath[MAX_PATH_LEN];
struct shpstr ship;
int cno;
struct nstr_item ni_bomb;
struct sctstr ap_sect;
int dst_type;
s_char *dst_ptr;
- s_char buf[1024];
+ char buf[1024];
wantflags = 0;
if (!snxtitem(&ni_bomb, EF_PLANE, player->argp[1]))
foll(void)
{
struct shpstr ship;
- s_char *cp;
+ char *cp;
int good, leader, count = 0;
coord x, y;
struct nstr_item nstr;
- s_char buf[1024];
+ char buf[1024];
if (!opt_SAIL) {
pr("The SAIL option is not enabled, so this command is not valid.\n");
struct nstr_item ni;
struct lndstr land;
int fort_amt, hard_amt;
- s_char *p;
- s_char buf[1024];
+ char *p;
+ char buf[1024];
if (!snxtitem(&ni, EF_LAND, player->argp[1]))
return RET_SYN;
int type;
struct mchrstr *mp;
struct lchrstr *lcp;
- s_char *p;
+ char *p;
int fueled;
int land_fuel, ship_fuel;
int oil_amt, pet_amt, fuel_amt, tot_fuel, max_amt;
int harbor, sector;
int fuelled_ship = -1;
struct nstr_item tender, ltender;
- s_char prompt[128];
- s_char buf[1024];
+ char prompt[128];
+ char buf[1024];
if (opt_FUEL == 0) {
pr("Option 'FUEL' not enabled\n");
int amt;
struct ichrstr *ip;
int m, n;
- s_char *p;
+ char *p;
struct nstr_sect nstr;
- s_char buf[1024];
+ char buf[1024];
if (!(ip = whatitem(player->argp[1], "which commodity? ")))
return RET_SYN;
{
struct nstr_sect nstr;
struct sctstr sect;
- s_char *p;
+ char *p;
int i, n, qty;
int avail;
- s_char buf[1024];
+ char buf[1024];
double grind_eff = 0.8;
if ((p = getstarg(player->argp[1], "Sectors? ", buf)) == 0)
struct plchrstr *pcp;
struct plnstr pln;
int level;
- s_char *p;
+ char *p;
int hcm;
int n;
struct nstr_item ni;
struct sctstr sect;
- s_char buf[1024];
+ char buf[1024];
long cash;
struct natstr *natp;
struct sctstr sect;
int nsect;
struct nstr_sect nstr;
- s_char *p;
- s_char buf[1024];
- s_char inbuf[128];
+ char *p;
+ char buf[1024];
+ char inbuf[128];
int type;
int value;
int ovalue;
#include "commands.h"
#include "optlist.h"
-static s_char *
-lowerit(s_char *buf, int n, s_char *orig)
+static char *
+lowerit(char *buf, int n, char *orig)
{ /* converts a string to lower case */
/* lower case output buffer */
/* size of output buffer */
/* input strig */
int i;
- s_char *tmp;
+ char *tmp;
tmp = buf;
memset(buf, 0, n);
for (i = 0; i < n && *orig; i++) {
int
info(void)
{
- s_char buf[255];
+ char buf[255];
FILE *fp;
- s_char *name;
- s_char *tmp_name;
+ char *name;
+ char *tmp_name;
struct stat statb;
struct dirent *dp;
- s_char filename[1024];
- s_char last[256];
+ char filename[1024];
+ char last[256];
DIR *info_dp;
int nmatch = 0;
int width = 0;
apro(void)
{
FILE *fp;
- s_char *name, *lbp;
- s_char *fbuf;
- s_char *lbuf;
+ char *name, *lbp;
+ char *fbuf;
+ char *lbuf;
struct dirent *dp;
- s_char filename[1024];
+ char filename[1024];
DIR *info_dp;
long nf, nhf, nl, nlhl, nhl, nll;
int alreadyhit;
return RET_OK;
}
-#else
+#else /* _WIN32 */
int
info(void)
{
- s_char buf[255];
+ char buf[255];
FILE *fp;
- s_char *name;
- s_char *tmp_name;
- s_char filename[1024];
- s_char last[256];
+ char *name;
+ char *tmp_name;
+ char filename[1024];
+ char last[256];
int nmatch = 0;
int width = 0;
char sep;
HANDLE hDir;
WIN32_FIND_DATA fData;
FILE *fp;
- s_char *name, *lbp;
- s_char *fbuf;
- s_char *lbuf;
- s_char filename[1024];
+ char *name, *lbp;
+ char *fbuf;
+ char *lbuf;
+ char filename[1024];
long nf, nhf, nl, nlhl, nhl, nll;
int alreadyhit;
int lhitlim;
return RET_OK;
}
-#endif
+#endif /* _WIN32 */
launch_as(struct plnstr *pp)
{
coord sx, sy;
- s_char *cp, buf[1024];
+ char *cp, buf[1024];
struct plnstr plane;
struct nstr_item ni;
int goodtarget;
struct plchrstr *pcp = plchr + pp->pln_type;
coord sx, sy;
int n, dam;
- s_char *cp;
+ char *cp;
struct mchrstr *mcp;
struct shpstr target_ship;
struct sctstr sect;
int nukedam;
int rel;
struct natstr *natp;
- s_char buf[1024];
+ char buf[1024];
if (pcp->pl_flags & P_MAR)
cp = getstarg(player->argp[2], "Target ship? ", buf);
int i;
int dist;
int dir;
- s_char *cp;
- s_char *p;
- s_char buf[1024];
+ char *cp;
+ char *p;
+ char buf[1024];
pr("\n");
cp = getstarg(player->argp[2], "Target sector? ", buf);
int a_spy = 0; /* the best boarder scout */
struct sctstr sect;
struct lndstr land;
- s_char *p;
- s_char buf[1024];
+ char *p;
+ char buf[1024];
att_combat_init(def, EF_LAND);
/*
struct sctstr sect;
struct shpstr ship;
int retval;
- s_char *p;
- s_char buf[1024];
+ char *p;
+ char buf[1024];
if (!(p = getstarg(player->argp[1],
"What commodity (or 'plane' or 'land')? ", buf))
struct sctstr sect;
struct lndstr land;
int retval;
- s_char *p;
- s_char buf[1024];
+ char *p;
+ char buf[1024];
if (!(p = getstarg(player->argp[1],
"What commodity (or 'plane' or 'land')? ", buf))
struct nstr_item ni;
struct plnstr pln;
int loaded = 0;
- s_char buf[1024];
- s_char *p;
- s_char prompt[512];
+ char buf[1024];
+ char *p;
+ char prompt[512];
struct mchrstr *mcp = mchr + sp->shp_type;
if (!(mcp->m_flags & (M_CHOPPER | M_XLIGHT | M_FLY | M_MSL))) {
struct lndstr land;
struct plnstr plane;
int loaded = 0;
- s_char *p;
- s_char prompt[512];
- s_char buf[1024];
+ char *p;
+ char prompt[512];
+ char buf[1024];
int load_spy = 0;
count_units(sp);
struct mchrstr *mcp = &mchr[(int)sp->shp_type];
int ship_amt, ship_max, sect_amt, move_amt;
int amount;
- s_char prompt[512];
- s_char *p;
- s_char buf[1024];
+ char prompt[512];
+ char *p;
+ char buf[1024];
sprintf(prompt, "Number of %s to %s %s at %s? ",
ich->i_name,
struct nstr_item ni;
struct plnstr pln;
int loaded = 0;
- s_char *p;
- s_char prompt[512];
- s_char buf[1024];
+ char *p;
+ char prompt[512];
+ char buf[1024];
if (!lp->lnd_maxlight) {
if (noisy)
struct lchrstr *lcp = &lchr[(int)lp->lnd_type];
int land_amt, land_max, sect_amt, move_amt;
int amount;
- s_char prompt[512];
- s_char *p;
- s_char buf[1024];
+ char prompt[512];
+ char *p;
+ char buf[1024];
sprintf(prompt, "Number of %s to %s %s at %s? ",
ich->i_name,
struct lndstr land;
struct plnstr plane;
int loaded = 0;
- s_char *p;
- s_char prompt[512];
- s_char buf[1024];
+ char *p;
+ char prompt[512];
+ char buf[1024];
lnd_count_units(lp);
int maxtarget;
int transfer;
int total;
- s_char *p;
- s_char buf[1024];
+ char *p;
+ char buf[1024];
if (!(ip = whatitem(player->argp[1], "Transfer what commodity? ")))
return RET_SYN;
int
map(void)
{
- register s_char *b;
+ char *b;
int unit_type = 0;
int bmap = 0;
struct nstr_sect ns;
struct emp_qelem land_list;
double minmob, maxmob;
int together;
- s_char *cp = 0;
+ char *cp = 0;
struct lndstr *lnd = 0; /* leader */
struct nstr_sect ns;
s_char origin;
int dir;
int stopping = 0;
int skip = 0;
- s_char buf[1024];
- s_char prompt[128];
+ char buf[1024];
+ char prompt[128];
if (!snxtitem(&ni_land, EF_LAND, player->argp[1]))
return RET_SYN;
multifire(void)
{
static int ef_with_guns[] = { EF_SECTOR, EF_SHIP, EF_LAND, EF_BAD };
- s_char vbuf[20];
- s_char *ptr;
+ char vbuf[20];
+ char *ptr;
double range2, range;
int trange;
coord fx;
struct natstr *natp;
struct nstr_item nbst;
int type;
- s_char *p;
+ char *p;
int nfiring = 0;
int ndefending = 0;
union item_u item;
struct emp_qelem fired, defended;
double odds;
- s_char buf[1024];
+ char buf[1024];
emp_initque(&fired);
emp_initque(&defended);
int mines_wanted;
int mines_laid;
int total_mines_laid;
- s_char prompt[128];
+ char prompt[128];
if (!snxtitem(&ni, EF_LAND, player->argp[1]))
return RET_SYN;
mobq(void)
{
struct shpstr ship;
- s_char *cp, *oldmq;
+ char *cp, *oldmq;
int good, mobquota, count = 0;
struct nstr_item nstr;
- s_char buf[1024];
+ char buf[1024];
if (!opt_SAIL) {
pr("The SAIL option is not enabled, so this command is not valid.\n");
struct lndstr land;
struct natstr *natp;
int i, min;
- s_char *p;
- s_char mess[128];
- s_char buf[1024];
+ char *p;
+ char mess[128];
+ char buf[1024];
if (!snxtitem(&np, EF_LAND, player->argp[1]))
return RET_SYN;
name(void)
{
struct shpstr ship;
- s_char *p;
+ char *p;
struct nstr_item nb;
- s_char buf[1024];
+ char buf[1024];
if (!snxtitem(&nb, EF_SHIP, player->argp[1]))
return RET_SYN;
struct emp_qelem ship_list;
double minmob, maxmob;
int together;
- s_char *cp = 0;
+ char *cp = 0;
struct shpstr *shp = 0; /* flagship */
struct nstr_sect ns;
s_char origin;
int dir;
int stopping = 0;
int skip = 0;
- s_char buf[1024];
- s_char prompt[128];
- s_char pathtaken[1024]; /* Doubtful we'll have a path longer than this */
- s_char *pt = pathtaken;
+ char buf[1024];
+ char prompt[128];
+ char pathtaken[1024]; /* Doubtful we'll have a path longer than this */
+ char *pt = pathtaken;
if (!snxtitem(&ni_ship, EF_SHIP, player->argp[1]))
return RET_SYN;
short k;
int sectors_were_taken = 0;
natid i, j;
- s_char num[128];
- s_char *verb;
+ char num[128];
+ char *verb;
if (!snxtitem(&nstr, EF_NEWS, "*"))
return RET_SYN;
static void
preport(register struct nwsstr *np)
{
- register s_char *cp;
+ char *cp;
register int i;
- s_char buf[255];
- s_char num[128];
- s_char *ptr;
+ char buf[255];
+ char num[128];
+ char *ptr;
cp = buf;
sprintf(buf, "%-16.16s ", ctime(&np->nws_when));
int
offe(void)
{
- register s_char *cp;
- s_char buf[1024];
+ char *cp;
+ char buf[1024];
if (!(cp = getstarg(player->argp[1], "loan or treaty? ", buf)) || !*cp)
return RET_SYN;
static int
do_treaty(void)
{
- register s_char *cp;
+ char *cp;
register int ourcond;
register int theircond;
register int j;
time_t now;
int n;
struct natstr *natp;
- s_char prompt[128];
- s_char buf[1024];
+ char prompt[128];
+ char buf[1024];
if ((n = natarg(player->argp[2], "Treaty offered to? ")) < 0)
return RET_SYN;
struct lonstr loan;
natid recipient;
int n;
- s_char prompt[128];
+ char prompt[128];
if ((n = natarg(player->argp[2], "Lend to? ")) < 0)
return RET_SYN;
struct ichrstr *i1;
coord p0x, p0y, p1x, p1y;
int i;
- s_char *p, *p1, *dest;
- s_char buf1[128];
- s_char buf[1024];
- s_char prompt[128];
+ char *p, *p1, *dest;
+ char buf1[128];
+ char buf[1024];
+ char prompt[128];
if (!snxtitem(&nb, EF_SHIP, player->argp[1]))
return RET_SYN;
}
static void
-eta_calc(struct shpstr *sp, s_char *path, int *len, int *nupdates)
+eta_calc(struct shpstr *sp, char *path, int *len, int *nupdates)
{
double mobcost, mobil;
int i;
{
int nships = 0;
int len, updates;
- s_char *c;
+ char *c;
struct nstr_item nb;
struct shpstr ship;
- s_char buf[1024];
+ char buf[1024];
if (!snxtitem(&nb, EF_SHIP, player->argp[1]))
return RET_SYN;
int
orig(void)
{
- s_char *p;
+ char *p;
coord x, y;
- s_char buf[1024];
+ char buf[1024];
natid cnum;
struct natstr *np;
coord tx, ty;
coord ax, ay;
int ap_to_target;
- s_char flightpath[MAX_PATH_LEN];
+ char flightpath[MAX_PATH_LEN];
struct nstr_item ni_bomb;
struct nstr_item ni_esc;
struct sctstr target;
struct emp_qelem esc_list;
int wantflags;
struct sctstr ap_sect;
- s_char buf[1024];
+ char buf[1024];
wantflags = P_P;
if (!snxtitem(&ni_bomb, EF_PLANE, player->argp[1]))
coord cx, cy;
int i;
int y;
- s_char *pp, *p;
+ char *pp, *p;
/* Note this is not re-entrant anyway, so we keep the buffers
around */
- static s_char *mapbuf = NULL;
- static s_char **map = NULL;
+ static char *mapbuf = NULL;
+ static char **map = NULL;
double move_cost;
- s_char buf[1024];
+ char buf[1024];
if (!(p = getstarg(player->argp[1], "from sector : ", buf)) ||
!sarg_xy(p, &cx, &cy) || !getsect(cx, cy, §))
int use_targets = 0;
int got_targets = 0;
int no_numbers = 0;
- s_char *p;
+ char *p;
memset(targets, 0, sizeof(targets));
natp = getnatp(player->cnum);
int
rada(void)
{
- s_char *cp;
+ char *cp;
double tf;
double tech;
struct nstr_item ni;
struct lndstr land;
struct sctstr sect;
int from_unit;
- s_char buf[1024];
+ char buf[1024];
from_unit = (**player->argp == 'l');
struct nstr_item np;
struct plnstr plane;
int i;
- s_char *p;
- s_char buf[1024];
+ char *p;
+ char buf[1024];
if (!snxtitem(&np, EF_PLANE, player->argp[1]))
return RET_SYN;
int
rea(void)
{
- static s_char *telnames[] = {
+ static char *telnames[] = {
/* must follow TEL_ defines in tel.h */
"Telegram", "Announcement", "BULLETIN", "Production Report"
};
- register s_char *p;
- register s_char *mbox;
- s_char mbox_buf[256]; /* Maximum path length */
+ char *p;
+ char *mbox;
+ char mbox_buf[256]; /* Maximum path length */
struct telstr tgm;
FILE *telfp;
int teles;
time_t lastdate;
int header;
int filelen;
- s_char kind[80];
+ char kind[80];
int n;
int num = player->cnum;
struct natstr *np = getnatp(player->cnum);
coord tx, ty;
coord ax, ay;
int ap_to_target;
- s_char flightpath[MAX_PATH_LEN];
+ char flightpath[MAX_PATH_LEN];
int cno;
struct nstr_item ni_bomb;
struct nstr_item ni_esc;
struct emp_qelem esc_list;
int wantflags;
struct sctstr ap_sect;
- s_char buf[1024];
+ char buf[1024];
wantflags = 0;
if (!snxtitem(&ni_bomb, EF_PLANE, player->argp[1]))
int
reje(void)
{
- register s_char *p;
+ char *p;
int rel;
int do_undo;
struct natstr nat;
struct nstr_item ni;
- s_char buf[1024];
+ char buf[1024];
if ((p = getstarg(player->argp[1], "reject or accept? ", buf)) == 0)
return RET_SYN;
char *p;
float price;
time_t now;
- s_char buf[1024];
+ char buf[1024];
if (!opt_MARKET) {
pr("The market is disabled.\n");
int
retr(void)
{
- s_char *pq, *fl;
+ char *pq, *fl;
int nships;
struct nstr_item ni;
struct shpstr ship;
int rflags = -2;
int zero;
unsigned int x;
- s_char buf1[1024];
- s_char buf2[1024];
+ char buf1[1024];
+ char buf2[1024];
if (!snxtitem(&ni, EF_SHIP, player->argp[1]))
return RET_SYN;
int
lretr(void)
{
- s_char *pq, *fl;
+ char *pq, *fl;
int nunits;
struct nstr_item ni;
struct lndstr land;
int isarmy = 0;
int rflags = -2;
int zero;
- s_char buf1[1024];
- s_char buf2[1024];
+ char buf1[1024];
+ char buf2[1024];
unsigned int x;
if (!snxtitem(&ni, EF_LAND, player->argp[1]))
int ry;
i_type i_del;
int dir;
- s_char *p;
+ char *p;
/* Note this is not re-entrant anyway, so we keep the buffers
around */
- static s_char *mapbuf = NULL;
- static s_char **map = NULL;
- static s_char *buf = NULL;
+ static char *mapbuf = NULL;
+ static char **map = NULL;
+ static char *buf = NULL;
int i;
if ((ip = whatitem(player->argp[1], "What item? ")) == 0)
struct mchrstr *mp;
struct plchrstr *pp;
struct lchrstr *lp;
- s_char *p;
+ char *p;
i_type i;
struct nstr_item ni2;
struct plnstr plane;
struct lndstr land;
struct sctstr sect2;
- s_char prompt[128];
- s_char buf[1024];
+ char prompt[128];
+ char buf[1024];
float eff;
if (!(p = getstarg(player->argp[1], "Ship, land, or plane? ", buf)))
return RET_SYN;
if (p && (isalpha(*p) || (*p == '*') || (*p == '~') || issector(p)
|| islist(p))) {
- s_char y_or_n[80], bbuf[80];
+ char y_or_n[80], bbuf[80];
memset(y_or_n, 0, sizeof(y_or_n));
if (type == EF_SHIP) {
struct sctstr sect;
struct mchrstr *mp;
struct natstr *np;
- s_char buf[512];
+ char buf[512];
struct natstr *natp;
mp = &mchr[(int)sp->shp_type];
union item_u item;
int type;
struct mchrstr *mp;
- s_char *p;
- s_char prompt[128];
- s_char buf[1024];
+ char *p;
+ char prompt[128];
+ char buf[1024];
if (!(p = getstarg(player->argp[1], "Ship, land, or plane? ", buf)))
return RET_SYN;
return RET_SYN;
if (p && (isalpha(*p) || (*p == '*') || (*p == '~') || issector(p)
|| islist(p))) {
- s_char y_or_n[80], bbuf[80];
+ char y_or_n[80], bbuf[80];
if (type == EF_SHIP) {
if (*p == '*')
struct natstr *np;
int ncond;
int nsect;
- s_char *ptr;
+ char *ptr;
coord y, yval;
int i;
/* Note this is not re-entrant anyway, so we keep the buffers
around */
- static s_char *mapbuf = NULL;
- static s_char **map = NULL;
+ static char *mapbuf = NULL;
+ static char **map = NULL;
nsect = 0;
if (!snxtsct(&ns, player->argp[1]))
time_t now;
int ii = 0;
coord x, y;
- s_char buf[1024];
+ char buf[1024];
if (!opt_MARKET) {
pr("The market is disabled.\n");
int foundslot;
int id;
time_t now;
- s_char buf[1024];
+ char buf[1024];
if (!opt_MARKET) {
pr("The market is disabled.\n");
setres(void)
{
struct sctstr sect;
- s_char *what;
+ char *what;
int amt;
- s_char *p;
+ char *p;
struct nstr_sect nstr;
- s_char buf[1024];
+ char buf[1024];
if ((what = getstarg(player->argp[1],
"Set What (iron, gold, oil, uranium, fertility)? ",
setsector(void)
{
struct sctstr sect;
- s_char *what;
+ char *what;
int amt, current;
- s_char *p;
+ char *p;
struct nstr_sect nstr;
- s_char buf[1024];
- s_char char0, char1;
+ char buf[1024];
+ char char0, char1;
if ((what = getstarg(player->argp[1],
"Give What (iron, gold, oil, uranium, fertility, owner, eff., mob., work, avail., oldown, mines)? ",
}
void
-resnoise(struct sctstr *sptr, int public_amt, s_char *name, int old,
+resnoise(struct sctstr *sptr, int public_amt, char *name, int old,
int new)
{
- s_char p[100];
+ char p[100];
pr("%s of %s changed from %d to %d%%\n",
name, xyas(sptr->sct_x, sptr->sct_y, player->cnum), old, new);
int
show(void)
{
- s_char *p;
+ char *p;
void (*cfunc)(int);
void (*sfunc)(int);
void (*bfunc)(int);
struct natstr *natp;
int tlev;
- s_char buf[1024];
+ char buf[1024];
int rlev;
if (!(p = getstarg(player->argp[1],
struct sky *todelete = 0;
struct sky **prev;
struct plchrstr *pcp;
- s_char *name;
+ char *name;
int nsat = 0;
prev = 0;
#include "land.h"
#include "commands.h"
-static void starv_sects(s_char *range);
-static void starv_ships(s_char *range);
-static void starv_units(s_char *range);
+static void starv_sects(char *range);
+static void starv_ships(char *range);
+static void starv_units(char *range);
static void sect_hdr(void);
static void ship_hdr(void);
static void unit_hdr(void);
int do_sects = 0;
int do_ships = 0;
int do_units = 0;
- s_char range[1024];
+ char range[1024];
if (opt_NOFOOD) { /* no food - no work! */
pr("No food is required in this game\n");
}
static void
-starv_sects(s_char *range)
+starv_sects(char *range)
{
struct nstr_sect nstr;
struct sctstr sect;
}
static void
-starv_ships(s_char *range)
+starv_ships(char *range)
{
struct nstr_item ni;
struct shpstr ship;
}
static void
-starv_units(s_char *range)
+starv_units(char *range)
{
struct nstr_item ni;
struct lndstr land;
struct natstr *np;
struct sctstr sect;
struct range range;
- s_char *ptr;
+ char *ptr;
struct nscstr cond[NS_NCOND];
int ncond;
int i;
- s_char buf[1024];
+ char buf[1024];
/* Note this is not re-entrant anyway, so we keep the buffers
around */
- static s_char *mapbuf = NULL;
- static s_char **map = NULL;
+ static char *mapbuf = NULL;
+ static char **map = NULL;
nsect = 0;
ptr = getstarg(player->argp[1], "commodity or variable? ", buf);
{
struct sctstr secta, sectb;
coord x, y;
- s_char buf[1024];
- s_char *p;
+ char buf[1024];
+ char *p;
if (!(p = getstarg(player->argp[1], "First sector : ", buf)) ||
!sarg_xy(p, §a.sct_x, §a.sct_y) ||
#include "commands.h"
static void expose_ship(struct shpstr *s1, struct shpstr *s2);
-static int tend_land(struct shpstr *tenderp, s_char *units);
+static int tend_land(struct shpstr *tenderp, char *units);
int
tend(void)
int transfer;
int total;
int type;
- s_char *p;
- s_char prompt[512];
- s_char buf[1024];
+ char *p;
+ char prompt[512];
+ char buf[1024];
if (!(p = getstarg(player->argp[1],
"Tend what commodity (or 'land')? ", buf)) || !*p)
}
static int
-tend_land(struct shpstr *tenderp, s_char *units)
+tend_land(struct shpstr *tenderp, char *units)
{
struct nstr_item lni;
struct nstr_item targets;
struct lndstr land;
struct plnstr plane;
struct nstr_item pni;
- s_char buf[1024];
+ char buf[1024];
if (!snxtitem(&lni, EF_LAND, units))
return RET_SYN;
terr(void)
{
struct sctstr sect;
- s_char *p;
+ char *p;
int terr_n;
int field;
struct nstr_sect nstr;
- s_char prompt[128];
- s_char buf[1024];
+ char prompt[128];
+ char buf[1024];
if (!snxtsct(&nstr, player->argp[1]))
return RET_SYN;
struct nstr_sect nstr;
int val;
struct ichrstr *ip;
- s_char *p;
+ char *p;
int thresh;
i_type type;
- s_char prompt[128];
- s_char buf[128];
+ char prompt[128];
+ char buf[128];
if ((ip = whatitem(player->argp[1], "What commodity? ")) == 0)
return RET_SYN;
{
int flag = 0;
int pos;
- s_char *name;
+ char *name;
struct natstr *np;
np = getnatp(player->cnum);
double hitchance;
struct shpstr vship;
struct shpstr sub;
- s_char *ptr;
+ char *ptr;
double mobcost;
struct mchrstr *mcp;
struct nstr_item nbst;
- s_char buf[1024];
- s_char *sav;
+ char buf[1024];
+ char *sav;
int ntorping = 0;
- s_char prompt[128];
+ char prompt[128];
if (!(sav = getstarg(player->argp[1], "From ship(s)? ", buf)))
return RET_SYN;
return 1;
}
-s_char *
+char *
prsub(struct shpstr *sp)
{
if (mchr[(int)sp->shp_type].m_flags & M_SUB)
double tleft;
double tally;
int q;
- s_char buf[1024];
+ char buf[1024];
if (!opt_MARKET) {
pr("The market is disabled.\n");
int
upgr(void)
{
- s_char *p;
- s_char buf[1024];
+ char *p;
+ char buf[1024];
if (!(p = getstarg(player->argp[1], "Ship, land, or plane? ", buf)))
return RET_SYN;
struct plnstr plane;
int count;
- s_char *cp;
- s_char c;
+ char *cp;
+ char c;
struct nstr_item nstr;
- s_char buf[1024];
+ char buf[1024];
if (!(cp = getstarg(player->argp[1], "wing? ", buf)))
return RET_SYN;
struct sctstr sect;
struct lndstr land;
int work_amt, eff_amt, w;
- s_char *p;
+ char *p;
coord donex = 0, doney = 1;
- s_char buf[1024];
+ char buf[1024];
if (!snxtitem(&ni, EF_LAND, player->argp[1]))
return RET_SYN;
{
natid whichcnum;
struct natstr *natp;
- register s_char *p;
+ char *p;
int update;
int checking;
int totpop;
int totwant;
int dowant;
- s_char buf[1024];
+ char buf[1024];
if (!opt_DEMANDUPDATE) {
pr("Demand updates are not enabled.\n");
#include "optlist.h"
#include <stdio.h>
-s_char *
-mailbox(s_char *buf, natid cn)
+char *
+mailbox(char *buf, natid cn)
{
(void)sprintf(buf, "%s%d", telfil, cn);
return buf;
#include "optlist.h"
static int bmnxtsct(struct nstr_sect *);
-static s_char map_char(unsigned char type, natid own, int owner_or_god);
+static char map_char(unsigned char type, natid own, int owner_or_god);
int
draw_map(int bmap, s_char origin, int map_flags, struct nstr_sect *nsp)
/* Note this is not re-entrant anyway, so we keep the buffers
around */
static unsigned char *bitmap = NULL;
- static s_char *wmapbuf = NULL;
- static s_char **wmap = NULL;
+ static char *wmapbuf = NULL;
+ static char **wmap = NULL;
if (!wmapbuf)
wmapbuf = malloc(WORLD_Y * MAPWIDTH(1));
}
} else {
struct sctstr sect;
- s_char mapch;
+ char mapch;
int changed = 0;
if (!player->god) {
}
}
if (map_flags & MAP_HIGH) {
- s_char *ptr;
+ char *ptr;
struct sctstr sect;
snxtsct_rewind(nsp);
* Return character to use in maps for sector type TYPE owned by OWN.
* If OWNER_OR_GOD, the map is for the sector's owner or a deity.
*/
-static s_char
+static char
map_char(unsigned char type, natid own, int owner_or_god)
{
if (type > SCT_MAXDEF) {
/* Note that this requires that the BMAP is mapped into memory */
int
-share_bmap(natid from, natid to, struct nstr_sect *ns, s_char des,
- s_char *from_name)
+share_bmap(natid from, natid to, struct nstr_sect *ns, char des,
+ char *from_name)
{
- s_char *from_bmap = ef_ptr(EF_BMAP, from);
- s_char *to_bmap = ef_ptr(EF_BMAP, to);
+ char *from_bmap = ef_ptr(EF_BMAP, from);
+ char *to_bmap = ef_ptr(EF_BMAP, to);
int n = 0;
struct sctstr sect;
- s_char fromdes;
- s_char todes;
- s_char from_des = *from_name;
+ char fromdes;
+ char todes;
+ char from_des = *from_name;
if (isalpha(from_des))
from_des &= ~0x20;
struct as_data *adp;
};
-static int bp_path(struct as_path *pp, s_char *buf);
+static int bp_path(struct as_path *pp, char *buf);
static int bp_neighbors(struct as_coord c, struct as_coord *cp, void *);
static double bp_lbcost(struct as_coord from, struct as_coord to, void *);
static double bp_realcost(struct as_coord from, struct as_coord to, void *);
* string in path. Return 0 on success, -1 on error.
*/
static int
-best_path(struct sctstr *from, struct sctstr *to, s_char *path,
+best_path(struct sctstr *from, struct sctstr *to, char *path,
int mob_type)
{
static struct bestp *mybestpath;
* success, -1 on failure.
*/
static int
-bp_path(struct as_path *pp, s_char *buf)
+bp_path(struct as_path *pp, char *buf)
{
struct as_path *np;
- s_char *cp = buf;
+ char *cp = buf;
int dx, dy;
int n;
}
double
-pathcost(struct sctstr *start, s_char *path, int mob_type)
+pathcost(struct sctstr *start, char *path, int mob_type)
{
struct sctstr *sectp = (void *)empfile[EF_SECTOR].cache;
unsigned i;
return cost;
}
-s_char *
-BestDistPath(s_char *path,
+char *
+BestDistPath(char *path,
struct sctstr *from,
struct sctstr *to, double *cost, int mob_type)
{
return BestLandPath(path, from, to, cost, mob_type);
}
-s_char *
-BestLandPath(s_char *path,
+char *
+BestLandPath(char *path,
struct sctstr *from,
struct sctstr *to, double *cost, int mob_type)
{
return path;
}
-s_char *
-BestShipPath(s_char *path, int fx, int fy, int tx, int ty, int owner)
+char *
+BestShipPath(char *path, int fx, int fy, int tx, int ty, int owner)
{
char *map;
return bestownedpath(path, map, fx, fy, tx, ty, owner);
}
-s_char *
-BestAirPath(s_char *path, int fx, int fy, int tx, int ty)
+char *
+BestAirPath(char *path, int fx, int fy, int tx, int ty)
{
return bestownedpath(path, 0, fx, fy, tx, ty, -1);
}
* null terminate
*/
void
-blankfill(s_char *ptr, register struct range *range, int size)
+blankfill(char *ptr, struct range *range, int size)
{
- register s_char *p;
- register int row;
- register int col;
+ char *p;
+ int row;
+ int col;
for (row = 0; row < range->height; row++) {
col = (range->width + 1) * (size + 1) / 2 - 1;
#undef EMP_CONFIG_C_OUTPUT
};
-static struct keymatch *keylookup(s_char *key, struct keymatch tbl[]);
+static struct keymatch *keylookup(char *key, struct keymatch tbl[]);
static void set_dirs(char *);
/*
/* find the key in the table */
static struct keymatch *
-keylookup(register s_char *command, struct keymatch *tbl)
+keylookup(char *command, struct keymatch *tbl)
{
- register struct keymatch *kp;
+ struct keymatch *kp;
if (command == 0 || *command == 0)
return 0;
int
io_input(struct iop *iop, int waitforinput)
{
- s_char buf[IO_BUFSIZE];
+ char buf[IO_BUFSIZE];
int cc;
/* Not a read IOP */
}
int
-io_peek(struct iop *iop, s_char *buf, int nbytes)
+io_peek(struct iop *iop, char *buf, int nbytes)
{
if ((iop->flags & IO_READ) == 0)
return -1;
}
int
-io_read(struct iop *iop, s_char *buf, int nbytes)
+io_read(struct iop *iop, char *buf, int nbytes)
{
int cc;
}
int
-io_write(struct iop *iop, s_char *buf, int nbytes, int doWait)
+io_write(struct iop *iop, char *buf, int nbytes, int doWait)
{
int len;
}
int
-io_gets(struct iop *iop, s_char *buf, int nbytes)
+io_gets(struct iop *iop, char *buf, int nbytes)
{
if ((iop->flags & IO_READ) == 0)
return -1;
}
int
-io_puts(struct iop *iop, s_char *buf)
+io_puts(struct iop *iop, char *buf)
{
if ((iop->flags & IO_WRITE) == 0)
return -1;
#include "queue.h"
#include "ioqueue.h"
-static int ioqtocbuf(struct ioqueue *ioq, s_char *buf, int cc,
+static int ioqtocbuf(struct ioqueue *ioq, char *buf, int cc,
register int stopc);
#if !defined(_WIN32)
static int ioqtoiov(struct ioqueue *ioq, struct iovec *iov,
register int max);
#endif
-static int ioqtobuf(struct ioqueue *ioq, s_char *buf, int cc);
-static int appendcc(struct ioqueue *ioq, s_char *buf, int cc);
+static int ioqtobuf(struct ioqueue *ioq, char *buf, int cc);
+static int appendcc(struct ioqueue *ioq, char *buf, int cc);
static int removecc(struct ioqueue *ioq, register int cc);
#if defined(_WIN32)
* number of bytes actually found.
*/
int
-ioq_peek(struct ioqueue *ioq, s_char *buf, int cc)
+ioq_peek(struct ioqueue *ioq, char *buf, int cc)
{
return ioqtobuf(ioq, buf, cc);
}
}
void
-ioq_append(struct ioqueue *ioq, s_char *buf, int cc)
+ioq_append(struct ioqueue *ioq, char *buf, int cc)
{
appendcc(ioq, buf, cc);
}
* no input is available
*/
int
-ioq_gets(struct ioqueue *ioq, s_char *buf, int cc)
+ioq_gets(struct ioqueue *ioq, char *buf, int cc)
{
int nbytes;
int actual;
}
int
-ioq_puts(struct ioqueue *ioq, s_char *buf)
+ioq_puts(struct ioqueue *ioq, char *buf)
{
return appendcc(ioq, buf, strlen(buf));
}
* left for a higher level.
*/
static int
-ioqtobuf(struct ioqueue *ioq, s_char *buf, int cc)
+ioqtobuf(struct ioqueue *ioq, char *buf, int cc)
{
struct io *io;
struct emp_qelem *qp;
struct emp_qelem *head;
register int nbytes;
register int nleft;
- register s_char *offset;
+ char *offset;
nleft = cc;
offset = buf;
* terminating on the stop character.
*/
static int
-ioqtocbuf(struct ioqueue *ioq, s_char *buf, int cc, register int stopc)
+ioqtocbuf(struct ioqueue *ioq, char *buf, int cc, register int stopc)
{
register int nbytes;
register s_char *p;
* append a buffer to the end of the ioq.
*/
static int
-appendcc(struct ioqueue *ioq, s_char *buf, int cc)
+appendcc(struct ioqueue *ioq, char *buf, int cc)
{
struct io *io;
int len;
#include "misc.h"
#include "gen.h"
-s_char *
-numstr(s_char *buf, int n)
+char *
+numstr(char *buf, int n)
{
- static s_char *numnames[] = {
+ static char *numnames[] = {
"zero", "one", "two", "three", "four", "five", "six",
"seven", "eight", "nine", "ten", "eleven", "twelve",
"thirteen", "fourteen", "fifteen", "sixteen",
"seventeen", "eighteen", "nineteen",
};
- static s_char *tennames[] = {
+ static char *tennames[] = {
"", "", "twenty", "thirty", "forty", "fifty",
"sixty", "seventy", "eighty", "ninety",
"hundred", "hundred ten", "hundred twenty",
return buf;
}
-s_char *
+char *
effadv(int n)
{
- static s_char *effadv_list[] = {
+ static char *effadv_list[] = {
"minimally", "partially", "moderately", "completely",
};
#include "gen.h"
int
-onearg(s_char *arg, s_char *prompt)
+onearg(char *arg, char *prompt)
{
int n;
- s_char buf[1024];
+ char buf[1024];
if (arg == 0 || *arg == 0) {
if ((arg = getstring(prompt, buf)) == 0)
#include "prototypes.h"
-s_char *
+char *
splur(int n)
{
return n == 1 ? "" : "s";
}
-s_char *
+char *
esplur(int n)
{
return n == 1 ? "" : "es";
}
-s_char *
+char *
iesplur(int n)
{
return n == 1 ? "y" : "ies";
int
explain(void)
{
- register s_char *format;
- register int i;
+ char *format;
+ int i;
pr("\t\tCurrent EMPIRE Command List\n"
"\t\t------- ------ ------- ----\n"
#include <fcntl.h>
int
-natbyname(s_char *name, natid *result)
+natbyname(char *name, natid *result)
{
struct natstr *np;
int i;
}
int
-natpass(int cn, s_char *pass)
+natpass(int cn, char *pass)
{
struct natstr *np;
void
ac_encounter(struct emp_qelem *bomb_list, struct emp_qelem *esc_list,
- coord x, coord y, s_char *path, int mission_flags,
+ coord x, coord y, char *path, int mission_flags,
int no_air_defense, struct emp_qelem *obomb,
struct emp_qelem *oesc)
{
int unfriendly[MAXNOC];
int overfly[MAXNOC];
struct emp_qelem ilist[MAXNOC], *qp;
- s_char mypath[1024];
+ char mypath[1024];
int myp;
int civ, mil;
natid plane_owner;
int intensity;
natid att_own, def_own;
int adam, ddam;
- s_char mesg[1024];
- s_char temp[14];
+ char mesg[1024];
+ char temp[14];
att_own = ap->plane.pln_own;
def_own = dp->plane.pln_own;
*/
void
ac_planedamage(struct plist *plp, natid from, int dam, natid other,
- int checkabort, int show, s_char *mesg)
+ int checkabort, int show, char *mesg)
{
struct plnstr *pp;
int disp;
- s_char dmess[255];
+ char dmess[255];
int eff;
struct shpstr ship;
struct lndstr land;
int diff;
struct emp_qelem *qp;
struct emp_qelem *next;
- s_char msg[255];
+ char msg[255];
plp = (struct plist *)list->q_forw;
* If they don't answer 'y' or 'Y', return 0
*/
int
-confirm(s_char *promptstring)
+confirm(char *promptstring)
{
- s_char y_or_n[1024];
+ char y_or_n[1024];
char c;
if (getstring(promptstring, y_or_n) == 0)
* return 1 for y or Y, and 0 for n or N
*/
int
-askyn(s_char *promptstring)
+askyn(char *promptstring)
{
- s_char y_or_n[1024];
+ char y_or_n[1024];
char c;
while (getstring(promptstring, y_or_n)) {
/* print a combat object with optional preposition */
-static s_char *
+static char *
pr_com(int inon, struct combat *com, natid who)
{
if (com->type == EF_SECTOR) {
}
}
-static s_char *
+static char *
prcom(int inon, struct combat *com)
{
return pr_com(inon, com, player->cnum);
{
struct sctstr sect;
int rel;
- s_char y_or_n[512];
+ char y_or_n[512];
struct natstr *natp;
if (player->aborted)
att_ask_support(int offset, int *fortp, int *shipp, int *landp,
int *planep)
{
- s_char buf[1024];
- s_char *p;
+ char buf[1024];
+ char *p;
*fortp = *shipp = *landp = *planep = 1;
if (player->argp[offset] != NULL) {
{
int attacking_mil;
int mob_support;
- s_char prompt[512];
+ char prompt[512];
if (att_get_combat(off, 0) <= 0)
return 0;
int count = 0;
int maxland = 0;
int first_time = 1;
- s_char prompt[512];
+ char prompt[512];
if (def->type == EF_LAND)
return;
int victim_land)
{
struct lndstr *lp = &llp->land;
- s_char buf[512];
+ char buf[512];
getland(uid, lp);
int radius;
int origx, origy;
double eff = att_combat_eff(def);
- s_char *p;
- s_char buf[1024];
+ char *p;
+ char buf[1024];
/*
*
/* Pop off shells and fly bombing missions to get your attack multiplier up */
static double
-get_osupport(s_char *outs, struct combat *def, int fort_sup, int ship_sup,
+get_osupport(char *outs, struct combat *def, int fort_sup, int ship_sup,
int land_sup, int plane_sup)
{
double osupport = 1.0;
/* Pop off shells and fly bombing missions to get your defense multiplier up */
static double
-get_dsupport(s_char *outs, struct emp_qelem *list, struct combat *def,
+get_dsupport(char *outs, struct emp_qelem *list, struct combat *def,
int ototal, int dtotal)
{
double dsupport = 1.0;
double *osupportp, double *dsupportp, int a_engineer)
{
int ototal, dtotal;
- s_char osupports[512];
- s_char dsupports[512];
+ char osupports[512];
+ char dsupports[512];
if (combat_mode == A_PARA)
*osupports = '\0';
int news_item;
int recalctime;
double odds;
- s_char *action;
+ char *action;
ototal = get_ototal(combat_mode, off, olist, osupport,
combat_mode != A_PARA);
{
struct emp_qelem *qp, *next;
struct llist *llp;
- s_char buf[1024];
+ char buf[1024];
for (qp = list->q_forw; qp != list; qp = next) {
next = qp->q_forw;
int n;
int occuppied = 0;
struct llist *llp, *delete_me = 0;
- s_char buf[1024];
+ char buf[1024];
struct sctstr sect;
struct shpstr ship;
struct lndstr land;
int n;
struct emp_qelem *qp, *next;
struct llist *llp;
- s_char buf[512];
- s_char prompt[512];
+ char buf[512];
+ char prompt[512];
s_char land_answer[1024];
s_char *answerp;
{
struct emp_qelem *qp, *next;
struct llist *llp;
- s_char buf[512];
+ char buf[512];
if (QEMPTY(olist))
return;
int mob_support;
int num_mil, dam = 0, left;
double d, weight;
- s_char prompt[512];
- s_char buf[1024];
- s_char *p;
+ char prompt[512];
+ char buf[1024];
+ char *p;
if (att_get_combat(off, 0) <= 0)
return;
#include "optlist.h"
void
-border(struct range *rp, s_char *prefstr, s_char *sep)
+border(struct range *rp, char *prefstr, char *sep)
/* prefixes each line */
/* separates the numbers */
#include "optlist.h"
void
-caploss(struct sctstr *sp, natid coun, s_char *msg)
+caploss(struct sctstr *sp, natid coun, char *msg)
{
struct natstr *natp;
struct lonstr loan;
#include "prototypes.h"
int
-chkmoney(long int cost, long int cash, s_char *argp)
+chkmoney(long int cost, long int cash, char *argp)
{
- s_char buf[1024];
- s_char *p;
+ char buf[1024];
+ char *p;
if (cash > 0 && cost > cash / 2) {
pr("This operation will cost you $%ld, and you only have $%ld.\n",
int
check_cost(int looping, int cost, long int cash, int *warnedp,
- s_char *argp)
+ char *argp)
{
- s_char buf[1024];
- s_char *p;
+ char buf[1024];
+ char *p;
if (looping && cash > 0 && player->dolcost + cost > cash
&& *warnedp < 2) {
struct shpstr ship;
struct lndstr land;
struct nukstr nuke;
- s_char *bp;
- s_char buf[128];
- s_char buf2[128];
+ char *bp;
+ char buf[128];
+ char buf2[128];
natid own;
int type;
int damage;
lp->lnd_own = 0;
}
-s_char *
+char *
prland(struct lndstr *lp)
{
return prbuf("%s #%d", lchr[(int)lp->lnd_type].l_name, lp->lnd_uid);
*/
int
-islist(s_char *p)
+islist(char *p)
{
int x;
}
void
-lnd_print(struct llist *llp, s_char *s)
+lnd_print(struct llist *llp, char *s)
{
if (llp->land.lnd_own == player->cnum)
pr("%s %s\n", prland(&llp->land), s);
}
void
-lnd_delete(struct llist *llp, s_char *s)
+lnd_delete(struct llist *llp, char *s)
{
if (s)
lnd_print(llp, s);
coord bx, by;
struct sctstr sect;
int ret_chance;
- s_char buf[1024];
+ char buf[1024];
int taken;
int nowhere_to_go = 0;
struct sctstr rsect;
int
intelligence_report(int destination, struct lndstr *lp, int spy,
- s_char *mess)
+ char *mess)
{
struct lchrstr *lcp;
- s_char buf1[80], buf2[80], buf3[80];
+ char buf1[80], buf2[80], buf3[80];
double estimate = 0.0; /* estimated defense value */
if (destination == 0)
coord allx;
coord ally;
int first = 1;
- s_char mess[128];
+ char mess[128];
int rel;
*minmobp = 9876.0;
}
void
-lnd_mess(s_char *str, struct llist *llp)
+lnd_mess(char *str, struct llist *llp)
{
mpr(llp->land.lnd_own, "%s %s & stays in %s\n",
prland(&llp->land),
int stopping = 0;
int visible;
int stop;
- s_char dp[80];
+ char dp[80];
int rel;
int oldown;
return (int)dam;
}
-s_char *
-lnd_path(int together, struct lndstr *lp, s_char *buf)
+char *
+lnd_path(int together, struct lndstr *lp, char *buf)
{
coord destx;
coord desty;
struct sctstr d_sect, sect;
- s_char *cp;
+ char *cp;
double dummy;
if (!sarg_xy(buf, &destx, &desty))
static void add_airport(struct emp_qelem *, coord, coord);
static int air_damage(struct emp_qelem *, coord, coord, int, natid,
- s_char *, int);
+ char *, int);
static void build_mission_list(struct genlist *, coord, coord, int, natid);
static void build_mission_list_type(struct genlist *, coord, coord, int,
int, natid);
int, struct ichrstr *, int, int, int *);
static void mission_pln_sel(struct emp_qelem *, int, int, int);
static int perform_mission(coord, coord, natid, struct emp_qelem *, int,
- s_char *, int);
+ char *, int);
/*
* Interdict commodities & transported planes
*/
int
-ground_interdict(coord x, coord y, natid victim, s_char *s)
+ground_interdict(coord x, coord y, natid victim, char *s)
{
int cn;
int dam = 0, newdam, rel;
*
*/
int
-unit_interdict(coord x, coord y, natid victim, s_char *s, int hardtarget,
+unit_interdict(coord x, coord y, natid victim, char *s, int hardtarget,
int mission)
{
int cn;
static int
perform_mission(coord x, coord y, natid victim, struct emp_qelem *list,
- int mission, s_char *s, int hardtarget)
+ int mission, char *s, int hardtarget)
{
struct emp_qelem *qp, missiles, bombers, escorts, airp, b, e;
struct emp_qelem *newqp;
return 0;
}
-s_char *
+char *
nameofitem(struct genitem *gp, int type)
{
switch (type) {
return NULL;
}
-s_char *
+char *
mission_name(short int mission)
{
switch (mission) {
static int
air_damage(struct emp_qelem *bombers, coord x, coord y, int mission,
- natid victim, s_char *s, int hardtarget)
+ natid victim, char *s, int hardtarget)
{
struct emp_qelem *qp;
struct plist *plp;
int
msl_hit(struct plnstr *pp, int hardtarget, int type, int news_item,
- int snews_item, s_char *what, coord x, coord y, int victim)
+ int snews_item, char *what, coord x, coord y, int victim)
{
int hit;
struct shpstr ship;
int sublaunch = 0;
struct plchrstr *pcp = plchr + pp->pln_type;
int hitchance = pln_hitchance(pp, hardtarget, type);
- s_char *from;
+ char *from;
int dam, dummyi;
mpr(pp->pln_own, "Preparing to launch %s at %s %s %s%s\n",
mpr(pp->pln_own, hit ? "HIT!\n" : "miss\n");
if (pcp->pl_flags & P_T)
mpr(victim, "...Incoming %s missile %s\n",
- sublaunch ? (s_char *)"" : cname(pp->pln_own),
+ sublaunch ? "" : cname(pp->pln_own),
hit ? "HIT!\n" : "missed\n");
if (hit && news_item) {
if (sublaunch)
struct plist *ip;
int icount = 0;
short destroyed = 0;
- s_char *att_name;
- s_char *def_name;
+ char *att_name;
+ char *def_name;
int news_item;
- s_char *who = sublaunch ? (s_char *)"" : cname(bombown);
+ char *who = sublaunch ? "" : cname(bombown);
getsect(x, y, §);
if (wantflags == P_O && !nowantflags) {
/* Keep launching missiles on list until mindam damage has been done */
int
msl_launch_mindam(struct emp_qelem *list, coord x, coord y, int hardtarget,
- int type, int mindam, s_char *whatp, int victim,
+ int type, int mindam, char *whatp, int victim,
int mission)
{
struct emp_qelem *qp;
* Ignore commands that require more permissions than COMSTAT.
*/
int
-comtch(register s_char *command, struct cmndstr *coms, int comstat)
+comtch(char *command, struct cmndstr *coms, int comstat)
{
register struct cmndstr *com;
register int status;
pp->pln_own = 0;
}
-s_char *
+char *
prplane(struct plnstr *pp)
{
return prbuf("%s #%d", plchr[(int)pp->pln_type].pl_name, pp->pln_uid);
/* More dynamic world sized buffers. We create 'em once, and then
* never again. No need to keep creating/tearing apart. We may
* want to do this in other places too where it doesn't matter. */
-static s_char **rad;
-static s_char *radbuf;
+static char **rad;
+static char *radbuf;
static s_char **vis;
static s_char *visbuf;
{
struct natstr *mynp;
struct natstr *themnp;
- s_char *myname = cname(us);
- s_char *themname;
+ char *myname = cname(us);
+ char *themname;
int oldrel;
- s_char *whichway;
+ char *whichway;
int n_up = 0;
int n_down = 0;
- s_char *addendum = 0;
+ char *addendum = 0;
int theirrel;
if (rel < AT_WAR)
#include "prototypes.h"
#include "optlist.h"
-static s_char **rad;
-static s_char *radbuf;
+static char **rad;
+static char *radbuf;
void
satmap(int x, int y, int eff, int range, int flags, int type)
int changed = 0;
long crackle;
s_char noise[100];
- s_char selection[1024];
+ char selection[1024];
if (!eff)
return;
}
int
-issector(s_char *arg)
+issector(char *arg)
{
- s_char c;
+ char c;
while (0 != (c = *arg++))
if (!isdigit(c) && !isspace(c) && (c != '/'))
sp->shp_own = 0;
}
-s_char *
+char *
prship(struct shpstr *sp)
{
return prbuf("%s %s(#%d)",
static int shp_check_one_mines(struct mlist *);
static int shp_hit_mine(struct shpstr *, struct mchrstr *);
-static void shp_mess(s_char *, struct mlist *);
+static void shp_mess(char *, struct mlist *);
void
shp_sel(struct nstr_item *ni, struct emp_qelem *list)
}
static void
-shp_mess(s_char *str, struct mlist *mlp)
+shp_mess(char *str, struct mlist *mlp)
{
mpr(mlp->ship.shp_own, "%s %s & stays in %s\n",
prship(&mlp->ship),
int stopping = 0;
struct emp_qelem msl_list, *qp, *newqp;
struct mlist *mvs;
- s_char what[512];
+ char what[512];
msl_sel(&msl_list, newx, newy, victim, P_T | P_MAR, 0, MI_INTERDICT);
double mobcost;
double tech; /* for mapping */
double tf; /* for mapping */
- s_char dp[80];
+ char dp[80];
int navigate;
if (dir <= DIR_STOP || dir >= DIR_VIEW) {
return 0; /* all attempts failed */
}
-s_char *
-shp_path(int together, struct shpstr *shp, s_char *buf)
+char *
+shp_path(int together, struct shpstr *shp, char *buf)
{
coord destx;
coord desty;
struct sctstr d_sect;
- s_char *cp;
+ char *cp;
if (!sarg_xy(buf, &destx, &desty))
return 0;
struct emp_qelem list;
struct mlist *mlp;
int eff;
- s_char buf[512];
+ char buf[512];
emp_initque(&list);
int packing;
struct dchrstr *dp;
struct ichrstr *ip;
- s_char buf[1024];
+ char buf[1024];
/* try to get it from sector we're in */
getsect(x, y, &dest);
return 0;
}
-s_char *
+char *
trade_nameof(struct trdstr *tp, union trdgenstr *tgp)
{
switch (tp->trd_type) {
trechk(register natid actor, register natid victim, int provision)
{
register natid cn;
- s_char buf[1024];
+ char buf[1024];
int news_verb;
int involved[MAXNOC];
struct trtstr treaty;
#endif
int
-dodistribute(struct sctstr *sp, int imex, s_char *path, double dist_i_cost,
+dodistribute(struct sctstr *sp, int imex, char *path, double dist_i_cost,
double dist_e_cost)
/* import or export? */
{
/* Used for building up distribution info */
struct distinfo {
- s_char *path; /* path to take */
+ char *path; /* path to take */
double imcost; /* import cost */
double excost; /* export cost */
};
/* #define SAVE_FINISH_PATHS */
#ifndef SAVE_FINISH_PATHS
-static s_char *finish_path = "h"; /* Placeholder indicating path exists */
+static char *finish_path = "h"; /* Placeholder indicating path exists */
#endif /* SAVE_FINISH_PATHS */
static void assemble_dist_paths(struct distinfo *distptrs);
-static s_char *ReversePath(s_char *path);
+static char *ReversePath(char *path);
void
finish_sects(int etu)
static void
assemble_dist_paths(struct distinfo *distptrs)
{
- s_char *path, *p;
+ char *path, *p;
double d;
struct sctstr *sp;
struct sctstr *dist;
struct distinfo *infptr;
int n;
- s_char buf[512];
+ char buf[512];
for (n = 0; NULL != (sp = getsectid(n)); n++) {
if ((sp->sct_dist_x == sp->sct_x) && (sp->sct_dist_y == sp->sct_y))
}
}
-static s_char *
-ReversePath(s_char *path)
+static char *
+ReversePath(char *path)
{
- s_char *patharray = "aucdefjhigklmyopqrstbvwxnz";
- static s_char new_path[512];
+ char *patharray = "aucdefjhigklmyopqrstbvwxnz";
+ static char new_path[512];
int ind;
if (path == NULL)
int len = 0;
int follow = -1;
int stop;
- s_char *cp;
+ char *cp;
if (sp->shp_own == 0)
return 0;
struct shpstr *sp, ship;
struct sctstr *sectp;
int error = 0;
- s_char *s, *p;
+ char *s, *p;
natid own;
struct emp_qelem ship_list;
int dir;
struct natstr *god;
struct tm *tm;
time_t now;
- s_char header[100];
+ char header[100];
if (shutdown_pending <= 0) {
shutdown_pending = 0;
projects / empserver / commitdiff