/*
* Give @unit and its cargo to @recipient.
* No action if @recipient already owns @unit.
* If @giver is non-zero, inform @recipient and @giver of the transaction.
* Clears mission and group on the units given away.
*/
void
unit_give_away(struct empobj *unit, natid recipient, natid giver)
{
int type;
struct nstr_item ni;
union empobj_storage cargo;
if (unit->own == recipient)
return;
if (giver) {
mpr(unit->own, "%s given to %s\n",
unit_nameof(unit), cname(recipient));
mpr(recipient, "%s given to you by %s\n",
unit_nameof(unit), cname(giver));
}
unit->own = recipient;
unit_wipe_orders(unit);
put_empobj(unit->ef_type, unit->uid, unit);
for (type = EF_PLANE; type <= EF_NUKE; type++) {
snxtitem_cargo(&ni, type, unit->ef_type, unit->uid);
while (nxtitem(&ni, &cargo))
unit_give_away(&cargo.gen, recipient, giver);
}
}
/*
* Drop cargo of @unit.
* Give it to @newown, unless it's zero.
*/
void
unit_drop_cargo(struct empobj *unit, natid newown)
{
int type;
struct nstr_item ni;
union empobj_storage cargo;
for (type = EF_PLANE; type <= EF_NUKE; type++) {
snxtitem_cargo(&ni, type, unit->ef_type, unit->uid);
while (nxtitem(&ni, &cargo)) {
switch (type) {
case EF_PLANE:
cargo.plane.pln_ship = cargo.plane.pln_land = -1;
break;
case EF_LAND:
cargo.land.lnd_ship = cargo.land.lnd_land = -1;
break;
case EF_NUKE:
cargo.nuke.nuk_plane = -1;
break;
}
mpr(cargo.gen.own, "%s transferred off %s %d to %s\n",
unit_nameof(&cargo.gen),
ef_nameof(unit->ef_type), unit->uid,
xyas(cargo.gen.x, cargo.gen.y, cargo.gen.own));
if (newown)
unit_give_away(&cargo.gen, newown, cargo.gen.own);
put_empobj(type, cargo.gen.uid, &cargo.gen);
}
}
}
static void
takeover_unit(struct empobj *unit, natid newown)
{
struct shpstr *sp;
struct plnstr *pp;
struct lndstr *lp;
struct nukstr *np;
int type;
struct nstr_item ni;
union empobj_storage cargo;
unit->own = newown;
if (opt_MARKET)
trdswitchown(unit->ef_type, unit, newown);
unit_wipe_orders(unit);
switch (unit->ef_type) {
case EF_SHIP:
sp = (struct shpstr *)unit;
sp->shp_off = 1;
break;
case EF_PLANE:
pp = (struct plnstr *)unit;
if (pp->pln_mobil > 0)
pp->pln_mobil = 0;
pp->pln_off = 1;
break;
case EF_LAND:
lp = (struct lndstr *)unit;
if (lp->lnd_mobil > 0)
lp->lnd_mobil = 0;
lp->lnd_off = 1;
lp->lnd_harden = 0;
break;
case EF_NUKE:
np = (struct nukstr *)unit;
np->nuk_off = 1;
break;
default:
CANT_REACH();
}
put_empobj(unit->ef_type, unit->uid, unit);
for (type = EF_PLANE; type <= EF_NUKE; type++) {
snxtitem_cargo(&ni, type, unit->ef_type, unit->uid);
while (nxtitem(&ni, &cargo)) {
if (cargo.gen.own == newown)
continue;
if (type == EF_PLANE)
cargo.plane.pln_effic = PLANE_MINEFF;
takeover_unit(&cargo.gen, newown);
}
}
}
/*
* Update cargo of @carrier for movement or destruction.
* If the carrier is destroyed, destroy its cargo (planes, land units,
* nukes).
* Else update their location to the carrier's. Any op sectors equal
* to location get updated, too.
* Return number of units updated.
*/
int
unit_update_cargo(struct empobj *carrier)
{
int cargo_type;
struct nstr_item ni;
union empobj_storage obj;
int n = 0;
for (cargo_type = EF_PLANE; cargo_type <= EF_NUKE; cargo_type++) {
snxtitem_cargo(&ni, cargo_type, carrier->ef_type, carrier->uid);
while (nxtitem(&ni, &obj)) {
if (carrier->own)
unit_teleport(&obj.gen, carrier->x, carrier->y);
else {
mpr(obj.gen.own, "%s lost!\n", unit_nameof(&obj.gen));
obj.gen.effic = 0;
}
put_empobj(cargo_type, obj.gen.uid, &obj);
n++;
}
}
return n;
}
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;
}
int
scra(void)
{
struct nstr_item ni;
union empobj_storage item;
int type, n;
struct sctstr sect;
struct mchrstr *mp;
struct plchrstr *pp;
struct lchrstr *lp;
char *p;
i_type i;
char prompt[128];
char buf[1024];
float eff;
short *mvec;
int amt;
if (!(p = getstarg(player->argp[1], "Ship, land, or plane? ", buf)))
return RET_SYN;
switch (*p) {
case 's':
type = EF_SHIP;
break;
case 'p':
type = EF_PLANE;
break;
case 'l':
type = EF_LAND;
break;
default:
pr("Ships, land units, or planes only! (s, l, p)\n");
return RET_SYN;
}
if (!snxtitem(&ni, type, player->argp[2], NULL))
return RET_SYN;
n = 0;
while (nxtitem(&ni, &item)) {
if (!player->owner)
continue;
n++;
}
snprintf(prompt, sizeof(prompt), "Really scrap %d %s%s [n]? ",
n, ef_nameof(type), splur(n));
if (!confirm(prompt))
return RET_FAIL;
snxtitem_rewind(&ni);
while (nxtitem(&ni, &item)) {
if (!player->owner)
continue;
if (opt_MARKET) {
if (ontradingblock(type, &item.ship)) {
pr("You cannot scrap an item on the trading block!\n");
continue;
}
}
getsect(item.gen.x, item.gen.y, §);
if (type == EF_SHIP) {
if (!player->owner
&& relations_with(sect.sct_own, player->cnum) < FRIENDLY) {
pr("%s is not in a friendly harbor!\n",
prship(&item.ship));
continue;
}
if (sect.sct_type != SCT_HARBR || sect.sct_effic < 60) {
pr("%s is not in a 60%% efficient harbor!\n",
prship(&item.ship));
continue;
}
if (mchr[item.ship.shp_type].m_flags & M_TRADE) {
pr("WARNING: You only collect money from trade ships if you \"scuttle\" them!\n");
sprintf(prompt,
"Are you really sure that you want to scrap %s (n)? ",
prship(&item.ship));
if (!confirm(prompt)) {
pr("%s not scrapped\n", prship(&item.ship));
continue;
}
}
} else {
if (!player->owner
&& relations_with(sect.sct_own, player->cnum) != ALLIED) {
pr("%s is not in an allied sector!\n",
unit_nameof(&item.gen));
continue;
}
if (type == EF_PLANE
&& (sect.sct_type != SCT_AIRPT || sect.sct_effic < 60)) {
pr("%s is not in a 60%% efficient airfield!\n",
prplane(&item.plane));
continue;
}
}
pr("%s scrapped in %s\n",
unit_nameof(&item.gen),
xyas(item.gen.x, item.gen.y, player->cnum));
unit_drop_cargo(&item.gen, sect.sct_own);
if (type == EF_SHIP) {
eff = item.ship.shp_effic / 100.0;
mp = &mchr[(int)item.ship.shp_type];
for (i = I_NONE + 1; i <= I_MAX; i++) {
if (load_comm_ok(§, item.ship.shp_own, i,
-item.ship.shp_item[i]))
sect.sct_item[i] += item.ship.shp_item[i];
}
mvec = mp->m_mat;
if (item.ship.shp_pstage == PLG_INFECT
&& sect.sct_pstage == PLG_HEALTHY)
sect.sct_pstage = PLG_EXPOSED;
} else if (type == EF_LAND) {
eff = item.land.lnd_effic / 100.0;
lp = &lchr[(int)item.land.lnd_type];
for (i = I_NONE + 1; i <= I_MAX; i++) {
if (load_comm_ok(§, item.land.lnd_own, i,
-item.land.lnd_item[i]))
sect.sct_item[i] += item.land.lnd_item[i];
}
mvec = lp->l_mat;
if (item.land.lnd_pstage == PLG_INFECT
&& sect.sct_pstage == PLG_HEALTHY)
sect.sct_pstage = PLG_EXPOSED;
} else {
eff = item.land.lnd_effic / 100.0;
pp = &plchr[(int)item.plane.pln_type];
mvec = pp->pl_mat;
}
item.gen.effic = 0;
put_empobj(type, item.gen.uid, &item.gen);
for (i = I_NONE + 1; i <= I_MAX; i++) {
if (i == I_CIVIL || i == I_MILIT || i == I_UW)
amt = sect.sct_item[i] + mvec[i] * eff;
else
amt = sect.sct_item[i] + mvec[i] * 2 / 3 * eff;
if (amt > ITEM_MAX)
amt = ITEM_MAX;
sect.sct_item[i] = amt;
}
putsect(§);
}
return RET_OK;
}
/*
* Actually get the commod
*
* First, try to forage in the sector
* Second look for a warehouse or headquarters to leech
* Third, look for a ship we own in a harbor
* Fourth, look for supplies in a supply unit we own
* (one good reason to do this last is that the supply
* unit will then call resupply, taking more time)
*
* May want to put code to resupply with SAMs here, later --ts
*/
static int
s_commod(struct empobj *sink, short *vec,
i_type type, int wanted, int limit, int actually_doit)
{
natid own = sink->own;
coord x = sink->x;
coord y = sink->y;
int lookrange;
struct sctstr sect;
struct nstr_sect ns;
struct nstr_item ni;
struct lchrstr *lcp;
struct shpstr ship;
struct lndstr land;
/* leave at least 1 military in sectors/ships */
int minimum = 0;
int can_move;
double move_cost, weight, mobcost;
int packing;
struct dchrstr *dp;
struct ichrstr *ip;
if (wanted > limit)
wanted = limit;
if (wanted <= vec[type])
return 1;
wanted -= vec[type];
/* try to get it from sector we're in */
if (sink->ef_type != EF_SECTOR) {
getsect(x, y, §);
if (sect.sct_own == own) {
if (!opt_NOFOOD && type == I_FOOD)
minimum = 1 + (int)ceil(food_needed(sect.sct_item,
etu_per_update));
if (sect.sct_item[type] - wanted >= minimum) {
sect.sct_item[type] -= wanted;
if (actually_doit) {
vec[type] += wanted;
putsect(§);
put_empobj(sink->ef_type, sink->uid, sink);
}
return 1;
} else if (sect.sct_item[type] - minimum > 0) {
wanted -= sect.sct_item[type] - minimum;
sect.sct_item[type] = minimum;
if (actually_doit) {
vec[type] += sect.sct_item[type] - minimum;
putsect(§);
}
}
}
}
/* look for a headquarters or warehouse */
lookrange = tfact(own, 10.0);
snxtsct_dist(&ns, x, y, lookrange);
while (nxtsct(&ns, §) && wanted) {
if (ns.curdist == 0)
continue;
if (sect.sct_own != own)
continue;
if ((sect.sct_type != SCT_WAREH) &&
(sect.sct_type != SCT_HEADQ) && (sect.sct_type != SCT_HARBR))
continue;
if ((sect.sct_type == SCT_HEADQ) &&
(sect.sct_dist_x == sect.sct_x) &&
(sect.sct_dist_y == sect.sct_y))
continue;
if (sect.sct_effic < 60)
continue;
move_cost = path_find(sect.sct_x, sect.sct_y, x, y, own, MOB_MOVE);
if (move_cost < 0)
continue;
if (!opt_NOFOOD && type == I_FOOD)
minimum = 1 + (int)ceil(food_needed(sect.sct_item,
etu_per_update));
if (sect.sct_item[type] <= minimum)
continue;
ip = &ichr[type];
dp = &dchr[sect.sct_type];
packing = ip->i_pkg[dp->d_pkg];
if (packing > 1 && sect.sct_effic < 60)
packing = 1;
weight = (double)ip->i_lbs / packing;
mobcost = move_cost * weight;
if (mobcost > 0)
can_move = (double)sect.sct_mobil / mobcost;
else
can_move = sect.sct_item[type] - minimum;
if (can_move > sect.sct_item[type] - minimum)
can_move = sect.sct_item[type] - minimum;
if (can_move >= wanted) {
int n;
sect.sct_item[type] -= wanted;
/* take off mobility for delivering sect */
n = roundavg(wanted * weight * move_cost);
sect.sct_mobil -= LIMIT_TO(n, 0, sect.sct_mobil);
if (actually_doit) {
vec[type] += wanted;
putsect(§);
put_empobj(sink->ef_type, sink->uid, sink);
}
return 1;
} else if (can_move > 0) {
int n;
wanted -= can_move;
sect.sct_item[type] -= can_move;
/* take off mobility for delivering sect */
n = roundavg(can_move * weight * move_cost);
sect.sct_mobil -= LIMIT_TO(n, 0, sect.sct_mobil);
if (actually_doit) {
vec[type] += can_move;
putsect(§);
}
}
}
/* look for an owned ship in a harbor */
snxtitem_dist(&ni, EF_SHIP, x, y, lookrange);
while (nxtitem(&ni, &ship) && wanted) {
if (sink->ef_type == EF_SHIP && sink->uid == ship.shp_uid)
continue;
if (ship.shp_own != own)
continue;
if (!(mchr[(int)ship.shp_type].m_flags & M_SUPPLY))
continue;
getsect(ship.shp_x, ship.shp_y, §);
if (sect.sct_type != SCT_HARBR)
continue;
if (sect.sct_effic < 2)
continue;
move_cost = path_find(sect.sct_x, sect.sct_y, x, y, own, MOB_MOVE);
if (move_cost < 0)
continue;
if (!opt_NOFOOD && type == I_FOOD)
minimum = 1 + (int)ceil(food_needed(ship.shp_item,
etu_per_update));
if (ship.shp_item[type] <= minimum)
continue;
ip = &ichr[type];
dp = &dchr[sect.sct_type];
packing = ip->i_pkg[dp->d_pkg];
if (packing > 1 && sect.sct_effic < 60)
packing = 1;
weight = (double)ip->i_lbs / packing;
mobcost = move_cost * weight;
if (mobcost > 0)
can_move = (double)sect.sct_mobil / mobcost;
else
can_move = ship.shp_item[type] - minimum;
if (can_move > ship.shp_item[type] - minimum)
can_move = ship.shp_item[type] - minimum;
if (can_move >= wanted) {
int n;
ship.shp_item[type] -= wanted;
n = roundavg(wanted * weight * move_cost);
sect.sct_mobil -= LIMIT_TO(n, 0, sect.sct_mobil);
if (actually_doit) {
vec[type] += can_move;
putship(ship.shp_uid, &ship);
if (n)
putsect(§);
put_empobj(sink->ef_type, sink->uid, sink);
}
return 1;
} else if (can_move > 0) {
int n;
wanted -= can_move;
ship.shp_item[type] -= can_move;
n = roundavg(can_move * weight * move_cost);
sect.sct_mobil -= LIMIT_TO(n, 0, sect.sct_mobil);
if (actually_doit) {
vec[type] += can_move;
putship(ship.shp_uid, &ship);
if (n)
putsect(§);
}
}
}
/* look for an owned supply unit */
snxtitem_dist(&ni, EF_LAND, x, y, lookrange);
while (nxtitem(&ni, &land) && wanted) {
int min;
if (sink->ef_type == EF_LAND && sink->uid == land.lnd_uid)
continue;
if (land.lnd_own != own)
continue;
lcp = &lchr[(int)land.lnd_type];
if (!(lcp->l_flags & L_SUPPLY))
continue;
if (land.lnd_item[type] <= get_minimum(&land, type))
continue;
if (land.lnd_ship >= 0) {
getsect(land.lnd_x, land.lnd_y, §);
if (sect.sct_type != SCT_HARBR || sect.sct_effic < 2)
continue;
}
move_cost = path_find(land.lnd_x, land.lnd_y, x, y, own, MOB_MOVE);
if (move_cost < 0)
continue;
#if 0
/*
* Recursive supply is disabled for now. It can introduce
* cycles into the "resupplies from" relation. The code below
* attempts to break these cycles by temporarily zapping the
* commodity being supplied. That puts the land file in a
* funny state temporarily, risking loss of supplies when
* something goes wrong on the way. Worse, it increases
* lnd_seqno even when !actually_doit, which can lead to
* spurious seqno mismatch oopses in users of
* lnd_could_be_supplied(). I can't be bothered to clean up
* this mess right now, because recursive resupply is too dumb
* to be really useful anyway: each step uses the first source
* it finds, without consideration of mobility cost. If you
* re-enable it, don't forget to uncomment its documentation
* in supply.t as well.
*/
if (land.lnd_item[type] - wanted < get_minimum(&land, type)) {
struct lndstr save;
/*
* Temporarily zap this unit's store, so the recursion
* avoids it.
*/
save = land;
land.lnd_item[type] = 0;
putland(land.lnd_uid, &land);
save.lnd_seqno = land.lnd_seqno;
s_commod((struct empobj *)&land, land.lnd_item, type, wanted,
lchr[land.lnd_type].l_item[type] - wanted,
actually_doit);
land.lnd_item[type] += save.lnd_item[type];
if (actually_doit)
putland(land.lnd_uid, &land);
else
putland(save.lnd_uid, &save);
}
#endif
min = get_minimum(&land, type);
ip = &ichr[type];
weight = ip->i_lbs;
mobcost = move_cost * weight;
if (mobcost > 0)
can_move = (double)land.lnd_mobil / mobcost;
else
can_move = land.lnd_item[type] - min;
if (can_move > land.lnd_item[type] - min)
can_move = land.lnd_item[type] - min;
if (can_move >= wanted) {
land.lnd_item[type] -= wanted;
land.lnd_mobil -= roundavg(wanted * weight * move_cost);
if (actually_doit) {
vec[type] += wanted;
putland(land.lnd_uid, &land);
put_empobj(sink->ef_type, sink->uid, sink);
}
return 1;
} else if (can_move > 0) {
wanted -= can_move;
land.lnd_item[type] -= can_move;
land.lnd_mobil -= roundavg(can_move * weight * move_cost);
if (actually_doit) {
vec[type] += can_move;
putland(land.lnd_uid, &land);
}
}
}
if (actually_doit)
put_empobj(sink->ef_type, sink->uid, sink);
return 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;
}