/*
* Declne a loan. Return RET_OK on success, anything else on error.
*/
static int
loan_decline(struct ltcomstr *ltcp)
{
struct lonstr *lp;
lp = <cp->u.l;
if (!getloan(ltcp->num, lp)) {
logerror("loan_decline: can't read loan");
pr("can't read loan; get help!\n");
return RET_FAIL;
}
/* loan got accepted somehow between now and last time we checked */
if (lp->l_status == LS_SIGNED) {
late(ltcp);
return RET_OK;
}
lp->l_status = LS_FREE;
if (!putloan(ltcp->num, lp)) {
logerror("loan_decline: can't write loan");
pr("can't write loan; get help!\n");
return RET_FAIL;
}
decline(ltcp);
return RET_OK;
}
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;
}
/*
* 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 = <cp->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;
}
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;
}
int
coll(void)
{
int arg;
time_t now;
char *p;
struct lonstr loan;
struct sctstr sect;
struct natstr *lonee_np;
coord x, y;
double owed;
double pay;
char buf[1024];
if (!opt_LOANS) {
pr("Loans are not enabled.\n");
return RET_FAIL;
}
if ((arg = onearg(player->argp[1], "Collect on loan # ")) < 0)
return RET_SYN;
/* Check if it's a valid loan. That means, is it a valid loan,
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("You aren't owed anything on that loan...\n");
return RET_FAIL;
}
/* If we got here, we check to see if it's been defaulted on. We
already know it's owed to this player. */
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;
}
lonee_np = getnatp(loan.l_lonee);
pr("You are owed $%.2f on that loan.\n", owed);
p = getstarg(player->argp[2],
"What sector do you wish to confiscate? ", buf);
if (!p)
return RET_SYN;
if (!check_loan_ok(&loan))
return RET_FAIL;
if (!sarg_xy(p, &x, &y) || !getsect(x, y, §))
return RET_SYN;
if (!neigh(x, y, player->cnum)) {
pr("You are not adjacent to %s\n", xyas(x, y, player->cnum));
return RET_FAIL;
}
if (sect.sct_own != loan.l_lonee) {
pr("%s is not owned by %s.\n",
xyas(x, y, player->cnum), cname(loan.l_lonee));
return RET_FAIL;
}
pay = appraise_sect(§);
if (pay > owed * 1.2) {
pr("That sector (and its contents) is valued at more than %.2f.\n",
owed);
return RET_FAIL;
}
if (!influx(lonee_np)
&& sect.sct_x == lonee_np->nat_xcap
&& sect.sct_y == lonee_np->nat_ycap) {
pr("%s's capital cannot be confiscated.\n", cname(loan.l_lonee));
return RET_FAIL;
}
pr("That sector (and its contents) is valued at $%.2f\n", pay);
sect.sct_item[I_MILIT] = 1; /* FIXME now where did this guy come from? */
/*
* Used to call takeover() here a long time ago, but that does
* unwanted things, like generate che.
*/
sect.sct_own = player->cnum;
memset(sect.sct_dist, 0, sizeof(sect.sct_dist));
memset(sect.sct_del, 0, sizeof(sect.sct_del));
sect.sct_off = 1;
sect.sct_dist_x = sect.sct_x;
sect.sct_dist_y = sect.sct_y;
putsect(§);
nreport(player->cnum, N_SEIZE_SECT, loan.l_lonee, 1);
owed = loan_owed(&loan, time(&now));
if (pay >= owed) {
loan.l_status = LS_FREE;
loan.l_ldur = 0;
nreport(loan.l_lonee, N_REPAY_LOAN, player->cnum, 1);
wu(0, loan.l_lonee,
"%s seized %s to satisfy loan #%d\n",
cname(player->cnum),
xyas(sect.sct_x, sect.sct_y, loan.l_lonee), arg);
pr("That loan is now considered repaid.\n");
} else {
(void)time(&loan.l_lastpay);
owed -= pay;
loan.l_amtdue = (int)owed;
pay += loan.l_amtpaid;
loan.l_amtpaid = (int)pay;
wu(0, loan.l_lonee,
"%s seized %s in partial payment of loan %d.\n",
cname(player->cnum),
xyas(sect.sct_x, sect.sct_y, loan.l_lonee), arg);
pr("You are still owed $%.2f on loan %d.\n", owed, arg);
}
putloan(arg, &loan);
return RET_OK;
}
