#include "hack.h"

static NEARDATA const char steeds[] = { S_QUADRUPED, S_UNICORN, S_ANGEL,

S_CENTAUR, S_DRAGON, S_JABBERWOCK,

'\0' };

STATIC_DCL boolean FDECL(landing_spot, (coord *, int, int));

STATIC_DCL void FDECL(maybewakesteed, (struct monst *));

rider_cant_reach()

{

You("aren't skilled enough to reach from %s.", y_monnam(u.usteed));

}

can_saddle(mtmp)

struct monst *mtmp;

{

struct permonst *ptr = mtmp->data;

return (index(steeds, ptr->mlet) && (ptr->msize >= MZ_MEDIUM)

&& (!humanoid(ptr) || ptr->mlet == S_CENTAUR) && !amorphous(ptr)

&& !noncorporeal(ptr) && !is_whirly(ptr) && !unsolid(ptr));

}

use_saddle(otmp)

struct obj *otmp;

{

struct monst *mtmp;

struct permonst *ptr;

int chance;

const char *s;

if (!u_handsy())

return 0;

/* Select an animal */

if (u.uswallow || Underwater || !getdir((char *) 0)) {

pline1(Never_mind);

return 0;

}

if (!u.dx && !u.dy) {

pline("Saddle yourself? Very funny...");

return 0;

}

if (!isok(u.ux + u.dx, u.uy + u.dy)

|| !(mtmp = m_at(u.ux + u.dx, u.uy + u.dy)) || !canspotmon(mtmp)) {

pline("I see nobody there.");

return 1;

}

/* Is this a valid monster? */

if (mtmp->misc_worn_check & W_SADDLE || which_armor(mtmp, W_SADDLE)) {

pline("%s doesn't need another one.", Monnam(mtmp));

return 1;

}

ptr = mtmp->data;

if (touch_petrifies(ptr) && !uarmg && !Stone_resistance) {

char kbuf[BUFSZ];

You("touch %s.", mon_nam(mtmp));

if (!(poly_when_stoned(youmonst.data) && polymon(PM_STONE_GOLEM))) {

Sprintf(kbuf, "attempting to saddle %s", an(mtmp->data->mname));

instapetrify(kbuf);

}

}

if (ptr == &mons[PM_INCUBUS] || ptr == &mons[PM_SUCCUBUS]) {

pline("Shame on you!");

exercise(A_WIS, FALSE);

return 1;

}

if (mtmp->isminion || mtmp->isshk || mtmp->ispriest || mtmp->isgd

|| mtmp->iswiz) {

pline("I think %s would mind.", mon_nam(mtmp));

return 1;

}

if (!can_saddle(mtmp)) {

You_cant("saddle such a creature.");

return 1;

}

/* Calculate your chance */

chance = ACURR(A_DEX) + ACURR(A_CHA) / 2 + 2 * mtmp->mtame;

chance += u.ulevel * (mtmp->mtame ? 20 : 5);

if (!mtmp->mtame)

chance -= 10 * mtmp->m_lev;

if (Role_if(PM_KNIGHT))

chance += 20;

switch (P_SKILL(P_RIDING)) {

case P_ISRESTRICTED:

case P_UNSKILLED:

default:

chance -= 20;

break;

case P_BASIC:

break;

case P_SKILLED:

chance += 15;

break;

case P_EXPERT:

chance += 30;

break;

}

if (Confusion || Fumbling || Glib)

chance -= 20;

else if (uarmg && (s = OBJ_DESCR(objects[uarmg->otyp])) != (char *) 0

&& !strncmp(s, "riding ", 7))

/* Bonus for wearing "riding" (but not fumbling) gloves */

chance += 10;

else if (uarmf && (s = OBJ_DESCR(objects[uarmf->otyp])) != (char *) 0

&& !strncmp(s, "riding ", 7))

/* ... or for "riding boots" */

chance += 10;

if (otmp->cursed)

chance -= 50;

/* [intended] steed becomes alert if possible */

maybewakesteed(mtmp);

/* Make the attempt */

if (rn2(100) < chance) {

You("put the saddle on %s.", mon_nam(mtmp));

if (otmp->owornmask)

remove_worn_item(otmp, FALSE);

freeinv(otmp);

put_saddle_on_mon(otmp, mtmp);

} else

pline("%s resists!", Monnam(mtmp));

return 1;

}

put_saddle_on_mon(saddle, mtmp)

struct obj *saddle;

struct monst *mtmp;

{

if (!can_saddle(mtmp) || which_armor(mtmp, W_SADDLE))

return;

if (mpickobj(mtmp, saddle))

panic("merged saddle?");

mtmp->misc_worn_check |= W_SADDLE;

saddle->owornmask = W_SADDLE;

saddle->leashmon = mtmp->m_id;

update_mon_intrinsics(mtmp, saddle, TRUE, FALSE);

}

can_ride(mtmp)

struct monst *mtmp;

{

return (mtmp->mtame && humanoid(youmonst.data)

&& !verysmall(youmonst.data) && !bigmonst(youmonst.data)

&& (!Underwater || is_swimmer(mtmp->data)));

}

doride()

{

boolean forcemount = FALSE;

if (u.usteed) {

dismount_steed(DISMOUNT_BYCHOICE);

} else if (getdir((char *) 0) && isok(u.ux + u.dx, u.uy + u.dy)) {

if (wizard && yn("Force the mount to succeed?") == 'y')

forcemount = TRUE;

return (mount_steed(m_at(u.ux + u.dx, u.uy + u.dy), forcemount));

} else {

return 0;

}

return 1;

}

mount_steed(mtmp, force)

struct monst *mtmp; /* The animal */

boolean force; /* Quietly force this animal */

{

struct obj *otmp;

char buf[BUFSZ];

struct permonst *ptr;

/* Sanity checks */

if (u.usteed) {

You("are already riding %s.", mon_nam(u.usteed));

return (FALSE);

}

/* Is the player in the right form? */

if (Hallucination && !force) {

pline("Maybe you should find a designated driver.");

return (FALSE);

}

/* While riding Wounded_legs refers to the steed's,

if (Wounded_legs) {

Your("%s are in no shape for riding.", makeplural(body_part(LEG)));

if (force && wizard && yn("Heal your legs?") == 'y')

HWounded_legs = EWounded_legs = 0L;

else

return (FALSE);

}

if (Upolyd && (!humanoid(youmonst.data) || verysmall(youmonst.data)

|| bigmonst(youmonst.data) || slithy(youmonst.data))) {

You("won't fit on a saddle.");

return (FALSE);

}

if (!force && (near_capacity() > SLT_ENCUMBER)) {

You_cant("do that while carrying so much stuff.");

return (FALSE);

}

/* Can the player reach and see the monster? */

if (!mtmp || (!force && ((Blind && !Blind_telepat) || mtmp->mundetected

|| M_AP_TYPE(mtmp) == M_AP_FURNITURE

|| M_AP_TYPE(mtmp) == M_AP_OBJECT))) {

pline("I see nobody there.");

return (FALSE);

}

if (mtmp->data == &mons[PM_LONG_WORM]

&& (u.ux + u.dx != mtmp->mx || u.uy + u.dy != mtmp->my)) {

/* As of 3.6.2: test_move(below) is used to check for trying to mount

You("couldn't ride %s, let alone its tail.", a_monnam(mtmp));

return FALSE;

}

if (u.uswallow || u.ustuck || u.utrap || Punished

|| !test_move(u.ux, u.uy, mtmp->mx - u.ux, mtmp->my - u.uy,

TEST_MOVE)) {

if (Punished || !(u.uswallow || u.ustuck || u.utrap))

You("are unable to swing your %s over.", body_part(LEG));

else

You("are stuck here for now.");

return (FALSE);

}

/* Is this a valid monster? */

otmp = which_armor(mtmp, W_SADDLE);

if (!otmp) {

pline("%s is not saddled.", Monnam(mtmp));

return (FALSE);

}

ptr = mtmp->data;

if (touch_petrifies(ptr) && !Stone_resistance) {

char kbuf[BUFSZ];

You("touch %s.", mon_nam(mtmp));

Sprintf(kbuf, "attempting to ride %s", an(mtmp->data->mname));

instapetrify(kbuf);

}

if (!mtmp->mtame || mtmp->isminion) {

pline("I think %s would mind.", mon_nam(mtmp));

return (FALSE);

}

if (mtmp->mtrapped) {

struct trap *t = t_at(mtmp->mx, mtmp->my);

You_cant("mount %s while %s's trapped in %s.", mon_nam(mtmp),

mhe(mtmp), an(defsyms[trap_to_defsym(t->ttyp)].explanation));

return (FALSE);

}

if (!force && !Role_if(PM_KNIGHT) && !(--mtmp->mtame)) {

/* no longer tame */

newsym(mtmp->mx, mtmp->my);

pline("%s resists%s!", Monnam(mtmp),

mtmp->mleashed ? " and its leash comes off" : "");

if (mtmp->mleashed)

m_unleash(mtmp, FALSE);

return (FALSE);

}

if (!force && Underwater && !is_swimmer(ptr)) {

You_cant("ride that creature while under %s.",

hliquid("water"));

return (FALSE);

}

if (!can_saddle(mtmp) || !can_ride(mtmp)) {

You_cant("ride such a creature.");

return FALSE;

}

/* Is the player impaired? */

if (!force && !is_floater(ptr) && !is_flyer(ptr) && Levitation

&& !Lev_at_will) {

You("cannot reach %s.", mon_nam(mtmp));

return (FALSE);

}

if (!force && uarm && is_metallic(uarm) && greatest_erosion(uarm)) {

Your("%s armor is too stiff to be able to mount %s.",

uarm->oeroded ? "rusty" : "corroded", mon_nam(mtmp));

return (FALSE);

}

if (!force

&& (Confusion || Fumbling || Glib || Wounded_legs || otmp->cursed

|| (u.ulevel + mtmp->mtame < rnd(MAXULEV / 2 + 5)))) {

if (Levitation) {

pline("%s slips away from you.", Monnam(mtmp));

return FALSE;

}

You("slip while trying to get on %s.", mon_nam(mtmp));

Sprintf(buf, "slipped while mounting %s",

/* "a saddled mumak" or "a saddled pony called Dobbin" */

x_monnam(mtmp, ARTICLE_A, (char *) 0,

SUPPRESS_IT | SUPPRESS_INVISIBLE

| SUPPRESS_HALLUCINATION,

TRUE));

losehp(Maybe_Half_Phys(rn1(5, 10)), buf, NO_KILLER_PREFIX);

return (FALSE);

}

/* Success */

maybewakesteed(mtmp);

if (!force) {

if (Levitation && !is_floater(ptr) && !is_flyer(ptr))

/* Must have Lev_at_will at this point */

pline("%s magically floats up!", Monnam(mtmp));

You("mount %s.", mon_nam(mtmp));

if (Flying)

You("and %s take flight together.", mon_nam(mtmp));

}

/* setuwep handles polearms differently when you're mounted */

if (uwep && is_pole(uwep))

unweapon = FALSE;

u.usteed = mtmp;

remove_monster(mtmp->mx, mtmp->my);

teleds(mtmp->mx, mtmp->my, TRUE);

context.botl = TRUE;

return TRUE;

}

exercise_steed()

{

if (!u.usteed)

return;

/* It takes many turns of riding to exercise skill */

if (++u.urideturns >= 100) {

u.urideturns = 0;

use_skill(P_RIDING, 1);

}

return;

}

kick_steed()

{

char He[4];

if (!u.usteed)

return;

/* [ALI] Various effects of kicking sleeping/paralyzed steeds */

if (u.usteed->msleeping || !u.usteed->mcanmove) {

/* We assume a message has just been output of the form

Strcpy(He, mhe(u.usteed));

*He = highc(*He);

if ((u.usteed->mcanmove || u.usteed->mfrozen) && !rn2(2)) {

if (u.usteed->mcanmove)

u.usteed->msleeping = 0;

else if (u.usteed->mfrozen > 2)

u.usteed->mfrozen -= 2;

else {

u.usteed->mfrozen = 0;

u.usteed->mcanmove = 1;

}

if (u.usteed->msleeping || !u.usteed->mcanmove)

pline("%s stirs.", He);

else

pline("%s rouses %sself!", He, mhim(u.usteed));

} else

pline("%s does not respond.", He);

return;

}

/* Make the steed less tame and check if it resists */

if (u.usteed->mtame)

u.usteed->mtame--;

if (!u.usteed->mtame && u.usteed->mleashed)

m_unleash(u.usteed, TRUE);

if (!u.usteed->mtame

|| (u.ulevel + u.usteed->mtame < rnd(MAXULEV / 2 + 5))) {

newsym(u.usteed->mx, u.usteed->my);

dismount_steed(DISMOUNT_THROWN);

return;

}

pline("%s gallops!", Monnam(u.usteed));

u.ugallop += rn1(20, 30);

return;

}

STATIC_OVL boolean

landing_spot(spot, reason, forceit)

coord *spot; /* landing position (we fill it in) */

int reason;

int forceit;

{

int i = 0, x, y, distance, min_distance = -1;

boolean found = FALSE;

struct trap *t;

/* avoid known traps (i == 0) and boulders, but allow them as a backup */

if (reason != DISMOUNT_BYCHOICE || Stunned || Confusion || Fumbling)

i = 1;

for (; !found && i < 2; ++i) {

for (x = u.ux - 1; x <= u.ux + 1; x++)

for (y = u.uy - 1; y <= u.uy + 1; y++) {

if (!isok(x, y) || (x == u.ux && y == u.uy))

continue;

if (accessible(x, y) && !MON_AT(x, y)) {

distance = distu(x, y);

if (min_distance < 0 || distance < min_distance

|| (distance == min_distance && rn2(2))) {

if (i > 0 || (((t = t_at(x, y)) == 0 || !t->tseen)

&& (!sobj_at(BOULDER, x, y)

|| throws_rocks(youmonst.data)))) {

spot->x = x;

spot->y = y;

min_distance = distance;

found = TRUE;

}

}

}

}

}

/* If we didn't find a good spot and forceit is on, try enexto(). */

if (forceit && min_distance < 0

&& !enexto(spot, u.ux, u.uy, youmonst.data))

return FALSE;

return found;

}

dismount_steed(reason)

int reason; /* Player was thrown off etc. */

{

struct monst *mtmp;

struct obj *otmp;

coord cc, steedcc;

const char *verb = "fall";

boolean repair_leg_damage = (Wounded_legs != 0L);

unsigned save_utrap = u.utrap;

boolean have_spot = landing_spot(&cc, reason, 0);

mtmp = u.usteed; /* make a copy of steed pointer */

/* Sanity check */

if (!mtmp) /* Just return silently */

return;

/* Check the reason for dismounting */

otmp = which_armor(mtmp, W_SADDLE);

switch (reason) {

case DISMOUNT_THROWN:

verb = "are thrown";

/*FALLTHRU*/

case DISMOUNT_FELL:

You("%s off of %s!", verb, mon_nam(mtmp));

if (!have_spot)

have_spot = landing_spot(&cc, reason, 1);

losehp(Maybe_Half_Phys(rn1(10, 10)), "riding accident", KILLED_BY_AN);

set_wounded_legs(BOTH_SIDES, (int) HWounded_legs + rn1(5, 5));

repair_leg_damage = FALSE;

break;

case DISMOUNT_POLY:

You("can no longer ride %s.", mon_nam(u.usteed));

if (!have_spot)

have_spot = landing_spot(&cc, reason, 1);

break;

case DISMOUNT_ENGULFED:

/* caller displays message */

break;

case DISMOUNT_BONES:

/* hero has just died... */

break;

case DISMOUNT_GENERIC:

/* no messages, just make it so */

break;

case DISMOUNT_BYCHOICE:

default:

if (otmp && otmp->cursed) {

You("can't. The saddle %s cursed.",

otmp->bknown ? "is" : "seems to be");

otmp->bknown = 1; /* ok to skip set_bknown() here */

return;

}

if (!have_spot) {

You("can't. There isn't anywhere for you to stand.");

return;

}

if (!has_mname(mtmp)) {

pline("You've been through the dungeon on %s with no name.",

an(mtmp->data->mname));

if (Hallucination)

pline("It felt good to get out of the rain.");

} else

You("dismount %s.", mon_nam(mtmp));

}

/* While riding, Wounded_legs refers to the steed's legs;

if (repair_leg_damage)

heal_legs(1);

/* Release the steed and saddle */

u.usteed = 0;

u.ugallop = 0L;

/*

steedcc.x = u.ux, steedcc.y = u.uy;

if (m_at(u.ux, u.uy)) {

/* hero's spot has a monster in it; hero must have been plucked

if (!enexto(&steedcc, u.ux, u.uy, mtmp->data)

/* no spot? must have been engulfed by a lurker-above over

&& !enexto(&steedcc, u.ux, u.uy, &mons[PM_BAT]))

/* still no spot; last resort is any spot within bounds */

(void) enexto(&steedcc, u.ux, u.uy, &mons[PM_GHOST]);

}

if (!m_at(steedcc.x, steedcc.y)) {

if (mtmp->mhp < 1)

mtmp->mhp = 0; /* make sure it isn't negative */

mtmp->mhp++; /* force at least one hit point, possibly resurrecting */

place_monster(mtmp, steedcc.x, steedcc.y);

mtmp->mhp--; /* take the extra hit point away: cancel resurrection */

} else {

impossible("Dismounting: can't place former steed on map.");

}

if (!DEADMONSTER(mtmp)) {

/* if for bones, there's no reason to place the hero;

if (reason == DISMOUNT_BONES) {

/* move the steed to an adjacent square */

if (enexto(&cc, u.ux, u.uy, mtmp->data))

rloc_to(mtmp, cc.x, cc.y);

else /* evidently no room nearby; move steed elsewhere */

(void) rloc(mtmp, FALSE);

return;

}

/* Set hero's and/or steed's positions. Try moving the hero first. */

if (!u.uswallow && !u.ustuck && have_spot) {

struct permonst *mdat = mtmp->data;

/* The steed may drop into water/lava */

if (!is_flyer(mdat) && !is_floater(mdat) && !is_clinger(mdat)) {

if (is_pool(u.ux, u.uy)) {

if (!Underwater)

pline("%s falls into the %s!", Monnam(mtmp),

surface(u.ux, u.uy));

if (!is_swimmer(mdat) && !amphibious(mdat)) {

killed(mtmp);

adjalign(-1);

}

} else if (is_lava(u.ux, u.uy)) {

pline("%s is pulled into the %s!", Monnam(mtmp),

hliquid("lava"));

if (!likes_lava(mdat)) {

killed(mtmp);

adjalign(-1);

}

}

}

/* Steed dismounting consists of two steps: being moved to another

/* [ALI] No need to move the player if the steed died. */

if (!DEADMONSTER(mtmp)) {

/* Keep steed here, move the player to cc;

in_steed_dismounting = TRUE;

teleds(cc.x, cc.y, TRUE);

in_steed_dismounting = FALSE;

/* Put your steed in your trap */

if (save_utrap)

(void) mintrap(mtmp);

}

/* Couldn't move hero... try moving the steed. */

} else if (enexto(&cc, u.ux, u.uy, mtmp->data)) {

/* Keep player here, move the steed to cc */

rloc_to(mtmp, cc.x, cc.y);

/* Player stays put */

/* Otherwise, kill the steed. */

} else {

if (reason == DISMOUNT_BYCHOICE) {

/* [un]#ride: hero gets credit/blame for killing steed */

killed(mtmp);

adjalign(-1);

} else {

/* other dismount: kill former steed with no penalty;

monkilled(mtmp, "", -AD_PHYS);

}

}

} /* !DEADMONST(mtmp) */

/* usually return the hero to the surface */

if (reason != DISMOUNT_ENGULFED && reason != DISMOUNT_BONES) {

in_steed_dismounting = TRUE;

(void) float_down(0L, W_SADDLE);

in_steed_dismounting = FALSE;

context.botl = TRUE;

(void) encumber_msg();

vision_full_recalc = 1;

} else

context.botl = TRUE;

/* polearms behave differently when not mounted */

if (uwep && is_pole(uwep))

unweapon = TRUE;

return;

}

STATIC_OVL void

maybewakesteed(steed)

struct monst *steed;

{

int frozen = (int) steed->mfrozen;

boolean wasimmobile = steed->msleeping || !steed->mcanmove;

steed->msleeping = 0;

if (frozen) {

frozen = (frozen + 1) / 2; /* half */

/* might break out of timed sleep or paralysis */

if (!rn2(frozen)) {

steed->mfrozen = 0;

steed->mcanmove = 1;

} else {

/* didn't awake, but remaining duration is halved */

steed->mfrozen = frozen;

}

}

if (wasimmobile && !steed->msleeping && steed->mcanmove)

pline("%s wakes up.", Monnam(steed));

/* regardless of waking, terminate any meal in progress */

finish_meating(steed);

}

stucksteed(checkfeeding)

boolean checkfeeding;

{

struct monst *steed = u.usteed;

if (steed) {

/* check whether steed can move */

if (steed->msleeping || !steed->mcanmove) {

pline("%s won't move!", upstart(y_monnam(steed)));

return TRUE;

}

/* optionally check whether steed is in the midst of a meal */

if (checkfeeding && steed->meating) {

pline("%s is still eating.", upstart(y_monnam(steed)));

return TRUE;

}

}

return FALSE;

}

place_monster(mon, x, y)

struct monst *mon;

int x, y;

{

struct monst *othermon;

const char *monnm, *othnm;

char buf[QBUFSZ];

buf[0] = '\0';

/* normal map bounds are <1..COLNO-1,0..ROWNO-1> but sometimes

if (!isok(x, y) && (x != 0 || y != 0 || !mon->isgd)) {

describe_level(buf);

impossible("trying to place %s at <%d,%d> mstate:%lx on %s",

minimal_monnam(mon, TRUE), x, y, mon->mstate, buf);

x = y = 0;

}

if (mon == u.usteed

/* special case is for convoluted vault guard handling */

|| (DEADMONSTER(mon) && !(mon->isgd && x == 0 && y == 0))) {

describe_level(buf);

impossible("placing %s onto map, mstate:%lx, on %s?",

(mon == u.usteed) ? "steed" : "defunct monster",

mon->mstate, buf);

return;

}

if ((othermon = level.monsters[x][y]) != 0) {

describe_level(buf);

monnm = minimal_monnam(mon, FALSE);

othnm = (mon != othermon) ? minimal_monnam(othermon, TRUE) : "itself";

impossible("placing %s over %s at <%d,%d>, mstates:%lx %lx on %s?",

monnm, othnm, x, y, othermon->mstate, mon->mstate, buf);

}

mon->mx = x, mon->my = y;

level.monsters[x][y] = mon;

mon->mstate &= ~(MON_OFFMAP | MON_MIGRATING | MON_LIMBO | MON_BUBBLEMOVE

| MON_ENDGAME_FREE | MON_ENDGAME_MIGR);

}