예제 #1
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;
}
예제 #2
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);
}
예제 #3
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);
}
예제 #4
0
파일: empdis.c 프로젝트: fstltna/empserver
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);
}
예제 #5
0
파일: empdis.c 프로젝트: fstltna/empserver
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;
}
예제 #6
0
파일: empdis.c 프로젝트: fstltna/empserver
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);
}
예제 #7
0
파일: orig.c 프로젝트: gefla/empserver
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;
}
예제 #8
0
int
chan(void)
{
    char *p;
    int charge;
    int btucost;
    char buf[1024];
    struct natstr *us;

    p = getstarg(player->argp[1], "country name or representative? ", buf);
    if (!p)
	return RET_SYN;
    us = getnatp(player->cnum);
    switch (*p) {
    case 'n':
    case 'c':
	charge = 0;
	btucost = 0;
	if (us->nat_stat == STAT_ACTIVE) {
	    if (opt_BLITZ == 0) {
		if (us->nat_btu < 254) {
		    pr("You need 254 btus to change your country name!\n");
		    return RET_FAIL;
		}
		pr("This command costs 254 BTU's and 10%% of your money.\n");
		if (!confirm("Are you sure you want to do this? "))
		    return RET_FAIL;
		btucost = 254;
		if (us->nat_money <= 0)
		    charge = 0;
		else
		    charge = us->nat_money / 10;
	    }
	}
	p = getstarg(player->argp[2], "New country name -- ", buf);
	if (!p)
	    return RET_SYN;
	if (!check_nat_name(p, player->cnum))
	    return RET_FAIL;
	player->dolcost += charge;
	player->btused += btucost;
	strcpy(us->nat_cnam, p);
	putnat(us);
	nreport(player->cnum, N_NAME_CHNG, 0, 1);
	break;
    case 'p':
    case 'r':
	pr("(note: these are stored in plain text.)\n");
	p = getstarg(player->argp[2], "New representative name -- ", buf);
	if (!p)
	    return RET_SYN;
	p[sizeof(us->nat_pnam) - 1] = 0;
	strcpy(us->nat_pnam, p);
	putnat(us);
	break;
    default:
	pr("Only \"country\" or \"representative\" can change.\n");
	return RET_SYN;
    }
    return RET_OK;
}
예제 #9
0
파일: repa.c 프로젝트: gefla/empserver
int
repa(void)
{
    struct lonstr loan;
    struct natstr *natp;
    struct natstr *loaner;
    int loan_num;
    int payment;
    int newdue;
    char *cp;
    time_t now;
    char buf[1024];

    if (!opt_LOANS) {
	pr("Loans are not enabled.\n");
	return RET_FAIL;
    }
    natp = getnatp(player->cnum);
    cp = getstarg(player->argp[1], "Repay loan #? ", buf);
    if (!cp)
	return RET_SYN;
    loan_num = atoi(cp);
    if (loan_num < 0)
	return RET_SYN;
    if (!getloan(loan_num, &loan) || loan.l_lonee != player->cnum
	|| loan.l_status != LS_SIGNED) {
	pr("You don't owe anything on that loan.\n");
	return RET_FAIL;
    }
    if (!(cp = getstarg(player->argp[2], "amount? ", buf)))
	return RET_SYN;
    if (!check_loan_ok(&loan))
	return RET_FAIL;
    payment = atoi(cp);
    if (payment <= 0)
	return RET_SYN;

    newdue = (int)ceil(loan_owed(&loan, time(&now)) - payment);
    if (newdue < 0) {
	pr("You don't owe that much.\n");
	return RET_FAIL;
    }
    if (natp->nat_money < payment) {
	pr("You only have $%d.\n", natp->nat_money);
	return RET_FAIL;
    }
    player->dolcost += payment;
    loaner = getnatp(loan.l_loner);
    loaner->nat_money += payment;
    putnat(loaner);
    loan.l_lastpay = now;
    if (newdue == 0) {
	wu(0, loan.l_loner, "Country #%d paid off loan #%d with $%d\n",
	   player->cnum, loan_num, payment);
	nreport(player->cnum, N_REPAY_LOAN, loan.l_loner, 1);
	loan.l_status = LS_FREE;
	loan.l_ldur = 0;
	pr("Congratulations, you've paid off the loan!\n");
    } else {
	wu(0, loan.l_loner,
	   "Country #%d paid $%d on loan %d\n",
	   player->cnum, payment, loan_num);
	loan.l_amtdue = newdue;
	loan.l_amtpaid += payment;
    }
    if (!putloan(loan_num, &loan)) {
	logerror("repa: can't write loan");
	pr("Can't save loan; get help!\n");
	return RET_FAIL;
    }
    return RET_OK;
}
예제 #10
0
void
setrel(natid us, natid them, int rel)
{
    struct natstr *mynp = getnatp(us);
    struct natstr *themnp = getnatp(them);
    int oldrel;
    char *whichway;
    int n_up = 0;
    int n_down = 0;
    char *addendum = NULL;

    if (CANT_HAPPEN(rel < AT_WAR))
	rel = AT_WAR;
    if (CANT_HAPPEN(rel > ALLIED))
	rel = ALLIED;
    if (CANT_HAPPEN(!mynp || !themnp))
	return;
    if (us == them)
	return;
    oldrel = relations_with(us, them);
    if (oldrel == rel)
	return;
    if (rel > oldrel)
	whichway = "upgraded";
    else
	whichway = "downgraded";
    if (rel == ALLIED) {
	addendum = "Congratulations!";
	n_up = N_DECL_ALLY;
    } else if (rel == FRIENDLY) {
	n_up = N_UP_FRIENDLY;
	n_down = N_DOWN_FRIENDLY;
    } else if (rel == NEUTRAL) {
	n_up = N_UP_NEUTRAL;
	n_down = N_DOWN_NEUTRAL;
    } else if (rel == HOSTILE) {
	addendum = "Another cold war...";
	n_up = N_UP_HOSTILE;
	n_down = N_DOWN_HOSTILE;
    } else if (rel < HOSTILE) {
	addendum = "Declaration made (give 'em hell).";
	n_down = N_DECL_WAR;
    }

    if (addendum && us == player->cnum && !update_running)
	pr("%s\n", addendum);
    mpr(us, "Diplomatic relations with %s %s to \"%s\".\n",
	cname(them), whichway, relates[rel]);
    if (!(getrejects(us, themnp) & REJ_TELE))
	mpr(them,
	    "Country %s has %s their relations with you to \"%s\"!\n",
	    prnat(mynp), whichway, relates[rel]);

    putrel(mynp, them, rel);
    putnat(mynp);

    if (!player->god) {
	if (oldrel == ALLIED)
	    nreport(us, N_DIS_ALLY, them, 1);
	else if (oldrel < HOSTILE && rel >= HOSTILE)
	    nreport(us, N_DIS_WAR, them, 1);
	if (rel > oldrel)
	    nreport(us, n_up, them, 1);
	else
	    nreport(us, n_down, them, 1);
    }
    if (opt_HIDDEN)
	setcont(them, us, FOUND_TELE);
}
예제 #11
0
파일: trad.c 프로젝트: fstltna/empserver
int
check_trade(void)
{
    int n;
    struct natstr *natp;
    struct trdstr trade;
    union empobj_storage tg;
    time_t now;
    int price;
    int saveid;
    natid seller;

    for (n = 0; gettrade(n, &trade); n++) {
	if (trade.trd_unitid < 0)
	    continue;
	if (!trade_getitem(&trade, &tg))
	    continue;
	if (tg.gen.own == 0) {
	    trade.trd_owner = 0;
	    trade.trd_unitid = -1;
	    puttrade(n, &trade);
	    continue;
	}
	if (tg.gen.own != trade.trd_owner) {
	    logerror("Something weird, tg.gen.own != trade.trd_owner!\n");
	    trade.trd_owner = 0;
	    trade.trd_unitid = -1;
	    puttrade(n, &trade);
	    continue;
	}

	if (trade.trd_owner == trade.trd_maxbidder)
	    continue;

	(void)time(&now);
	if (trade.trd_markettime + TRADE_DELAY > now)
	    continue;

	saveid = trade.trd_unitid;
	seller = trade.trd_owner;
	trade.trd_owner = 0;
	trade.trd_unitid = -1;
	if (!puttrade(n, &trade)) {
	    logerror("Couldn't save trade after purchase; get help!\n");
	    continue;
	}

	price = trade.trd_price;
	natp = getnatp(trade.trd_maxbidder);
	if (natp->nat_money < price) {
	    nreport(trade.trd_maxbidder, N_WELCH_DEAL, seller, 1);
	    wu(0, seller,
	       "%s tried to buy a %s #%d from you for $%.2f\n",
	       cname(trade.trd_maxbidder), trade_nameof(&trade, &tg.gen),
	       saveid, price * tradetax);
	    wu(0, seller, "   but couldn't afford it.\n");
	    wu(0, seller,
	       "   Your item was taken off the market.\n");
	    wu(0, trade.trd_maxbidder,
	       "You tried to buy %s #%d from %s for $%d\n",
	       trade_nameof(&trade, &tg.gen), saveid, cname(seller),
	       price);
	    wu(0, trade.trd_maxbidder, "but couldn't afford it.\n");
	    continue;
	}

/* If we get this far, the sale will go through. */

	natp->nat_money -= price;
	putnat(natp);

	natp = getnatp(seller);
	natp->nat_money += roundavg(price * tradetax);
	putnat(natp);

	switch (trade.trd_type) {
	case EF_NUKE:
	    tg.nuke.nuk_x = trade.trd_x;
	    tg.nuke.nuk_y = trade.trd_y;
	    tg.nuke.nuk_plane = -1;
	    break;
	case EF_PLANE:
	    if (!pln_is_in_orbit(&tg.plane)) {
		tg.plane.pln_x = trade.trd_x;
		tg.plane.pln_y = trade.trd_y;
	    }
	    if (opt_MOB_ACCESS) {
		tg.plane.pln_mobil = -(etu_per_update / sect_mob_neg_factor);
		game_tick_to_now(&tg.plane.pln_access);
	    } else {
		tg.plane.pln_mobil = 0;
	    }
	    tg.plane.pln_harden = 0;
	    tg.plane.pln_ship = -1;
	    tg.plane.pln_land = -1;
	    break;
	case EF_SHIP:
	    break;
	case EF_LAND:
	    tg.land.lnd_x = trade.trd_x;
	    tg.land.lnd_y = trade.trd_y;
	    if (opt_MOB_ACCESS) {
		tg.land.lnd_mobil = -(etu_per_update / sect_mob_neg_factor);
		game_tick_to_now(&tg.land.lnd_access);
	    } else {
		tg.land.lnd_mobil = 0;
	    }
	    tg.land.lnd_harden = 0;
	    unit_drop_cargo(&tg.gen, 0);
	    tg.land.lnd_ship = -1;
	    tg.land.lnd_land = -1;
	    break;
	default:
	    logerror("Bad trade type %d in trade\n", trade.trd_type);
	    break;
	}
	unit_give_away(&tg.gen, trade.trd_maxbidder, 0);
	put_empobj(trade.trd_type, saveid, &tg.gen);

	nreport(seller, N_MAKE_SALE, trade.trd_maxbidder, 1);
	wu(0, seller, "%s bought %s #%d from you for $%.2f\n",
	   cname(trade.trd_maxbidder), trade_nameof(&trade, &tg.gen),
	   saveid, price * tradetax);
	wu(0, trade.trd_maxbidder,
	   "The bidding is over & you bought %s #%d from %s for $%d\n",
	   trade_nameof(&trade, &tg.gen), saveid, cname(seller),
	   price);
    }
    return RET_OK;
}
예제 #12
0
int
enli(void)
{
    struct nstr_sect nstr;
    struct sctstr sect;
    struct natstr *natp;
    int civ;
    int mil;
    int newmil;
    int milwant;
    int totalmil;
    int reserve;
    char *p;
    int quota;
    char prompt[128];
    char buf[1024];

    if (!snxtsct(&nstr, player->argp[1]))
	return RET_SYN;
    natp = getnatp(player->cnum);
    newmil = 500;
    sprintf(prompt, "Number to enlist (max %d) : ", newmil);
    if (!(p = getstarg(player->argp[2], prompt, buf)))
	return RET_SYN;
    if ((milwant = atoi(p)) > newmil)
	milwant = newmil;
    if (0 != (quota = (milwant < 0)))
	milwant = -milwant;
    totalmil = 0;
    reserve = natp->nat_reserve;
    if (reserve <= 0) {
	pr("No military reserves left\n");
	return RET_OK;
    }
    while (nxtsct(&nstr, &sect)) {
	if (!player->owner)
	    continue;
	if (sect.sct_oldown != player->cnum)
	    continue;
	civ = sect.sct_item[I_CIVIL];
	if (civ == 0)
	    continue;
	if (sect.sct_loyal > 70) {
	    pr("civilians refuse to report in %s!\n",
	       xyas(sect.sct_x, sect.sct_y, player->cnum));
	    continue;
	}
	if (sect.sct_mobil <= 0) {
	    pr("%s is out of mobility!\n",
	       xyas(sect.sct_x, sect.sct_y, player->cnum));
	}
	mil = sect.sct_item[I_MILIT];
	newmil = civ * 0.5;
	if (quota) {
	    if (newmil > milwant - mil)
		newmil = milwant - mil;
	    if (newmil > 500)
		newmil = 500;
	} else if (newmil > milwant)
	    newmil = milwant;
	if (newmil > 999 - mil)
	    newmil = 999 - mil;
	if (newmil <= 0)
	    continue;
	if (newmil > reserve)
	    newmil = reserve;
	sect.sct_item[I_MILIT] = newmil + mil;
	reserve -= newmil;
	totalmil += newmil;
	sect.sct_item[I_CIVIL] = civ - newmil;
	pr("%3d enlisted in %s (%d)\n", newmil,
	   xyas(sect.sct_x, sect.sct_y, player->cnum), mil + newmil);
	if (sect.sct_mobil > 0)
	    sect.sct_mobil *= 1.0 - (double)newmil / (double)civ;
	putsect(&sect);
	if (totalmil >= 10000) {
	    pr("Rioting in induction center interrupts enlistment\n");
	    break;
	}
	if (reserve == 0) {
	    pr("Military reserve exhausted\n");
	    break;
	}
    }
    pr("Total new enlistment : %d\n", totalmil);
    pr("Military reserves stand at %d\n", reserve);
    if (totalmil) {
	natp->nat_reserve -= totalmil;
	putnat(natp);
    }
    if ((player->btused += roundavg(totalmil * 0.02)) > 0)
	pr("Paperwork at recruiting stations ... %d\n", player->btused);
    return RET_OK;
}
예제 #13
0
파일: buy.c 프로젝트: gefla/empserver
int
check_market(void)
{
    struct comstr comm;
    struct sctstr *sect;
    struct natstr *natp;
    int m;
    int n;
    time_t now;
    double gain;
    double price;

    for (n = 0; getcomm(n, &comm); n++) {
	if (comm.com_maxbidder == comm.com_owner || comm.com_owner == 0)
	    continue;
	(void)time(&now);
	if (comm.com_markettime + MARK_DELAY > now)
	    continue;
	if (CANT_HAPPEN(comm.com_type <= I_NONE || comm.com_type > I_MAX))
	    continue;
	sect = getsectp(comm.com_x, comm.com_y);
	m = sect->sct_item[comm.com_type];

	price = comm.com_price * comm.com_amount * buytax;
	gain = comm.com_price * comm.com_amount;

	natp = getnatp(comm.com_maxbidder);
	if (natp->nat_money < price) {
	    nreport(comm.com_maxbidder, N_WELCH_DEAL, comm.com_owner, 1);
	    wu(0, comm.com_maxbidder,
	       "You didn't have enough cash to cover the cost.\n");
	    wu(0, comm.com_owner,
	       "Sale #%d fell through.  Goods remain on the market.\n", n);
	    comm.com_maxbidder = comm.com_owner;
	} else if (sect->sct_type != SCT_WAREH
		   && sect->sct_type != SCT_HARBR) {
	    wu(0, comm.com_maxbidder,
	       "Sector not a warehouse now, sale #%d fell though.\n", n);
	    wu(0, comm.com_owner,
	       "Sale #%d fell through.  Goods remain on the market.\n", n);
	    comm.com_maxbidder = comm.com_owner;
	} else if (m + comm.com_amount > ITEM_MAX) {
	    wu(0, comm.com_maxbidder,
	       "Warehouse full,  sale #%d fell though.\n", n);
	    wu(0, comm.com_owner,
	       "Sale #%d fell through.  Goods remain on the market.\n", n);
	    comm.com_maxbidder = comm.com_owner;
	} else {
	    sect->sct_item[comm.com_type] = m + comm.com_amount;
	    putsect(sect);
	    nreport(comm.com_owner, N_MAKE_SALE, comm.com_maxbidder, 1);
	    wu(0, comm.com_owner, "%s bought %d %s from you for $%.2f\n",
	       cname(comm.com_maxbidder), comm.com_amount,
	       ichr[comm.com_type].i_name, gain);
	    wu(0, comm.com_maxbidder,
	       "You just bought %d %s from %s for $%.2f\n",
	       comm.com_amount, ichr[comm.com_type].i_name,
	       cname(comm.com_owner), price);
	    natp->nat_money -= roundavg(price);
	    putnat(natp);
	    natp = getnatp(comm.com_owner);
	    natp->nat_money += roundavg(gain);
	    putnat(natp);
	    comm.com_owner = 0;
	}
	comm.com_owner = 0;
	putcomm(n, &comm);
    }
    return RET_OK;
}
예제 #14
0
int
edit(void)
{
    union empobj_storage item;
    char *what;
    struct nstr_item ni;
    char *key, *ptr;
    struct natstr *np;
    int type, arg_index, ret;
    char buf[1024];

    what = getstarg(player->argp[1],
		    "Edit what (country, land, ship, plane, nuke, unit)? ",
		    buf);
    if (!what)
	return RET_SYN;
    switch (what[0]) {
    case 'l':
	type = EF_SECTOR;
	break;
    case 'p':
	type = EF_PLANE;
	break;
    case 's':
	type = EF_SHIP;
	break;
    case 'u':
	type = EF_LAND;
	break;
    case 'n':
	type = EF_NUKE;
	break;
    case 'c':
	type = EF_NATION;
	break;
    default:
	pr("huh?\n");
	return RET_SYN;
    }

    if (!snxtitem(&ni, type, player->argp[2], NULL))
	return RET_SYN;
    while (nxtitem(&ni, &item)) {
	if (!player->argp[3]) {
	    switch (type) {
	    case EF_SECTOR:
		print_sect(&item.sect);
		break;
	    case EF_SHIP:
		print_ship(&item.ship);
		break;
	    case EF_PLANE:
		print_plane(&item.plane);
		break;
	    case EF_LAND:
		print_land(&item.land);
		break;
	    case EF_NUKE:
		print_nuke(&item.nuke);
		break;
	    case EF_NATION:
		print_nat(&item.nat);
		break;
	    default:
		CANT_REACH();
	    }
	}

	arg_index = 3;
	for (;;) {
	    if (player->argp[arg_index]) {
		if (player->argp[arg_index+1]) {
		    key = player->argp[arg_index++];
		    ptr = player->argp[arg_index++];
		} else
		    return RET_SYN;
	    } else if (arg_index == 3) {
		key = getin(buf, &ptr);
		if (!key)
		    return RET_SYN;
		if (!*key)
		    break;
	    } else
		break;

	    if (!check_obj_ok(&item.gen))
		return RET_FAIL;
	    switch (type) {
	    case EF_NATION:
		/*
		 * edit_nat() may update the edited country by sending
		 * it bulletins.  Writing back item.nat would trigger
		 * a seqno mismatch oops.  Workaround: edit in-place.
		 */
		np = getnatp(item.nat.nat_cnum);
		ret = edit_nat(np, key, ptr);
		if (ret != RET_OK)
		    return ret;
		if (!putnat(np))
		    return RET_FAIL;
		item.nat = *np;
		continue;
	    case EF_SECTOR:
		ret = edit_sect(&item.sect, key, ptr);
		break;
	    case EF_SHIP:
		ret = edit_ship(&item.ship, key, ptr);
		break;
	    case EF_LAND:
		ret = edit_land(&item.land, key, ptr);
		break;
	    case EF_PLANE:
		ret = edit_plane(&item.plane, key, ptr);
		break;
	    case EF_NUKE:
		ret = edit_nuke(&item.nuke, key, ptr);
		break;
	    default:
		CANT_REACH();
	    }
	    if (ret != RET_OK)
		return ret;
	    if (!put_empobj(type, item.gen.uid, &item.gen))
		return RET_FAIL;
	}
    }

    return RET_OK;
}
예제 #15
0
파일: zdon.c 프로젝트: gefla/empserver
int
zdon(void)
{
    int whichcnum;
    struct natstr *natp;
    char *p;

    int checking;
    int wantupd;
    int totpop;
    int totwant;
    int dowant;
    char buf[1024];

    if (update_demand != UPD_DEMAND_SCHED
	&& update_demand != UPD_DEMAND_ASYNC) {
	pr("Demand updates are not enabled.\n");
	return RET_FAIL;
    }
    p = getstarg(player->argp[1], "Want update? [Yes|No|Check] ", buf);
    if (!p)
	return RET_SYN;
    if (*p == 'y' || *p == 'Y') {
	checking = 0;
	wantupd = 1;
    } else if (*p == 'n' || *p == 'N') {
	checking = 0;
	wantupd = 0;
    } else {
	checking = 1;
	wantupd = 0;
    }

    if (player->god) {
	whichcnum = natarg(player->argp[2], "for which country? ");
	if (whichcnum < 0)
	    return RET_SYN;
    } else
	whichcnum = player->cnum;

    if (!(natp = getnatp(whichcnum))) {
	pr("Unable to find country. %d\n", whichcnum);
	pr("Notify the Deity.\n");
	return RET_FAIL;
    }
    if (!checking) {
	if (wantupd) {
	    if (influx(natp)) {
		pr("Unable to request an update as the country is in flux\n");
		return RET_FAIL;
	    }
	    pr("You (%d) now want an update.\n", whichcnum);
	} else {
	    pr("You (%d) now DON'T want an update.\n", whichcnum);
	}
	natp->nat_update = wantupd;
	putnat(natp);
    }

    dowant = demand_update_want(&totwant, &totpop, whichcnum);
    if (checking) {
	if (dowant) {
	    pr("You want an update.\n");
	} else
	    pr("You DON'T want an update, yet.\n");
    }

    pr("%d of a total of %d lunatics want an update.\n", totwant, totpop);

    if (!checking && wantupd && demandupdatecheck()) {
	pr("Here goes...\n");
	update_trigger();
    }
    return RET_OK;
}