Example #1
0
int
shark(void)
{
    int arg;
    time_t now;
    char *p;
    struct lonstr loan;
    struct natstr *natp;
    struct natstr *oldie;
    double owed;
    int payment;
    char buf[1024];

    if (!opt_LOANS) {
	pr("Loans are not enabled.\n");
	return RET_FAIL;
    }
    p = getstarg(player->argp[1], "Transfer which loan #: ", buf);
    if (!p)
	return RET_SYN;
    if (*p == 0)
	return RET_SYN;
    arg = atoi(p);
    if (arg < 0)
	return RET_SYN;
    /* Check if it's a valid loan to shark.  That means, is it a valid loan,
       not owed to this player, with a valid duration and it's been signed. */
    if (!getloan(arg, &loan) || (loan.l_loner == player->cnum) ||
	(loan.l_ldur == 0) || (loan.l_status != LS_SIGNED)) {
	pr("Invalid loan\n");
	return RET_FAIL;
    }
    /* If we got here, we check to see if it's been defaulted on. */
    owed = loan_owed(&loan, time(&now));
    if (now <= loan.l_duedate) {
	pr("There has been no default on loan %d\n", arg);
	return RET_FAIL;
    }
    pr("That loan is worth $%.2f.\n", owed);
    natp = getnatp(player->cnum);
    payment = (int)ceil(owed * (1.0 + loan.l_irate / 100.0));
    if (payment > natp->nat_money - 100.0) {
	pr("You do not have enough to cover that loan\n");
	return RET_FAIL;
    } else {
	wu(0, loan.l_lonee,
	   "%s bought loan #%d.  You now owe him!\n",
	   cname(player->cnum), arg);
	wu(0, loan.l_loner,
	   "%s bought loan #%d out from under you for %d\n",
	   cname(player->cnum), arg, payment);
	pr("You now own loan #%d.  Go break some legs.\n", arg);
    }
    oldie = getnatp(loan.l_loner);
    oldie->nat_money += payment;
    player->dolcost += payment;
    loan.l_loner = player->cnum;
    putloan(arg, &loan);
    return RET_OK;
}
Example #2
0
/*
 * Is object @p of type @type visible to the player?
 * TODO: Fold this into interators.
 */
static int
xdvisible(int type, void *p)
{
    struct empobj *gp = p;
    struct lonstr *lp = p;
    struct natstr *natp;
    int tlev;

    if (!empobj_in_use(type, p))
	return 0;

    switch (type) {
    case EF_SECTOR:
    case EF_SHIP:
    case EF_PLANE:
    case EF_LAND:
    case EF_NUKE:
    case EF_LOST:
    case EF_REALM:
	return gp->own == player->cnum || player->god;
    case EF_COUNTRY:
	return gp->own == player->cnum;
    case EF_NEWS:
	return !opt_HIDDEN || player->god; /* FIXME */
    case EF_LOAN:
	if (lp->l_status == LS_SIGNED)
	    return 1;
	return lp->l_loner == player->cnum || lp->l_lonee == player->cnum
	    || player->god;
    case EF_SHIP_CHR:
	tlev = ((struct mchrstr *)p)->m_tech;
	goto tech;
    case EF_PLANE_CHR:
	tlev = ((struct plchrstr *)p)->pl_tech;
	goto tech;
    case EF_LAND_CHR:
	tlev = ((struct lchrstr *)p)->l_tech;
    tech:
	natp = getnatp(player->cnum);
	return player->god || tlev <= (int)(1.25 * natp->nat_level[NAT_TLEV]);
    case EF_NUKE_CHR:
	tlev = ((struct nchrstr *)p)->n_tech;
	if (drnuke_const > MIN_DRNUKE_CONST) {
	    natp = getnatp(player->cnum);
	    if (tlev > (int)((int)(1.25 * natp->nat_level[NAT_RLEV])
			     / drnuke_const))
		return player->god;
	}
	goto tech;
    case EF_TABLE:
	return ((struct empfile *)p)->cadef != NULL;
    default:
	return 1;
    }
}
Example #3
0
void
prepare_sects(int etu, struct bp *bp)
{
    struct sctstr *sp;
    struct natstr *np;
    int n, civ_tax, uw_tax, mil_pay;

    memset(levels, 0, sizeof(levels));

/* Process all the fallout. */
    if (opt_FALLOUT) {
	if (!player->simulation) {
	    /* First, we determine which sectors to process fallout in */
	    for (n = 0; NULL != (sp = getsectid(n)); n++)
		sp->sct_updated = sp->sct_fallout != 0;
	    /* Next, we process the fallout there */
	    for (n = 0; NULL != (sp = getsectid(n)); n++)
		if (sp->sct_updated)
		    do_fallout(sp, etu);
	    /* Next, we spread the fallout */
	    for (n = 0; NULL != (sp = getsectid(n)); n++)
		if (sp->sct_updated)
		    spread_fallout(sp, etu);
	    /* Next, we decay the fallout */
	    for (n = 0; NULL != (sp = getsectid(n)); n++)
		if (sp->sct_fallout)
		    decay_fallout(sp, etu);
	}
    }
    for (n = 0; NULL != (sp = getsectid(n)); n++) {
	sp->sct_updated = 0;

	if (sp->sct_type == SCT_WATER)
	    continue;
	bp_set_from_sect(bp, sp);
	np = getnatp(sp->sct_own);

	if (np->nat_stat != STAT_SANCT) {
	    guerrilla(sp);
	    do_plague(sp, np, etu);
	    tax(sp, np, etu, &pops[sp->sct_own], &civ_tax, &uw_tax,
		&mil_pay);
	    np->nat_money += civ_tax + uw_tax + mil_pay;
	    if (sp->sct_type == SCT_BANK)
		np->nat_money += bank_income(sp, etu);
	}
    }
    for (n = 0; NULL != (np = getnatp(n)); n++) {
	np->nat_money += upd_slmilcosts(np->nat_cnum, etu);
    }
}
Example #4
0
/*
 * Send C_FLASH text to everyone.
 * Format text to send using printf-style @format and optional
 * arguments.  It is assumed to be plain ASCII.
 * Prefix text it with a header suitable for broadcast from deity.
 * Initiate an output queue flush, but do not wait for it to complete.
 */
void
pr_wall(char *format, ...)
{
    time_t now;
    struct tm *tm;
    char buf[4096];		/* UTF-8 */
    int n;
    struct player *p;
    va_list ap;

    time(&now);
    tm = localtime(&now);
    n = sprintf(buf, "BROADCAST from %s @ %02d:%02d: ",
		getnatp(0)->nat_cnam, tm->tm_hour, tm->tm_min);

    va_start(ap, format);
    (void)vsprintf(buf + n, format, ap);
    va_end(ap);
    for (p = player_next(NULL); p; p = player_next(p)) {
	if (p->state != PS_PLAYING)
	    continue;
	pr_player(p, C_FLASH, buf);
	io_output(p->iop, 0);
    }
}
Example #5
0
int
check_nat_name(char *cname, natid cnum)
{
    struct natstr *natp;
    natid cn;
    int allblank;
    char *p;

    if (strlen(cname) >= sizeof(natp->nat_cnam)) {
	pr("Country name too long\n");
	return 0;
    }

    allblank = 1;
    for (p = cname; *p != '\0'; p++) {
	if (iscntrl(*p)) {
	    pr("No control characters allowed in country names!\n");
	    return 0;
	} else if (!isspace(*p))
	    allblank = 0;
    }
    if (allblank) {
	pr("Country name can't be all blank\n");
	return 0;
    }

    for (cn = 0; NULL != (natp = getnatp(cn)); cn++) {
	if (cn != cnum && !strcmp(cname, natp->nat_cnam)) {
	    pr("Country #%d is already called `%s'\n", cn, cname);
	    return 0;
	}
    }
    return 1;
}
Example #6
0
/*
 * translate @x,y:int into
 * result params
 */
int
sarg_range(char *str, coord *xp, coord *yp, int *dist)
{
    coord x, y;
    long d;
    char *end;
    struct natstr *np;

    if (*str++ != '@')
	return 0;
    x = strtox(str, &str);
    if (x < 0 || *str++ != ',')
	return 0;
    y = strtoy(str, &str);
    if (y < 0 || *str++ != ':')
	return 0;
    d = strtol(str, &end, 10);
    if (end == str || (*end != 0 && !isspace(*end)) || d < 0)
	return 0;
    *dist = d;
    np = getnatp(player->cnum);
    *xp = xabs(np, x);
    *yp = yabs(np, y);
    return 1;
}
Example #7
0
/*
 * Get nation argument.
 * If @arg is not empty, use it
 * Else prompt for input using @prompt.
 * If no input is provided, return NULL.
 * If the argument identifies a country, return its getnatp() value.
 * Else complain and return NULL.
 * Caution: this function doesn't care for lack of contact.
 */
struct natstr *
natargp(char *arg, char *prompt)
{
    char buf[1024];
    int n;
    struct natstr *np;

    arg = getstarg(arg, prompt, buf);
    if (!arg || !*arg)
	return NULL;
    if (isdigit(*arg))
	n = atoi(arg);
    else {
	n = cnumb(arg);
	if (n == M_NOTUNIQUE) {
	    pr("Country '%s' is ambiguous\n", arg);
	    return NULL;
	}
    }
    np = getnatp(n);
    if (!np || np->nat_stat == STAT_UNUSED) {
	pr("Country '%s' doesn't exist.\n", arg);
	return NULL;
    }
    return np;
}
Example #8
0
/*
 * translate #1 or lx:ly,hx:hy into a result range struct
 * returns absolute coords
 */
int
sarg_area(char *str, struct range *rp)
{
    long rlm;
    struct natstr *np;
    struct realmstr realm;
    char *end;

    if (*str == '#') {
	/*
	 * realm #X where (X > 0 && X < MAXNOR)
	 * Assumes realms are in abs coordinates
	 */
	if (*++str) {
	    rlm = strtol(str, &end, 10);
	    if (end == str || (*end != 0 && !isspace(*end))
		|| rlm < 0 || MAXNOR <= rlm)
		return 0;
	} else
	    rlm = 0;
	getrealm(rlm, player->cnum, &realm);
	rp->lx = realm.r_xl;
	rp->hx = realm.r_xh;
	rp->ly = realm.r_yl;
	rp->hy = realm.r_yh;
    } else {
	/*
	 * full map specification
	 * LX:LY,HX:HY where
	 * ly, hy are optional.
	 */
	rp->lx = rp->hx = strtox(str, &str);
	if (rp->lx < 0)
	    return 0;
	if (*str == ':') {
	    rp->hx = strtox(str + 1, &str);
	    if (rp->hx < 0)
		return 0;
	}
	if (*str++ != ',')
	    return 0;
	rp->ly = rp->hy = strtoy(str, &str);
	if (rp->ly < 0)
	    return 0;
	if (*str == ':') {
	    rp->hy = strtoy(str + 1, &str);
	    if (rp->hy < 0)
		return 0;
	}
	if (*str != 0 && !isspace(*str))
	    return 0;
	np = getnatp(player->cnum);
	rp->lx = xabs(np, rp->lx);
	rp->hx = xabs(np, rp->hx);
	rp->ly = yabs(np, rp->ly);
	rp->hy = yabs(np, rp->hy);
    }
    xysize_range(rp);
    return 1;
}
Example #9
0
/* Extended dump command */
int
xdump(void)
{
    char *p;
    char buf[1024];
    struct xdstr xd;
    struct natstr *natp;
    int type;
    int meta = 0;

    p = getstarg(player->argp[1], "Table name, or meta? ", buf);
    if (p && strcmp(p, "meta") == 0) {
	meta = 1;
	p = getstarg(player->argp[2], "Table name? ", buf);
    }
    if (!p || !*p)
	return RET_SYN;

    xdinit(&xd, player->cnum, 0, 0, pr);
    natp = getnatp(player->cnum);
    type = isdigit(p[0]) ? atoi(p) : ef_byname(p);
    if (type < 0 || type >= EF_MAX)
	return RET_SYN;
    if (meta)
	return xdmeta(&xd, type);
    if ((EF_IS_GAME_STATE(type) || EF_IS_VIEW(type))
	&& !(natp->nat_stat == STAT_ACTIVE || player->god)) {
	pr("Access to table %s denied\n", ef_nameof(type));
	return RET_FAIL;
    }
    return xditem(&xd, type, player->argp[2]);
}
Example #10
0
/*
 * Print coordinates @x,@y.
 * @format must be a printf-style format string that converts exactly
 * two int values.
 */
void
prxy(char *format, coord x, coord y)
{
    struct natstr *np;

    np = getnatp(player->cnum);
    pr(format, xrel(np, x), yrel(np, y));
}
Example #11
0
/*
 * Sound the current player's bell.
 */
void
pr_beep(void)
{
    struct natstr *np = getnatp(player->cnum);

    if (np->nat_flags & NF_BEEP)
	pr("\07");
}
Example #12
0
/*
 * Accept a loan.  If the offering country has too little money,
 * leave him $100 left and offer the rest.  Return RET_OK on
 * success, anything else on error.
 */
static int
loan_accept(struct ltcomstr *ltcp)
{
    struct lonstr *lp;
    struct natstr *lender;
    struct nstr_item nstr;
    struct lonstr loan;

    lp = &ltcp->u.l;
    if (ltcp->proposee != player->cnum) {
	pr("%s %d is still pending.\n", ltcp->Name, ltcp->num);
	return RET_OK;
    }
    if (!getloan(ltcp->num, lp)) {
	logerror("loan_accept: can't read loan");
	pr("can't read loan; get help!\n");
	return RET_FAIL;
    }
    if (lp->l_status == LS_FREE) {	/* other guy retratcted already */
	late(ltcp);
	return RET_OK;
    }
    if (lp->l_status == LS_SIGNED) {	/* already signed somehow */
	prev_signed(ltcp);
	return RET_OK;
    }
    /* check to see if a loan already exists */
    snxtitem_all(&nstr, EF_LOAN);
    while (nxtitem(&nstr, &loan)) {
	if (loan.l_status == LS_SIGNED && loan.l_lonee == lp->l_loner
	    && (loan.l_loner == lp->l_lonee)) {
	    pr("He already owes you money - make him repay his loan!\n");
	    return RET_OK;
	}
    }
    lender = getnatp(ltcp->proposer);
    if (lender->nat_money < lp->l_amtdue) {	/* other guy is poor */
	lp->l_amtdue = lender->nat_money - 100;
	pr("%s no longer has the funds.\n", cname(ltcp->proposer));
	if (lp->l_amtdue <= 0)
	    return RET_FAIL;
	pr("You may borrow $%d at the same terms.\n", lp->l_amtdue);
    }
    lender->nat_money -= lp->l_amtdue;
    putnat(lender);
    player->dolcost -= lp->l_amtdue;
    lp->l_amtpaid = 0;
    (void)time(&lp->l_lastpay);
    lp->l_duedate = lp->l_ldur * SECS_PER_DAY + lp->l_lastpay;
    lp->l_status = LS_SIGNED;
    if (!putloan(ltcp->num, lp)) {
	pr("Problem writing lp->to disk; get help!\n");
	return RET_FAIL;
    }
    accpt(ltcp);
    pr("You are now $%d richer (sort of).\n", lp->l_amtdue);
    return RET_OK;
}
Example #13
0
int
orig(void)
{
    char *p;
    coord x, y;
    char buf[1024];
    int cnum;
    struct natstr *np;

    p = getstarg(player->argp[1], "New origin (sector or country) : ", buf);
    if (!p || !*p)
        return RET_SYN;
    if (!isalpha(*p) && strchr(p, ',')) {
        /* sector */
        if (!sarg_xy(p, &x, &y)) {
            pr("Bad sector designation.\n");
            return RET_SYN;
        }
    } else if (*p == '~') {
        /* reset */
        if (!player->god) {
            pr("Only deities can reset their origin.\n");
            return RET_FAIL;
        }
        x = y = 0;
    } else {
        /* country */
        cnum = natarg(p, NULL);
        if (!(np = getnatp(cnum)))
            return RET_SYN;
        if (!player->god && relations_with(cnum, player->cnum) != ALLIED) {
            pr("Country %s is not allied with you!\n", np->nat_cnam);
            return RET_FAIL;
        }
        x = np->nat_xorg;
        y = np->nat_yorg;
    }
    pr("Origin at %s (old system) is now at 0,0 (new system).\n",
       xyas(x, y, player->cnum));
    np = getnatp(player->cnum);
    np->nat_xorg = x;
    np->nat_yorg = y;
    putnat(np);
    return RET_OK;
}
Example #14
0
static int
play_cmd(void)
{
    struct player *other;
    natid cnum;
    struct natstr *natp;
    char **ap;
    char buf[128];

    ap = player->argp;
    if (*++ap) {
        strncpy(player->userid, *ap, sizeof(player->userid) - 1);
        player->userid[sizeof(player->userid) - 1] = '\0';
        player->authenticated = 0;
    }
    if (*++ap) {
        if (natbyname(*ap, &cnum) < 0) {
            pr_id(player, C_CMDERR, "country %s does not exist\n", *ap);
            return RET_FAIL;
        }
    }
    if (*++ap) {
        if (!natpass(cnum, *ap)) {
            pr_id(player, C_CMDERR, "password bad, logging entry\n");
            logerror("%s tried country #%d with %s",
                     praddr(player), cnum, *ap);
            return RET_FAIL;
        }
        player->cnum = cnum;
        player->authenticated = 1;
    }
    if (!may_play())
        return RET_FAIL;
    other = getplayer(player->cnum);
    if (other) {
        natp = getnatp(player->cnum);
        if (natp->nat_stat != STAT_VIS) {
            pr_id(player, C_EXIT, "country in use by %s\n", praddr(other));
        } else {
            pr_id(player, C_EXIT, "country in use\n");
        }
        return RET_FAIL;
    }
    snprintf(buf, sizeof(buf), "Play#%d", player->cnum);
    logerror("%s logged in as country #%d", praddr(player), player->cnum);
    journal_login();
    empth_set_name(empth_self(), buf);
    pr_id(player, C_INIT, "%d\n", CLIENTPROTO);
    empth_rwlock_rdlock(shutdown_lock);
    player->state = PS_PLAYING;
    player_main(player);
    journal_logout();
    logerror("%s logged out, country #%d", praddr(player), player->cnum);
    if (!io_eof(player->iop) && !io_error(player->iop))
        io_set_eof(player->iop);
    return RET_OK;
}
Example #15
0
char *
prnatid(natid cnum)
{
    struct natstr *np = getnatp(cnum);

    if (CANT_HAPPEN(!np))
	return prbuf("%d (#%d)", cnum, cnum);
    return prnat(np);
}
Example #16
0
void
setcont(natid us, natid them, int contact)
{
    struct natstr *np = getnatp(us);

    if (CANT_HAPPEN(!np))
	return;
    putcontact(np, them, contact);
    putnat(np);
}
Example #17
0
void
setrej(natid us, natid them, int how, int what)
{
    struct natstr *np = getnatp(us);

    if (CANT_HAPPEN(!np))
	return;
    putreject(np, them, how, what);
    putnat(np);
}
Example #18
0
/*
 * Initialize @xd.
 * If @cnum is NATID_BAD, this is an empdump export rather than an
 * xdump command.
 * Translate dump for country @cnum, except when @cnum is NATID_BAD.
 * Ignore CA_DUMP_ONLY selectors when @cnum is NATID_BAD.
 * If @human, dump in human-readable format.
 * If @sloppy, try to cope with invalid data (may result in invalid
 * dump).
 * Dump is to be delivered through callback @pr.
 * Return @xd.
 */
struct xdstr *
xdinit(struct xdstr *xd, natid cnum, int human, int sloppy,
       void (*pr)(char *fmt, ...))
{
    xd->cnum = cnum;
    xd->divine = cnum == NATID_BAD || getnatp(cnum)->nat_stat == STAT_GOD;
    xd->human = human;
    xd->sloppy = sloppy;
    xd->pr = pr;
    return xd;
}
Example #19
0
double
tfact(natid cn, double mult)
{
    double tlev;
    struct natstr *np;

    np = getnatp(cn);
    tlev = np->nat_level[NAT_TLEV];
    tlev = (50.0 + tlev) / (200.0 + tlev);
    return mult * tlev;
}
Example #20
0
void
enforce_minimum_session_time(void)
{
    struct natstr *natp = getnatp(player->cnum);

    time_t dt = natp->nat_last_logout - natp->nat_last_login;
    if (dt > seconds_since_midnight(natp->nat_last_logout))
	dt = seconds_since_midnight(natp->nat_last_logout);
    if (dt < 15)
	natp->nat_timeused += 15 - dt;
    putnat(natp);
}
Example #21
0
void
update_timeused_login(time_t now)
{
    struct natstr *natp = getnatp(player->cnum);
    time_t midnight_secs = seconds_since_midnight(now);

    if (now - natp->nat_last_logout > midnight_secs) {
	natp->nat_timeused = 0;
	putnat(natp);
    }
    player->lasttime = now;
}
Example #22
0
int
natpass(natid cn, char *pass)
{
    struct natstr *np;

    np = getnatp(cn);
    if (np->nat_stat == STAT_VIS)
	return 1;
    if (strcmp(np->nat_pnam, pass) == 0)
	return 1;
    return 0;
}
Example #23
0
void
update_timeused(time_t now)
{
    struct natstr *natp = getnatp(player->cnum);
    time_t midnight_secs = seconds_since_midnight(now);
    time_t dt = now - player->lasttime;

    if (dt > midnight_secs)
	natp->nat_timeused = midnight_secs;
    else
	natp->nat_timeused += dt;
    player->lasttime = now;
    putnat(natp);
}
Example #24
0
int
natbyname(char *name, natid *result)
{
    struct natstr *np;
    int i;

    for (i = 0; NULL != (np = getnatp(i)); i++) {
	if (np->nat_stat != STAT_UNUSED && !strcmp(np->nat_cnam, name)) {
	    *result = i;
	    return 0;
	}
    }
    *result = NATID_BAD;
    return -1;
}
Example #25
0
/*
 * Get nation argument.
 * If @arg is not empty, use it.
 * Else prompt for input using @prompt.
 * If no input is provided, return -1.
 * If the argument identifies a country, return its number.  getnatp()
 * can be assumed to succeed for this number.
 * Else complain and return -1.
 * If HIDDEN is enabled, countries not contacted are not eligible
 * unless the player is a deity.
 */
int
natarg(char *arg, char *prompt)
{
    struct natstr *np = natargp(arg, prompt);
    if (!np)
	return -1;
    if (opt_HIDDEN) {
	if (!player->god && !getcontact(getnatp(player->cnum), np->nat_cnum)) {
	    if (np->nat_stat != STAT_GOD) {
		pr("Country '%s' has not been contacted.\n", arg);
		return -1;
	    }
	}
    }
    return np->nat_cnum;
}
Example #26
0
int
real(void)
{
    struct realmstr realm;
    struct natstr *natp;
    int curr;
    int lastr;
    struct range abs;
    char *realmp = player->argp[1];

    natp = getnatp(player->cnum);
    if (!realmp) {
	curr = 0;
	lastr = MAXNOR - 1;
    } else {
	if (*realmp == '#')
	    ++realmp;
	if (*realmp && !isdigit(*realmp))
	    return RET_SYN;
	curr = lastr = atoi(realmp);
	if (curr < 0 || curr >= MAXNOR) {
	    pr("Realm number must be in the range 0:%d\n", MAXNOR - 1);
	    return RET_SYN;
	}
    }
    if (!player->argp[2]) {
	while (curr <= lastr) {
	    list_realm(curr, natp);
	    curr++;
	}
    } else {
	if (sarg_type(player->argp[2]) != NS_AREA)
	    return RET_SYN;
	abs.width = 0;
	abs.height = 0;
	if (!sarg_area(player->argp[2], &abs))
	    return RET_SYN;
	getrealm(curr, natp->nat_cnum, &realm);
	realm.r_xl = abs.lx;
	realm.r_xh = abs.hx;
	realm.r_yl = abs.ly;
	realm.r_yh = abs.hy;
	putrealm(&realm);
	list_realm(curr, natp);
    }
    return RET_OK;
}
Example #27
0
/*
 * setup the nstr_sect structure for sector selection.
 * can select on either NS_ALL, NS_AREA, or NS_DIST
 * iterate thru the "condarg" string looking
 * for arguments to compile into the nstr.
 * Using this function for anything but command arguments is usually
 * incorrect, because it respects conditionals.  Use the snxtsct_FOO()
 * instead.
 */
int
snxtsct(struct nstr_sect *np, char *str)
{
    struct range range;
    struct natstr *natp;
    coord cx, cy;
    int dist;
    char buf[1024];

    if (!str || !*str) {
	if (!(str = getstring("(sects)? ", buf)))
	    return 0;
    } else
	make_stale_if_command_arg(str);
    switch (sarg_type(str)) {
    case NS_AREA:
	if (!sarg_area(str, &range))
	    return 0;
	snxtsct_area(np, &range);
	break;
    case NS_DIST:
	if (!sarg_range(str, &cx, &cy, &dist))
	    return 0;
	snxtsct_dist(np, cx, cy, dist);
	break;
    case NS_ALL:
	/*
	 * Can't use snxtsct_all(), as it would disclose the real
	 * origin.  Use a world-sized area instead.
	 */
	natp = getnatp(player->cnum);
	range.lx = xabs(natp, -WORLD_X / 2);
	range.ly = yabs(natp, -WORLD_Y / 2);
	range.hx = xnorm(range.lx + WORLD_X - 1);
	range.hy = ynorm(range.ly + WORLD_Y - 1);
	xysize_range(&range);
	snxtsct_area(np, &range);
	break;
    default:
	return 0;
    }
    return snxtsct_use_condarg(np);
}
Example #28
0
int
sarg_xy(char *str, coord *xp, coord *yp)
{
    coord x, y;
    struct natstr *np;

    x = strtox(str, &str);
    if (x < 0 || *str++ != ',')
	return 0;
    y = strtoy(str, &str);
    if (y < 0 || (*str != 0 && !isspace(*str)))
	return 0;
    if ((x ^ y) & 1)
	return 0;
    np = getnatp(player->cnum);
    *xp = xabs(np, x);
    *yp = yabs(np, y);
    return 1;
}
Example #29
0
int
prod_plane(int etus, int natnum, struct bp *bp, int buildem)
		 /* Build = 1, maintain =0 */
{
    struct plnstr *pp;
    struct natstr *np;
    int n, k = 0;
    int start_money;

    for (n = 0; NULL != (pp = getplanep(n)); n++) {
	if (pp->pln_own == 0)
	    continue;
	if (pp->pln_own != natnum)
	    continue;
	if (pp->pln_effic < PLANE_MINEFF) {
	    makelost(EF_PLANE, pp->pln_own, pp->pln_uid,
		     pp->pln_x, pp->pln_y);
	    pp->pln_own = 0;
	    continue;
	}

	if (pln_is_in_orbit(pp)) {
	    if (!player->simulation && buildem == 0
		&& !(pp->pln_flags & PLN_SYNCHRONOUS))
		move_sat(pp);
	    continue;
	}

	np = getnatp(pp->pln_own);
	start_money = np->nat_money;
	upd_plane(pp, etus, np, bp, buildem);
	air_money[pp->pln_own] += np->nat_money - start_money;
	if (buildem == 0 || np->nat_money != start_money)
	    k++;
	if (player->simulation)
	    np->nat_money = start_money;
    }

    return k;
}
Example #30
0
static int
may_play(void)
{
    struct natstr *np;

    if (player->cnum == NATID_BAD || !player->authenticated) {
        pr_id(player, C_CMDERR, "need country and password\n");
        return 0;
    }
    /* TODO strstr() cheesy, compare IP against IP/BITS ... */
    np = getnatp(player->cnum);
    if (np->nat_stat == STAT_GOD && *privip
            && !strstr(privip, player->hostaddr)) {
        logerror("Deity login from untrusted host attempted by %s",
                 praddr(player));
        logerror("To allow this, add %s to econfig key privip",
                 player->hostaddr);
        pr_id(player, C_EXIT,
              "Deity login not allowed from this IP!"
              "  See log for help on how to allow it.\n");
        return 0;
    }
    return 1;
}