/*	SCCS Id: @(#)trap.c	3.2	96/10/21	*/
/* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
/* NetHack may be freely redistributed.  See license for details. */

/*
**	Japanese version Copyright
**	(c) Issei Numata, Naoki Hamada, Shigehiro Miyashita, 1994-1999
**	changing point is marked `JP' (94/6/7)
**	JNetHack may be freely redistributed.  See license for details. 
*/

#include "hack.h"

STATIC_DCL void FDECL(dofiretrap, (struct obj *));
STATIC_DCL void NDECL(domagictrap);
STATIC_DCL boolean FDECL(emergency_disrobe,(boolean *));
STATIC_DCL int FDECL(untrap_prob, (struct trap *ttmp));
STATIC_DCL void FDECL(cnv_trap_obj, (int, int, struct trap *));
STATIC_DCL void FDECL(move_into_trap, (struct trap *));
STATIC_DCL int FDECL(try_disarm, (struct trap *,BOOLEAN_P));
STATIC_DCL void FDECL(reward_untrap, (struct trap *, struct monst *));
STATIC_DCL int FDECL(disarm_beartrap, (struct trap *));
STATIC_DCL int FDECL(disarm_landmine, (struct trap *));
STATIC_DCL int FDECL(disarm_squeaky_board, (struct trap *));
STATIC_DCL int FDECL(disarm_shooting_trap, (struct trap *, int));
STATIC_DCL int FDECL(try_lift, (struct monst *, struct trap *, int, BOOLEAN_P));
STATIC_DCL int FDECL(help_monster_out, (struct monst *, struct trap *));
STATIC_DCL boolean FDECL(thitm, (int, struct monst *, struct obj *, int));
STATIC_DCL int FDECL(mkroll_launch,
			(struct trap *,XCHAR_P,XCHAR_P,SHORT_P,long));
STATIC_DCL boolean FDECL(isclearpath,(coord *, int, SCHAR_P, SCHAR_P));
STATIC_DCL void FDECL(blow_up_landmine, (struct trap *));

#ifndef OVLB
STATIC_VAR const char *a_your[2];
STATIC_VAR const char *A_Your[2];
STATIC_VAR const char *the_your[2];
STATIC_VAR const char tower_of_flame[];
STATIC_VAR const char *A_gush_of_water_hits;
STATIC_VAR const char *set_you[2];
STATIC_VAR const char *dig_you[2];
STATIC_VAR const char *web_you[2];

#else

#if 0 /*JP*/
STATIC_VAR const char *a_your[2] = { "a", "your" };
STATIC_VAR const char *A_Your[2] = { "A", "Your" };
STATIC_VAR const char *the_your[2] = { "the", "your" };
STATIC_VAR const char tower_of_flame[] = "tower of flame";
STATIC_VAR const char *A_gush_of_water_hits = "A gush of water hits";
#endif /*JP*/
STATIC_VAR const char *set_you[2] = { "", "あなたの仕掛けた" };
STATIC_VAR const char *dig_you[2] = { "", "あなたが掘った" };
STATIC_VAR const char *web_you[2] = { "", "あなたが張った" };

#endif /* OVLB */

#ifdef OVLB

/* called when you're hit by fire (dofiretrap,buzz,zapyourself,explode) */
boolean			/* returns TRUE if hit on torso */
burnarmor()
{
#define burn_dmg(obj,descr) rust_dmg(obj, descr, 0, FALSE)
    while (1) {
	switch (rn2(5)) {
	case 0:
/*JP	    if (!burn_dmg(uarmh, "leather helmet")) continue;*/
	    if (!burn_dmg(uarmh, "革の兜")) continue;
	    break;
	case 1:
	    if (uarmc)
/*JP		(void) burn_dmg(uarmc, "cloak");*/
		(void) burn_dmg(uarmc, "クローク");
	    else if (uarm)
		(void) burn_dmg(uarm, xname(uarm));
#ifdef TOURIST
	    else if (uarmu)
/*JP		(void) burn_dmg(uarmu, "shirt");*/
		(void) burn_dmg(uarmu, "シャツ");
#endif
	    return TRUE;
	case 2:
/*JP	    if (!burn_dmg(uarms, "wooden shield")) continue;*/
	    if (!burn_dmg(uarms, "木の盾")) continue;
	    break;
	case 3:
/*JP	    if (!burn_dmg(uarmg, "gloves")) continue;*/
	    if (!burn_dmg(uarmg, "小手")) continue;
	    break;
	case 4:
/*JP	    if (!burn_dmg(uarmf, "boots")) continue;*/
	    if (!burn_dmg(uarmf, "靴")) continue;
	    break;
	}
	break; /* Out of while loop */
    }
    return FALSE;
#undef burn_dmg
}

/* Generic rust-armor function.  Returns TRUE if a message was printed;
 * "print", if set, means to print a message (and thus to return TRUE) even
 * if the item could not be rusted; otherwise a message is printed and TRUE is
 * returned only for rustable items.
 */
boolean
rust_dmg(otmp, ostr, type, print)
register struct obj *otmp;
register const char *ostr;
int type;
boolean print;
{
#if 0 /*JP*/
	static NEARDATA const char *action[] = { "smoulder", "rust", "rot", "corrode" };
	static NEARDATA const char *msg[] =  { "burnt", "rusted", "rotten", "corroded" };
#endif
	static NEARDATA const char *action[] = { "くすぶった","錆びた","腐った","腐食した" };
	static NEARDATA const char *msg[] =  { "焦げた","錆びた","腐った","腐食した" };
	boolean vulnerable = FALSE;
	boolean plural;
	boolean grprot = FALSE;

	if (!otmp) return(FALSE);
	switch(type) {
		case 0:
		case 2: vulnerable = is_flammable(otmp); break;
		case 1: vulnerable = is_rustprone(otmp); grprot = TRUE; break;
		case 3: vulnerable = is_corrodeable(otmp); grprot = TRUE; break;
	}

	if (!print && (!vulnerable || otmp->oerodeproof || otmp->oeroded == MAX_ERODE))
		return FALSE;

	plural = is_gloves(otmp) || is_boots(otmp);

	if (!vulnerable) {
		if (flags.verbose)
/*JP		    Your("%s %s not affected.", ostr, plural ? "are" : "is");*/
		    Your("%sは影響を受けなかった．",ostr);
	} else if (otmp->oeroded < MAX_ERODE) {
		if (grprot && otmp->greased) {
			grease_protect(otmp,ostr,plural);
		} else if (otmp->oerodeproof || (otmp->blessed && !rnl(4))) {
			if (flags.verbose)
/*JP				pline("Somehow, your %s %s not affected.",
					ostr, plural ? "are" : "is");*/
				pline("何故か，%sは影響を受けなかった．",ostr);
		} else {
/*JP			Your("%s %s%s%s!", ostr, action[type],
				plural ? "" : "s",
				otmp->oeroded+1 == MAX_ERODE ? " completely" :
				otmp->oeroded ? " further" : "");*/
			Your("%sは%s%s！", ostr, 
			        otmp->oeroded+1 == MAX_ERODE ? "完全に" :
				otmp->oeroded ? "さらに" : "",
			        action[type]);
			otmp->oeroded++;
		}
	} else {
		if (flags.verbose)
/*JP			Your("%s %s%s completely %s.", ostr,
			     Blind ? "feel" : "look",
			     plural ? "" : "s", msg[type]);*/
			Your("%sは完全に%s%s.", ostr,msg[type],
			     Blind ? "ようだ" : "" );
	}
	return(TRUE);
}

void
grease_protect(otmp,ostr,plu)
register struct obj *otmp;
register const char *ostr;
register boolean plu;
{
/*JP	static const char txt[] = "protected by the layer of grease!";*/
	static const char txt[] = "油の塗りこみによって守られている！";

	if (ostr)
/*JP		Your("%s %s %s",ostr,plu ? "are" : "is",txt);*/
		Your("%sは%s",ostr,txt);
	else
/*JP		Your("%s %s",aobjnam(otmp,"are"),txt);*/
		Your("%sは%s",xname(otmp),txt);
	if (!rn2(2)) {
/*JP		pline("The grease dissolves.");*/
		pline("油は溶けてしまった．");
		otmp->greased = 0;
	}
}

struct trap *
maketrap(x,y,typ)
register int x, y, typ;
{
	register struct trap *ttmp;
	register struct rm *lev;
	register boolean oldplace;

	if ((ttmp = t_at(x,y)) != 0) {
	    if (ttmp->ttyp == MAGIC_PORTAL) return (struct trap *)0;
	    oldplace = TRUE;
	    if (u.utrap && (x == u.ux) && (y == u.uy) &&
	      ((u.utraptype == TT_BEARTRAP && typ != BEAR_TRAP) ||
	      (u.utraptype == TT_WEB && typ != WEB) ||
	      (u.utraptype == TT_PIT && typ != PIT && typ != SPIKED_PIT)))
		    u.utrap = 0;
	} else {
	    oldplace = FALSE;
	    ttmp = newtrap();
	    ttmp->tx = x;
	    ttmp->ty = y;
	    ttmp->launch.x = -1;	/* force error if used before set */
	    ttmp->launch.y = -1;
	}
	ttmp->ttyp = typ;
	switch(typ) {
	    case STATUE_TRAP:	    /* create a "living" statue */
	      { struct monst *mtmp;
		struct obj *otmp, *statue;

		statue = mkcorpstat(STATUE, (struct monst *)0,
					&mons[rndmonnum()], x, y, FALSE);
		mtmp = makemon(&mons[statue->corpsenm], 0, 0, NO_MM_FLAGS);
		if (!mtmp) break; /* should never happen */
		while(mtmp->minvent) {
		    otmp = mtmp->minvent;
		    otmp->owornmask = 0;
		    obj_extract_self(otmp);
		    add_to_container(statue, otmp);
		}
		mongone(mtmp);
		break;
	      }
	    case ROLLING_BOULDER_TRAP:	/* boulder will roll towards trigger */
		(void) mkroll_launch(ttmp, x, y, BOULDER, 1L);
		break;
	    case HOLE:
	    case PIT:
	    case SPIKED_PIT:
	    case TRAPDOOR:
		lev = &levl[x][y];
		if (*in_rooms(x, y, SHOPBASE) &&
			((typ == HOLE || typ == TRAPDOOR) || IS_DOOR(lev->typ)))
		    add_damage(x, y,		/* schedule repair */
			(IS_DOOR(lev->typ) && !flags.mon_moving) ? 200L : 0L);
		lev->doormask = 0;	/* subsumes altarmask, icedpool... */
		if (IS_ROOM(lev->typ)) /* && !IS_AIR(lev->typ) */
		    lev->typ = ROOM;

		/*
		 * some cases which can happen when digging
		 * down while phazing thru solid areas
		 */
		else if (lev->typ == STONE || lev->typ == SCORR)
		    lev->typ = CORR;
		else if (IS_WALL(lev->typ) || lev->typ == SDOOR)
		    lev->typ = level.flags.is_maze_lev ? ROOM :
			       level.flags.is_cavernous_lev ? CORR : DOOR;

		unearth_objs(x, y);
		break;
	}
	if (ttmp->ttyp == HOLE) ttmp->tseen = 1;  /* You can't hide a hole */
	else ttmp->tseen = 0;
	ttmp->once = 0;
	ttmp->madeby_u = 0;
	ttmp->dst.dnum = -1;
	ttmp->dst.dlevel = -1;
	if (!oldplace) {
	    ttmp->ntrap = ftrap;
	    ftrap = ttmp;
	}
	return(ttmp);
}

void
fall_through(td)
boolean td;	/* td == TRUE : trapdoor or hole */
{
	d_level dtmp;
	char msgbuf[BUFSZ];
	const char *dont_fall = 0;
	register int newlevel = dunlev(&u.uz);

	if(Blind && Levitation) return;

	do {
	    newlevel++;
	} while(!rn2(4) && newlevel < dunlevs_in_dungeon(&u.uz));

	if(td) {
		struct trap *t=t_at(u.ux,u.uy);
		if (t->ttyp == TRAPDOOR)
/*JP			pline("A trap door opens up under you!");*/
			pline("落し扉があなたの足元に開いた！");
		else
/*JP			pline("There's a gaping hole under you!");*/
			pline("あなたの足下にぽっかりと穴が開いている！");
/*JP	} else pline_The("%s opens up under you!", surface(u.ux,u.uy));*/
	} else pline("足元の%sに穴が開いた！", surface(u.ux,u.uy));

	if(Levitation || u.ustuck || !Can_fall_thru(&u.uz)
	   || is_flyer(uasmon) || is_clinger(uasmon)
	   || (Inhell && !u.uevent.invoked &&
					newlevel == dunlevs_in_dungeon(&u.uz))
		) {
/*JP	    dont_fall = "don't fall in.";*/
	    dont_fall = "しかしあなたは落ちなかった．";
	} else if (uasmon->msize >= MZ_HUGE) {
/*JP	    dont_fall = "don't fit through.";*/
	    dont_fall = "通り抜けるにはサイズが合わない．";
	} else if (!next_to_u()) {
/*JP	    dont_fall = "are jerked back by your pet!";*/
	    dont_fall = "あなたはペットによって引っぱられた！";
	}
	if (dont_fall) {
/*JP	    You(dont_fall);*/
	    pline(dont_fall);
	    /* hero didn't fall through, but any objects here might */
	    impact_drop((struct obj *)0, u.ux, u.uy, 0);
	    if (!td) {
		display_nhwindow(WIN_MESSAGE, FALSE);
/*JP		pline_The("opening under you closes up.");*/
		pline_The("足下に開いていたものは閉じた．");
	    }
	    return;
	}

	if(*u.ushops) shopdig(1);
	if (Is_stronghold(&u.uz)) {
	    find_hell(&dtmp);
	} else {
	    dtmp.dnum = u.uz.dnum;
	    dtmp.dlevel = newlevel;
	}
	if (!td)
/*JP	    Sprintf(msgbuf, "The hole in the %s above you closes up.",*/
	    Sprintf(msgbuf, "%sに開いた穴は閉じた．",
		    ceiling(u.ux,u.uy));
	schedule_goto(&dtmp, FALSE, TRUE, 0,
		      (char *)0, !td ? msgbuf : (char *)0);
}

/* you've either stepped onto a statue trap's location
   or you've triggered a statue trap by searching next to it
   or by trying to break it with a wand or pick-axe */
struct monst *
activate_statue_trap(trap, x, y, shatter)
struct trap *trap;
xchar x, y;
boolean shatter;
{
	struct monst *mtmp = 0;
	struct permonst *mptr = 0;
	struct obj *item, *otmp = sobj_at(STATUE, x, y);

	/* Guard against someone wishing for a statue of a unique monster
	   (which is allowed in normal play) and then tossing it onto the
	   [detected or guessed] location of a statue trap.  Normally the
	   uppermost statue is the one which would be activated. */
	while (otmp) {
	    mptr = &mons[otmp->corpsenm];
	    if (!(mptr->geno & G_UNIQ)) break;	/* not unique => use it */
	    while ((otmp = otmp->nexthere) != 0)
		if (otmp->otyp == STATUE) break;
	}
	deltrap(trap);
	if (otmp && (mtmp = makemon(mptr, x, y, NO_MINVENT)) != 0) {
	    /* if statue has been named, give same name to the monster */
	    if (otmp->onamelth)
		mtmp = christen_monst(mtmp, ONAME(otmp));
	    /* transfer any statue contents to monster's inventory */
	    while ((item = otmp->cobj) != 0) {
		obj_extract_self(item);
		add_to_minv(mtmp, item);
	    }
	    m_dowear(mtmp, TRUE);
	    delobj(otmp);
	    /* mimic statue becomes seen mimic; other hiders won't be hidden */
	    if (mtmp->m_ap_type) seemimic(mtmp);
	    else mtmp->mundetected = FALSE;
	    if (x == u.ux && y == u.uy)
/*JP
		pline_The("statue comes to life!");
*/
	        pline("彫像は生命を帯びた！");
	    else if (shatter)
/*JP
		pline("Instead of shattering, the statue suddenly comes alive!");
*/
		pline("砕けるかわりに，彫像は生命を帯びた！");
	    else
/*JP
		You("find %s posing as a statue.", a_monnam(mtmp));
*/
		pline("%sが彫像のふりをしているのを見つけた．", a_monnam(mtmp));
	    /* avoid hiding under nothing */
	    if (x == u.ux && y == u.uy &&
		    Upolyd && hides_under(uasmon) && !OBJ_AT(x, y))
		u.uundetected = 0;
	}
	if (Blind) feel_location(x, y);
	else newsym(x, y);
	return mtmp;
}

void
dotrap(trap)
register struct trap *trap;
{
	register int ttype = trap->ttyp;
	register struct monst *mtmp;
	register struct obj *otmp;
	boolean already_seen = trap->tseen;

	nomul(0);
	if(already_seen) {
	    if ((Levitation || is_flyer(uasmon)) &&
		    (ttype == PIT || ttype == SPIKED_PIT || ttype == HOLE ||
		    ttype == BEAR_TRAP)) {
#if 0 /*JP*/
		You("%s over %s %s.",
		    Levitation ? "float" : "fly",
		    a_your[trap->madeby_u],
		    defsyms[trap_to_defsym(ttype)].explanation);
#endif
		You("%s%sの上%s．",
		    set_you[trap->madeby_u],
		    jtrns_obj('^', defsyms[trap_to_defsym(ttype)].explanation),
		    Levitation ? "を見下ろした" : "を飛んでいる");
		return;
	    }
	    if(!Fumbling && ttype != MAGIC_PORTAL && ttype != ANTI_MAGIC &&
		(!rn2(5) ||
	    ((ttype == PIT || ttype == SPIKED_PIT) && is_clinger(uasmon)))) {
#if 0 /*JP*/
		You("escape %s %s.",
		    (ttype == ARROW_TRAP && !trap->madeby_u) ? "an" :
			a_your[trap->madeby_u],
		    defsyms[trap_to_defsym(ttype)].explanation);
#endif
		You("%s%sをするりと避けた．",
		    set_you[trap->madeby_u],
		    jtrns_obj('^', defsyms[trap_to_defsym(ttype)].explanation));
		return;
	    }
	}
		
	switch(ttype) {
	    case ARROW_TRAP:
		seetrap(trap);
/*JP		pline("An arrow shoots out at you!");*/
		pline("矢が飛んできた！");
		otmp = mksobj(ARROW, TRUE, FALSE);
		otmp->quan = 1L;
		otmp->owt = weight(otmp);
		if (thitu(8, dmgval(otmp, &youmonst), otmp, "矢")) {
		    obfree(otmp, (struct obj *)0);
		} else {
		    place_object(otmp, u.ux, u.uy);
		    if (!Blind) otmp->dknown = 1;
		    stackobj(otmp);
		    newsym(u.ux, u.uy);
		}
		break;
	    case DART_TRAP:
		seetrap(trap);
/*JP		pline("A little dart shoots out at you!");*/
		pline("小さな投げ矢があなたに飛んできた！");
		otmp = mksobj(DART, TRUE, FALSE);
		otmp->quan = 1L;
		otmp->owt = weight(otmp);
		if (!rn2(6)) otmp->opoisoned = 1;
/*JP		if (thitu(7, dmgval(otmp, &youmonst), otmp, "little dart")) {*/
		if (thitu(7, dmgval(otmp, &youmonst), otmp, "投げ矢")) {
		    if (otmp->opoisoned)
/*JP			poisoned("dart",A_CON,"poison dart",10);*/
			poisoned("投げ矢",A_CON,"毒矢",10);
		    obfree(otmp, (struct obj *)0);
		} else {
		    place_object(otmp, u.ux, u.uy);
		    if (!Blind) otmp->dknown = 1;
		    stackobj(otmp);
		    newsym(u.ux, u.uy);
		}
		break;
	    case ROCKTRAP:
		{
		    int dmg = d(2,6); /* should be std ROCK dmg? */

		    seetrap(trap);
		    otmp = mksobj_at(ROCK, u.ux, u.uy, TRUE);
		    otmp->quan = 1L;
		    otmp->owt = weight(otmp);

/*JP    pline("A trap door in the %s opens and a rock falls on your %s!",*/
		    pline("落し扉が%sに開き，石があなたの%sに落ちてきた！",
			    ceiling(u.ux,u.uy),
			    body_part(HEAD));

			/* KOKA */
			if(u.uusestand && (rn2(20) < ACURR(A_DEX))) {
			    You("素早くスタンドで防いだ．");
			    dmg = 0;
			}
		    else if (uarmh) {
			if(is_metallic(uarmh)) {
/*JP			    pline("Fortunately, you are wearing a hard helmet.");*/
			    pline("幸運にも，あなたは固い兜を身につけていた．");
			    dmg = 2;
			} else if (flags.verbose) {
/*JP			    Your("%s does not protect you.", xname(uarmh));*/
			    Your("%sでは防げない．", xname(uarmh));
			}
		    }

		    if (!Blind) otmp->dknown = 1;
		    stackobj(otmp);
		    newsym(u.ux,u.uy);	/* map the rock */

/*JP		    losehp(dmg, "falling rock", KILLED_BY_AN);*/
		    losehp(dmg, "落岩で", KILLED_BY_AN);
		    exercise(A_STR, FALSE);
		}
		break;

	    case SQKY_BOARD:	    /* stepped on a squeaky board */
		if (Levitation || is_flyer(uasmon)) {
		    if (!Blind) {
			seetrap(trap);
			if (Hallucination)
/*JP				You("notice a crease in the linoleum.");*/
				You("床の仕上材のしわに気がついた．");
			else
/*JP				You("notice a loose board below you.");*/
				You("足元の緩んだ板に気がついた．");
		    }
		} else {
		    seetrap(trap);
/*JP		    pline("A board beneath you squeaks loudly.");*/
		    pline("足元の板が大きくきしんだ．");
		    wake_nearby();
		}
		break;

	    case BEAR_TRAP:
		if(Levitation || is_flyer(uasmon)) break;
		seetrap(trap);
		if(amorphous(uasmon) || is_whirly(uasmon) ||
						    unsolid(uasmon)) {
/*JP		    pline("%s bear trap closes harmlessly through you.",
			    A_Your[trap->madeby_u]);*/
		    pline("%s熊の罠は噛みついたが，するっと通り抜けた．",
			    set_you[trap->madeby_u]);
		    break;
		}
		if(uasmon->msize <= MZ_SMALL) {
/*JP		    pline("%s bear trap closes harmlessly over you.",
			    A_Your[trap->madeby_u]);*/
		    pline("%s熊の罠は遥か上方で噛みついた．",
			    set_you[trap->madeby_u]);
		    break;
		}
		u.utrap = rn1(4, 4);
		u.utraptype = TT_BEARTRAP;
/*JP		pline("%s bear trap closes on your %s!",
			    A_Your[trap->madeby_u], body_part(FOOT));*/
		pline("%s熊の罠があなたの%sに噛みついた！",
			    set_you[trap->madeby_u], body_part(FOOT));
		if(u.umonnum == PM_OWLBEAR || u.umonnum == PM_BUGBEAR)
/*JP		    You("howl in anger!");*/
		    You("怒りの咆哮をあげた！");
		exercise(A_DEX, FALSE);
		break;

	    case SLP_GAS_TRAP:
		seetrap(trap);
		if(Sleep_resistance) {
/*JP		    You("are enveloped in a cloud of gas!");*/
		    You("ガス雲につつまれた！");
		    break;
		}
/*JP		pline("A cloud of gas puts you to sleep!");*/
		pline("あなたはガス雲で眠ってしまった！");
		flags.soundok = 0;
		fall_asleep(-rnd(25), TRUE);
		afternmv = Hear_again;
		break;

	    case RUST_TRAP:
		seetrap(trap);
		if (u.umonnum == PM_IRON_GOLEM) {
/*JP		    pline("%s you!", A_gush_of_water_hits);*/
		    pline("水が噴出してあなたに命中した！");
/*JP		    You("are covered with rust!");*/
		    You("錆に覆われた！");
		    rehumanize();
		    break;
		} else if (u.umonnum == PM_GREMLIN && rn2(3)) {
/*JP		    pline("%s you!", A_gush_of_water_hits);*/
		    pline("水が噴出してあなたに命中した！");
		    if ((mtmp = cloneu()) != 0) {
			mtmp->mhpmax = (u.mhmax /= 2);
/*JP			You("multiply.");*/
			You("分裂した．");
		    }
		    break;
		}

	    /* Unlike monsters, traps cannot aim their rust attacks at
	     * you, so instead of looping through and taking either the
	     * first rustable one or the body, we take whatever we get,
	     * even if it is not rustable.
	     */
		switch (rn2(5)) {
		    case 0:
/*JP			pline("%s you on the %s!", A_gush_of_water_hits,*/
			pline("水が噴出してあなたの%sに命中した！",
				    body_part(HEAD));
/*JP			(void) rust_dmg(uarmh, "helmet", 1, TRUE);*/
			(void) rust_dmg(uarmh, "兜", 1, TRUE);
			break;
		    case 1:
/*JP			pline("%s your left %s!", A_gush_of_water_hits,*/
			pline("水が噴出してあなたの左%sに命中した！",
				    body_part(ARM));
/*JP			if (rust_dmg(uarms, "shield", 1, TRUE)) break;*/
			if (rust_dmg(uarms, "盾", 1, TRUE)) break;
			if (uwep && bimanual(uwep))
			    goto two_hand;
			/* Two goto statements in a row--aaarrrgggh! */
/*JPglovecheck:		    (void) rust_dmg(uarmg, "gauntlets", 1, TRUE);*/
glovecheck:		    (void) rust_dmg(uarmg, "小手", 1, TRUE);
			/* Not "metal gauntlets" since it gets called
			 * even if it's leather for the message
			 */
			break;
		    case 2:
/*JP			pline("%s your right %s!", A_gush_of_water_hits,*/
			pline("水が噴出してあなたの右%sに命中した！",
				    body_part(ARM));
two_hand:		    erode_weapon(FALSE);
			goto glovecheck;
		    default:
/*JP			pline("%s you!", A_gush_of_water_hits);*/
			pline("水が噴出してあなたに命中した！");
			for (otmp=invent; otmp; otmp = otmp->nobj)
				    (void) snuff_lit(otmp);
/*JP			if (uarmc) (void) rust_dmg(uarmc, "cloak", 1, TRUE);*/
			if (uarmc) (void) rust_dmg(uarmc, "クローク", 1, TRUE);
			else if (uarm)
/*JP			    (void) rust_dmg(uarm, "armor", 1, TRUE);*/
			    (void) rust_dmg(uarm, "鎧", 1, TRUE);
#ifdef TOURIST
			else if (uarmu)
/*JP			    (void) rust_dmg(uarmu, "shirt", 1, TRUE);*/
			    (void) rust_dmg(uarmu, "シャツ", 1, TRUE);
#endif
		}
		break;

	    case FIRE_TRAP:
		seetrap(trap);
		dofiretrap((struct obj *)0);
		break;

	    case PIT:
	    case SPIKED_PIT:
		if (Levitation || is_flyer(uasmon)) break;
		seetrap(trap);
		if (is_clinger(uasmon)) {
		    if(trap->tseen) {
/*JP			You("see %s %spit below you.", a_your[trap->madeby_u],
			    ttype == SPIKED_PIT ? "spiked " : "");*/
			pline("足元に%s%s落し穴を発見した．", 
			    dig_you[trap->madeby_u],
			    ttype == SPIKED_PIT ? "トゲだらけの" : "");
		    } else {
/*JP			pline("%s pit %sopens up under you!",
			    A_Your[trap->madeby_u],
			    ttype == SPIKED_PIT ? "full of spikes " : "");*/
			    pline("%s落し穴が足元に開いた！",
				  dig_you[trap->madeby_u]);
/*JP			You("don't fall in!");*/
			pline("しかし，あなたは落ちなかった！");
		    }
		    break;
		}
/*JP		You("fall into %s pit!", a_your[trap->madeby_u]);*/
		You("%s落し穴に落ちた！", dig_you[trap->madeby_u]); 
		if (ttype == SPIKED_PIT)
/*JP		    You("land on a set of sharp iron spikes!");*/
		    You("鋭い鉄のトゲトゲの上に落ちた！");
		if (!passes_walls(uasmon))
		    u.utrap = rn1(6,2);
		u.utraptype = TT_PIT;
		if (ttype == SPIKED_PIT) {
/*JP		    losehp(rnd(10),"fell into a pit of iron spikes",*/
		    losehp(rnd(10),"トゲだらけの落し穴に落ちて",
/*JP			NO_KILLER_PREFIX);*/
			KILLED_BY);
		    if (!rn2(6))
/*JP			poisoned("spikes", A_STR, "fall onto poison spikes", 8);*/
			poisoned("トゲ", A_STR, "落し穴のトゲ", 8);
		} else
/*JP		    losehp(rnd(6),"fell into a pit", NO_KILLER_PREFIX);*/
		    losehp(rnd(6),"落し穴に落ちて", KILLED_BY);
		if (Punished && !carried(uball)) {
		    unplacebc();
		    ballfall();
		    placebc();
		}
/*JP		selftouch("Falling, you");*/
		selftouch("落下中あなたは");
		vision_full_recalc = 1;	/* vision limits change */
		exercise(A_STR, FALSE);
		exercise(A_DEX, FALSE);
		break;
	    case HOLE:
	    case TRAPDOOR:
		seetrap(trap);
		if (!Can_fall_thru(&u.uz)) {
		    impossible("dotrap: %ss cannot exist on this level.",
			       defsyms[trap_to_defsym(ttype)].explanation);
		    break;		/* don't activate it after all */
		}
		fall_through(TRUE);
		break;

	    case TELEP_TRAP:
		seetrap(trap);
		tele_trap(trap);
		break;
	    case LEVEL_TELEP:
		seetrap(trap);
		level_tele_trap(trap);
		break;

	    case WEB: /* Our luckless player has stumbled into a web. */
		seetrap(trap);
		if (amorphous(uasmon) || is_whirly(uasmon) ||
						    unsolid(uasmon)) {
		    if (acidic(uasmon) || u.umonnum == PM_GELATINOUS_CUBE ||
			u.umonnum == PM_FIRE_ELEMENTAL) {
/*JP			You("%s %s spider web!",
			    (u.umonnum == PM_FIRE_ELEMENTAL) ? "burn" : "dissolve",
			    a_your[trap->madeby_u]);*/
			You("%s蜘蛛の巣を%s！",
			    web_you[trap->madeby_u],
			    (u.umonnum == PM_FIRE_ELEMENTAL) ? "焼いた" : "こなごなにした");
			deltrap(trap);
			newsym(u.ux,u.uy);
			break;
		    }
/*JP		    You("flow through %s spider web.",
			    a_your[trap->madeby_u]);*/
		    You("%s蜘蛛の巣をするりと通り抜けた．",
			    web_you[trap->madeby_u]);
		    break;
		}
		if (uasmon->mlet == S_SPIDER) {
/*JP		    pline(trap->madeby_u ? "You take a walk on your web."
					 : "There is a spider web here.");*/
		    pline(trap->madeby_u ? 
			  "自分で張った蜘蛛の巣の上を歩いた．" : 
			  "ここには蜘蛛の巣がある");
		    break;
		}
/*JP		You("%s into %s spider web!",
		      Levitation ? (const char *)"float" :
		      locomotion(uasmon, "stumble"),
		      a_your[trap->madeby_u]);*/
		You("%s%s蜘蛛の巣にひっかかった",
		    Levitation ? (const char *)"浮きながら" : 
		    jconj(locomotion(uasmon, "つまずく"), "て"),
		    web_you[trap->madeby_u]);
		u.utraptype = TT_WEB;

		/* Time stuck in the web depends on your strength. */
		{
		    register int str = ACURR(A_STR);

		    if (str == 3) u.utrap = rn1(6,6);
		    else if (str < 6) u.utrap = rn1(6,4);
		    else if (str < 9) u.utrap = rn1(4,4);
		    else if (str < 12) u.utrap = rn1(4,2);
		    else if (str < 15) u.utrap = rn1(2,2);
		    else if (str < 18) u.utrap = rnd(2);
		    else if (str < 69) u.utrap = 1;
		    else {
			u.utrap = 0;
/*JP			You("tear through %s web!", a_your[trap->madeby_u]);*/
			You("%s蜘蛛の巣を引き裂いた！",
			    web_you[trap->madeby_u]);
			deltrap(trap);
			newsym(u.ux,u.uy);	/* get rid of trap symbol */
		    }
		}
		break;

	    case STATUE_TRAP:
		(void) activate_statue_trap(trap, u.ux, u.uy, FALSE);
		break;

	    case MAGIC_TRAP:	    /* A magic trap. */
		seetrap(trap);
		if (!rn2(30)) {
		    deltrap(trap);
		    newsym(u.ux,u.uy);	/* update position */
/*JP		    You("are caught in a magical explosion!");*/
		    You("魔法の爆発を浴びた！");
/*JP		    losehp(rnd(10), "magical explosion", KILLED_BY_AN);*/
		    losehp(rnd(10), "魔法の爆発を浴びて", KILLED_BY_AN);
/*JP		    Your("body absorbs some of the magical energy!");*/
		    Your("体は魔法のエネルギーを少し吸いとった！");
		    u.uen = (u.uenmax += 2);
		} else domagictrap();
		break;

	    case ANTI_MAGIC:
		seetrap(trap);
		if(Antimagic) {
		    shieldeff(u.ux, u.uy);
/*JP		    You_feel("momentarily lethargic.");*/
		    You("一瞬無気力感を感じた．");
		} else drain_en(rnd(u.ulevel) + 1);
		break;

	    case POLY_TRAP:
		seetrap(trap);
/*JP		You("%s onto a polymorph trap!",
		    Levitation ? (const char *)"float" :
		    locomotion(uasmon, "step"));*/
		You("変化の罠に%s！",
		    jconj(Levitation ? (const char *)"浮きながら飛びこむ" : 
		    locomotion(uasmon, "踏み込む"), "た"));
		if(Antimagic) {
		    shieldeff(u.ux, u.uy);
/*JP		    You_feel("momentarily different.");(*/
		    You("一瞬無気力感を感じた．");
		    /* Trap did nothing; don't remove it --KAA */
		} else {
		    deltrap(trap);	/* delete trap before polymorph */
		    newsym(u.ux,u.uy);	/* get rid of trap symbol */
/*JP		    You_feel("a change coming over you.");*/
		    You("変化が訪れたような気がした．");
		    polyself();
		}
		break;

	    case LANDMINE:
		if (Levitation || is_flyer(uasmon)) {
		    if (!already_seen && rn2(3)) break;
		    seetrap(trap);
/*JP		    pline("%s %s in a pile of soil below you.",
			    already_seen ? "There is" : "You discover",
			    trap->madeby_u ? "the trigger of your mine" :
					     "a trigger");*/
		    if(already_seen)
		      pline("ここには%s地雷の起爆スイッチがある．",
			    set_you[trap->madeby_u]);
		    else
		      You("足下の土の山に%s地雷の起爆スイッチをみつけた．",
			    set_you[trap->madeby_u]);
		    if (already_seen && rn2(3)) break;
/*JP		    pline("KAABLAMM!!!  The air currents set %s%s off!",
			    already_seen ? a_your[trap->madeby_u] : "",
			    already_seen ? " land mine" : "it");*/
		    pline("ちゅどーん！！空気の流れで%s地雷のスイッチが入った！",
			    set_you[trap->madeby_u]);
		} else {
		    seetrap(trap);
/*JP		    pline("KAABLAMM!!!  You triggered %s land mine!",
					    a_your[trap->madeby_u]);*/
		    pline("ちゅどーん！！%s地雷の起爆スイッチを踏んだ！",
			    set_you[trap->madeby_u]);
		    set_wounded_legs(LEFT_SIDE, rn1(35, 41));
		    set_wounded_legs(RIGHT_SIDE, rn1(35, 41));
		    exercise(A_DEX, FALSE);
		}
		blow_up_landmine(trap);
		newsym(u.ux,u.uy);		/* update trap symbol */
/*JP		losehp(rnd(16), "land mine", KILLED_BY_AN);*/
		losehp(rnd(16), "地雷を踏んで", KILLED_BY_AN);
		/* fall recursively into the pit... */
		if ((trap = t_at(u.ux, u.uy)) != 0) dotrap(trap);
		break;

	    case ROLLING_BOULDER_TRAP:
		seetrap(trap);
/*JP		pline("Click! You trigger a rolling boulder trap!");*/
		pline("カチッ！あなたは落岩のスイッチを踏んだ！");
		if(!launch_obj(BOULDER, trap->launch.x, trap->launch.y,
		      trap->launch2.x,trap->launch2.y, ROLL)) {
		    deltrap(trap);
		    newsym(u.ux,u.uy);	/* get rid of trap symbol */
/*JP		    pline("Fortunately for you, no boulder was released.");*/
		    pline("運のよいことに岩は転がってこなかった．");
		}
		break;

	    case MAGIC_PORTAL:
		seetrap(trap);
		domagicportal(trap);
		break;

	    default:
		seetrap(trap);
		impossible("You hit a trap of type %u", trap->ttyp);
	}
}

/* some actions common to both player and monsters for triggered landmine */
STATIC_OVL void
blow_up_landmine(trap)
struct trap *trap;
{
	scatter(trap->tx, trap->ty, 4,
		MAY_DESTROY | MAY_HIT | MAY_FRACTURE | VIS_EFFECTS);
	del_engr_at(trap->tx, trap->ty);
	wake_nearto(trap->tx, trap->ty, 400);
	if (IS_DOOR(levl[trap->tx][trap->ty].typ))
	    levl[trap->tx][trap->ty].doormask = D_BROKEN;
	/* TODO: destroy drawbridge if present;
		 sometimes delete trap instead of always leaving a pit */
	trap->ttyp = PIT;		/* explosion creates a pit */
	trap->madeby_u = FALSE;		/* resulting pit isn't yours */
}

#endif /* OVLB */
#ifdef OVL3

/*
 * Move obj from (x1,y1) to (x2,y2)
 *
 * Return 0 if no object was launched.
 *        1 if an object was launched and placed somewhere.
 *        2 if an object was launched, but used up.
 */
int
launch_obj(otyp, x1, y1, x2, y2, style)
short otyp;
register int x1,y1,x2,y2;
int style;
{
	register struct monst *mtmp;
	register struct obj *otmp;
	register int dx,dy;
	struct obj *singleobj;
	boolean used_up = FALSE;
	boolean otherside = FALSE;
	int dist;
	int tmp;
	int delaycnt = 0;

	otmp = sobj_at(otyp, x1, y1);
	/* Try the other side too, for rolling boulder traps */
	if (!otmp && otyp == BOULDER) {
		otherside = TRUE;
		otmp = sobj_at(otyp, x2, y2);
	}
	if (!otmp) return 0;
	if (otherside) {	/* swap 'em */
		int tx, ty;

		tx = x1; ty = y1;
		x1 = x2; y1 = y2;
		x2 = tx; y2 = ty;
	}

	if (otmp->quan == 1L) {
	    obj_extract_self(otmp);
	    singleobj = otmp;
	    otmp = (struct obj *) 0;
	} else {
	    singleobj = splitobj(otmp, otmp->quan - 1L);
	    obj_extract_self(singleobj);
	}
	newsym(x1,y1);
	/* in case you're using a pick-axe to chop the boulder that's being
	   launched (perhaps a monster triggered it), destroy context so that
	   next dig attempt never thinks you're resuming previous effort */
	if ((otyp == BOULDER || otyp == STATUE) &&
	    singleobj->ox == digging.pos.x && singleobj->oy == digging.pos.y)
	    (void) memset((genericptr_t)&digging, 0, sizeof digging);

	dist = distmin(x1,y1,x2,y2);
	bhitpos.x = x1;
	bhitpos.y = y1;
	dx = sgn(x2 - x1);
	dy = sgn(y2 - y1);
	switch (style) {
	    case ROLL:
			delaycnt = 2;
			/* fall through */
	    default:
			if (!delaycnt) delaycnt = 1;
			if (!cansee(bhitpos.x,bhitpos.y)) curs_on_u();
			tmp_at(DISP_FLASH, obj_to_glyph(singleobj));
			tmp_at(bhitpos.x, bhitpos.y);
	}
	while(dist-- > 0 && !used_up) {
		tmp_at(bhitpos.x, bhitpos.y);
		tmp = delaycnt;
		while (tmp-- > 0) delay_output();
		bhitpos.x += dx;
		bhitpos.y += dy;

		if ((mtmp = m_at(bhitpos.x, bhitpos.y)) != 0) {
			if (otyp == BOULDER && throws_rocks(mtmp->data)) {
			    if (rn2(3)) {
/*JP				pline("%s snatches the boulder.",*/
				pline("%sは岩をもぎとった．",
					Monnam(mtmp));
				mpickobj(mtmp, singleobj);
				used_up = TRUE;
				break;
			    }
			}
			if (ohitmon(mtmp,singleobj,
					(style==ROLL) ? -1 : dist, FALSE)) {
				used_up = TRUE;
				break;
			}
		} else if (bhitpos.x==u.ux && bhitpos.y==u.uy) {
			int hitvalu, hitu;
			if (multi) nomul(0);
			hitvalu = 9 + singleobj->spe;
			hitu = thitu(hitvalu,
				dmgval(singleobj, &youmonst),
				singleobj,
				xname(singleobj));
			if (hitu) stop_occupation();
		}
		if (style == ROLL) {
		    if (down_gate(bhitpos.x, bhitpos.y) != -1) {
		       if (ship_object(singleobj, bhitpos.x, bhitpos.y, FALSE)){
				used_up = TRUE;
				break;
			}
		    }
/*JP		    if (flooreffects(singleobj, bhitpos.x, bhitpos.y, "fall")) {*/
		    if (flooreffects(singleobj, bhitpos.x, bhitpos.y, "落ちた")) {
			used_up = TRUE;
			break;
		    }
		}
		if (otyp == BOULDER && closed_door(bhitpos.x,bhitpos.y)) {
			if (cansee(bhitpos.x, bhitpos.y))
/*JP				pline_The("boulder crashes through a door.");*/
				pline("岩は扉を破壊した．");
			levl[bhitpos.x][bhitpos.y].doormask = D_BROKEN;
		}
	}
	tmp_at(DISP_END, 0);
	if (!used_up) {
		place_object(singleobj, x2,y2);
		newsym(x2,y2);
		return 1;
	} else
		return 2;
}
#endif /* OVL3 */
#ifdef OVLB

void
seetrap(trap)
	register struct trap *trap;
{
	if(!trap->tseen) {
	    trap->tseen = 1;
	    newsym(trap->tx, trap->ty);
	}
}

#endif /* OVLB */
#ifdef OVL3

STATIC_OVL int
mkroll_launch(ttmp, x, y, otyp, ocount)
struct trap *ttmp;
xchar x,y;
short otyp;
long ocount;
{
	struct obj *otmp;
	register int tmp;
	schar dx,dy;
	int distance;
	coord cc;
	coord bcc;
	int trycount = 0;
	boolean success = FALSE;
	int mindist = 4;

	if (ttmp->ttyp == ROLLING_BOULDER_TRAP) mindist = 2;
	distance = rn1(5,4);    /* 4..8 away */
	tmp = rn2(8);		/* randomly pick a direction to try first */
	while (distance >= mindist) {
		dx = xdir[tmp];
		dy = ydir[tmp];
		cc.x = x; cc.y = y;
		/* Prevent boulder from being placed on water */
		if (ttmp->ttyp == ROLLING_BOULDER_TRAP
				&& is_pool(x+distance*dx,y+distance*dy))
			success = FALSE;
		else success = isclearpath(&cc, distance, dx, dy);
		if (ttmp->ttyp == ROLLING_BOULDER_TRAP) {
			boolean success_otherway;
			bcc.x = x; bcc.y = y;
			success_otherway = isclearpath(&bcc, distance,
						-(dx), -(dy));
			if (!success_otherway) success = FALSE;
		}
		if (success) break;
		if (++tmp > 7) tmp = 0;
		if ((++trycount % 8) == 0) --distance;
	}
	if (!success) {
	    /* create the trap without any ammo, launch pt at trap location */
		cc.x = bcc.x = x;
		cc.y = bcc.y = y;
	} else {
		otmp = mksobj(otyp, TRUE, FALSE);
		otmp->quan = ocount;
		otmp->owt = weight(otmp);
		place_object(otmp, cc.x, cc.y);
		stackobj(otmp);
	}
	ttmp->launch.x = cc.x;
	ttmp->launch.y = cc.y;
	if (ttmp->ttyp == ROLLING_BOULDER_TRAP) {
		ttmp->launch2.x = bcc.x;
		ttmp->launch2.y = bcc.y;
	} else
		ttmp->launch_otyp = otyp;
	newsym(ttmp->launch.x, ttmp->launch.y);
	return 1;
}

STATIC_OVL boolean
isclearpath(cc,distance,dx,dy)
coord *cc;
int distance;
schar dx,dy;
{
	uchar typ;
	xchar x, y;

	x = cc->x;
	y = cc->y;
	while (distance-- > 0) {
		x += dx;
		y += dy;
		typ = levl[x][y].typ;
		if (!isok(x,y) || !ZAP_POS(typ) || closed_door(x,y))
			return FALSE;
	}
	cc->x = x;
	cc->y = y;
	return TRUE;
}
#endif /* OVL3 */
#ifdef OVL1

int
mintrap(mtmp)
register struct monst *mtmp;
{
	register struct trap *trap = t_at(mtmp->mx, mtmp->my);
	boolean trapkilled = FALSE;
	struct permonst *mptr = mtmp->data;
	struct obj *otmp;

	if (!trap) {
	    mtmp->mtrapped = 0;	/* perhaps teleported? */
	} else if (mtmp->mtrapped) {	/* is currently in the trap */
	    if (!rn2(40)) {
		if (sobj_at(BOULDER, mtmp->mx, mtmp->my) &&
			(trap->ttyp == PIT || trap->ttyp == SPIKED_PIT)) {
		    if (!rn2(2)) {
			mtmp->mtrapped = 0;
			if (canseemon(mtmp))
/*JP
			    pline("%s pulls free...", Monnam(mtmp));
*/
			    pline("%sは助け上げられた．", Monnam(mtmp));
			fill_pit(mtmp->mx, mtmp->my);
		    }
		} else {
		    mtmp->mtrapped = 0;
		}
	    } else if (trap->ttyp == BEAR_TRAP && metallivorous(mptr)) {
		if (canseemon(mtmp))
/*JP
		    pline("%s eats a bear trap!", Monnam(mtmp));
*/
		    pline("%sは熊の罠を食べた！", Monnam(mtmp));
		deltrap(trap);
		mtmp->meating = 5;
		mtmp->mtrapped = 0;
	    }
	} else {
	    register int tt = trap->ttyp;
	    boolean in_sight, tear_web, see_it;

	    if ((mtmp->mtrapseen & (1 << (tt-1))) != 0 ||
		    (tt == HOLE && !mindless(mtmp->data))) {
		/* it has been in such a trap - perhaps it escapes */
		if(rn2(4)) return(0);
	    } else {
		mtmp->mtrapseen |= (1 << (tt-1));
	    }
	    /* Monster is aggravated by being trapped by you.
	       Recognizing who made the trap isn't completely
	       unreasonable; everybody has their own style. */
	    if (trap->madeby_u && rnl(5)) setmangry(mtmp);

	    /* bug?  `in_sight' ought to be split to distinguish between
	       trap_in_sight and can_see_victim to handle invisible monsters */
	    in_sight = canseemon(mtmp);
	    switch (tt) {
		case ARROW_TRAP:
			otmp = mksobj(ARROW, TRUE, FALSE);
			otmp->quan = 1L;
			otmp->owt = weight(otmp);
			if (in_sight) seetrap(trap);
			if(thitm(8, mtmp, otmp, 0)) trapkilled = TRUE;
			break;
		case DART_TRAP:
			otmp = mksobj(DART, TRUE, FALSE);
			otmp->quan = 1L;
			otmp->owt = weight(otmp);
			if (!rn2(6)) otmp->opoisoned = 1;
			if (in_sight) seetrap(trap);
			if(thitm(7, mtmp, otmp, 0)) trapkilled = TRUE;
			break;
		case ROCKTRAP:
			otmp = mksobj(ROCK, TRUE, FALSE);
			otmp->quan = 1L;
			otmp->owt = weight(otmp);
			if (in_sight) seetrap(trap);
			if (thitm(0, mtmp, otmp, d(2, 6)))
			    trapkilled = TRUE;
			break;

		case SQKY_BOARD:
			if(is_flyer(mptr)) break;
			/* stepped on a squeaky board */
			if (in_sight) {
/*JP			    pline("A board beneath %s squeaks loudly.", mon_nam(mtmp));*/
			    pline("%sの足元の板が大きくきしんだ．", mon_nam(mtmp));
			    seetrap(trap);
			} else
/*JP			   You_hear("a distant squeak.");*/
			   You_hear("遠くできしむ音を聞いた．");
			/* wake up nearby monsters */
			wake_nearto(mtmp->mx, mtmp->my, 40);
			break;

		case BEAR_TRAP:
			if(mptr->msize > MZ_SMALL &&
				!amorphous(mptr) && !is_flyer(mptr) &&
				!is_whirly(mptr) && !unsolid(mptr)) {
			    mtmp->mtrapped = 1;
			    if(in_sight) {
/*JP				pline("%s is caught in %s bear trap!",
				      Monnam(mtmp), a_your[trap->madeby_u]);*/
				pline("%sは%s熊の罠につかまった！",
				      Monnam(mtmp), set_you[trap->madeby_u]);
				seetrap(trap);
			    } else {
				if((mptr == &mons[PM_OWLBEAR]
				    || mptr == &mons[PM_BUGBEAR])
				   && flags.soundok)
/*JP				    You_hear("the roaring of an angry bear!");*/
				    You_hear("怒りの咆哮を聞いた！");
			    }
			}
			break;

		case SLP_GAS_TRAP:
			if (!resists_sleep(mtmp) &&
				!mtmp->msleep && mtmp->mcanmove) {
			    mtmp->mcanmove = 0;
			    mtmp->mfrozen = rnd(25);
			    if (in_sight) {
/*JP				pline("%s suddenly falls asleep!",*/
				pline("%sは突然眠りに落ちた！",
				      Monnam(mtmp));
				seetrap(trap);
			    }
			}
			break;

		case RUST_TRAP:
			if (in_sight) {
/*JP			    pline("%s %s!", A_gush_of_water_hits,*/
			    pline("水が噴出して，%sに命中した！", 
				  mon_nam(mtmp));
			    seetrap(trap);
			}
			if (mptr == &mons[PM_IRON_GOLEM]) {
				if (in_sight)
/*JP				    pline("%s falls to pieces!", Monnam(mtmp));*/
				    pline("%sはくだけちった！", Monnam(mtmp));
				else if(mtmp->mtame)
/*JP				    pline("May %s rust in peace.",*/
				    pline("%sよ永遠に破片なれ．",
								mon_nam(mtmp));
				mondied(mtmp);
				if (mtmp->mhp <= 0)
					trapkilled = TRUE;
			} else if (mptr == &mons[PM_GREMLIN] && rn2(3)) {
				struct monst *mtmp2 = clone_mon(mtmp);

				if (mtmp2) {
				    mtmp2->mhpmax = (mtmp->mhpmax /= 2);
				    if(in_sight)
/*JP					pline("%s multiplies.", Monnam(mtmp));*/
					pline("%sは分裂した．", Monnam(mtmp));
				}
			}
			if (rn2(2))
			    for (otmp = mtmp->minvent; otmp; otmp = otmp->nobj)
				(void) snuff_lit(otmp);
			break;

		case FIRE_TRAP:
 mfiretrap:
			see_it = cansee(mtmp->mx, mtmp->my);
			if (in_sight)
/*JP			    pline("A %s erupts from the %s under %s!",
				  tower_of_flame,
				  surface(mtmp->mx,mtmp->my), mon_nam(mtmp));*/
			    pline("火柱が%sの足元の%sから立ちのぼった！",
				  mon_nam(mtmp), surface(mtmp->mx,mtmp->my));
			else if (see_it)  /* evidently `mtmp' is invisible */
/*JP			    You("see a %s erupt from the %s!",
				tower_of_flame, surface(mtmp->mx,mtmp->my));*/
			    You("火柱が%sから生じるのを見た！",
				surface(mtmp->mx,mtmp->my));

			if (resists_fire(mtmp)) {
			    if (in_sight) {
				shieldeff(mtmp->mx,mtmp->my);
/*JP				pline("%s is uninjured.", Monnam(mtmp));*/
				pline("が，%sは傷つかない．", Monnam(mtmp));
			    }
			} else {
			    int num = d(2,4);

			    if (thitm(0, mtmp, (struct obj *)0, num))
				trapkilled = TRUE;
			    else
				/* we know mhp is at least `num' below mhpmax,
				   so no (mhp > mhpmax) check is needed here */
				mtmp->mhpmax -= rn2(num + 1);
			}
			(void) destroy_mitem(mtmp, SCROLL_CLASS, AD_FIRE);
			(void) destroy_mitem(mtmp, SPBOOK_CLASS, AD_FIRE);
			(void) destroy_mitem(mtmp, POTION_CLASS, AD_FIRE);
			if (burn_floor_paper(mtmp->mx, mtmp->my, see_it) &&
				!see_it && distu(mtmp->mx, mtmp->my) <= 3*3)
/*JP			    You("smell smoke.");*/
			    pline("煙の匂いがした．");
			if (is_ice(mtmp->mx,mtmp->my))
			    melt_ice(mtmp->mx,mtmp->my);
			if (see_it) seetrap(trap);
			break;

		case PIT:
		case SPIKED_PIT:
			if ( !is_flyer(mptr) &&
			     (!mtmp->wormno || (count_wsegs(mtmp) < 6)) &&
			     !is_clinger(mptr) ) {
				if (!passes_walls(mptr))
				    mtmp->mtrapped = 1;
				if(in_sight) {
/*JP				    pline("%s falls into %s pit!",
					Monnam(mtmp), a_your[trap->madeby_u]);*/
				    pline("%sは%s落し穴に落ちた！",
					Monnam(mtmp), set_you[trap->madeby_u]);
				    seetrap(trap);
				}
/*JP				mselftouch(mtmp, "Falling, ", FALSE);*/
				mselftouch(mtmp, "落下中，", FALSE);
				if(mtmp->mhp <= 0 ||
					thitm(0, mtmp, (struct obj *)0,
					 rnd((tt==PIT) ? 6 : 10)))
				    trapkilled = TRUE;
			}
			break;
		case HOLE:
		case TRAPDOOR:
			if (!Can_fall_thru(&u.uz)) {
			 impossible("mintrap: %ss cannot exist on this level.",
				    defsyms[trap_to_defsym(tt)].explanation);
			    break;	/* don't activate it after all */
			}
			if (is_flyer(mptr) || mptr == &mons[PM_WUMPUS] ||
			    (mtmp->wormno && count_wsegs(mtmp) > 5) ||
			    mptr->msize >= MZ_HUGE) break;
			/* Fall through */
		case LEVEL_TELEP:
		case MAGIC_PORTAL:
			{
			    int mlev_res;
			    mlev_res = mlevel_tele_trap(mtmp, trap, in_sight);
			    if (mlev_res) return(mlev_res);
			}
			break;

		case TELEP_TRAP:
			mtele_trap(mtmp, trap, in_sight);
			break;

		case WEB:
			/* Monster in a web. */
			if (mptr->mlet == S_SPIDER) break;
			if (amorphous(mptr) || is_whirly(mptr) || unsolid(mptr)){
			    if(acidic(mptr) ||
			       mptr == &mons[PM_GELATINOUS_CUBE] ||
			       mptr == &mons[PM_FIRE_ELEMENTAL]) {
				if (in_sight)
/*JP				    pline("%s %s %s spider web!",
					  Monnam(mtmp),
					  (mptr == &mons[PM_FIRE_ELEMENTAL]) ?
					    "burns" : "dissolves",
					  a_your[trap->madeby_u]);*/
				    pline("%s%s蜘蛛の巣を%s！",
					  Monnam(mtmp),
					  web_you[trap->madeby_u],
					  (mptr == &mons[PM_FIRE_ELEMENTAL]) ?
					    "焼いた" : "こなごなにした");
				deltrap(trap);
				newsym(mtmp->mx, mtmp->my);
				break;
			    }
			    if (in_sight) {
/*JP				pline("%s flows through %s spider web.",
				      Monnam(mtmp),
				      a_your[trap->madeby_u]);*/
				pline("%sは%s蜘蛛の巣をするりと通り抜けた．",
				      Monnam(mtmp),
				      web_you[trap->madeby_u]);
				seetrap(trap);
			    }
			    break;
			}
			tear_web = FALSE;
			switch (monsndx(mptr)) {
			    case PM_OWLBEAR: /* Eric Backus */
			    case PM_BUGBEAR:
				if (!in_sight) {
/*JP				    You_hear("the roaring of a confused bear!");*/
				    You_hear("混乱の咆哮を聞いた！");
				    mtmp->mtrapped = 1;
				    break;
				}
				/* fall though */
			    default:
				if (mptr->mlet == S_GIANT ||
				    (mptr->mlet == S_DRAGON &&
					extra_nasty(mptr)) || /* excl. babies */
				    (mtmp->wormno && count_wsegs(mtmp) > 5)) {
				    tear_web = TRUE;
				} else if (in_sight) {
/*JP				    pline("%s is caught in %s spider web.",
					  Monnam(mtmp),
					  a_your[trap->madeby_u]);*/
				    pline("%sは%s蜘蛛の巣につかまった．",
					  Monnam(mtmp),
					  web_you[trap->madeby_u]);
				    seetrap(trap);
				}
				mtmp->mtrapped = tear_web ? 0 : 1;
				break;
			    /* this list is fairly arbitrary; it deliberately
			       excludes wumpus & giant/ettin zombies/mummies */
			    case PM_TITANOTHERE:
			    case PM_BALUCHITHERIUM:
			    case PM_PURPLE_WORM:
			    case PM_JABBERWOCK:
			    case PM_IRON_GOLEM:
			    case PM_BALROG:
			    case PM_KRAKEN:
				tear_web = TRUE;
				break;
			}
			if (tear_web) {
			    if (in_sight)
/*JP				pline("%s tears through %s spider web!",
				      Monnam(mtmp), a_your[trap->madeby_u]);*/
				pline("%sは%s蜘蛛の巣を引き裂いた！",
				      Monnam(mtmp), web_you[trap->madeby_u]);
			    deltrap(trap);
			    newsym(mtmp->mx, mtmp->my);
			}
			break;

		case STATUE_TRAP:
			break;

		case MAGIC_TRAP:
			/* A magic trap.  Monsters usually immune. */
			if (!rn2(21)) goto mfiretrap;
			break;
		case ANTI_MAGIC:
			break;

		case LANDMINE:
			if(rn2(3))
				break; /* monsters usually don't set it off */
			if(is_flyer(mptr)) {
				boolean already_seen = trap->tseen;
				if (in_sight && !already_seen) {
/*JP	pline("A trigger appears in a pile of soil below %s.", mon_nam(mtmp));*/
	pline("%sの足元の土の山に起爆スイッチが現われた．", mon_nam(mtmp));
					seetrap(trap);
				}
				if (rn2(3)) break;
				if (in_sight) {
					newsym(mtmp->mx, mtmp->my);
/*JP					pline_The("air currents set %s off!",
					  already_seen ? "a land mine" : "it");*/
					pline("空気の流れでスイッチが入った！");
				}
			} else if(in_sight) {
			    newsym(mtmp->mx, mtmp->my);
/*JP			    pline("KAABLAMM!!!  %s triggers %s land mine!",
				Monnam(mtmp), a_your[trap->madeby_u]);*/
			    pline("ちゅどーん！！%sは%s地雷の起爆スイッチを踏んだ！",
				Monnam(mtmp), set_you[trap->madeby_u]);
			}
			if (!in_sight)
/*JP				pline("Kaablamm!  You hear an explosion in the distance!");*/
				pline("ちゅどーん！あなたは遠方の爆発音を聞いた");
			blow_up_landmine(trap);
			if(thitm(0, mtmp, (struct obj *)0, rnd(16)))
				trapkilled = TRUE;
			else {
				/* monsters recursively fall into new pit */
				if (mintrap(mtmp) == 2) trapkilled=TRUE;
			}
			if (unconscious()) {
				multi = -1;
/*JP				nomovemsg="The explosion awakens you!";*/
				nomovemsg="爆発であなたは起きた！";
			}
			break;

		case POLY_TRAP:
		    if (resists_magm(mtmp)) {
			shieldeff(mtmp->mx, mtmp->my);
		    } else if (!resist(mtmp, WAND_CLASS, 0, NOTELL)) {
			(void) newcham(mtmp, (struct permonst *)0);
			if (in_sight) seetrap(trap);
		    }
		    break;

		case ROLLING_BOULDER_TRAP:
		    if (!is_flyer(mptr)) {
		        newsym(mtmp->mx,mtmp->my);
			if (in_sight)
/*JP
			  pline("Click! %s triggers %s.", Monnam(mtmp),
				  trap->tseen ?
				  "a rolling boulder trap" :
				  something);
*/
			  pline("カチッ！%sは%sのスイッチを踏んだ！", Monnam(mtmp),
				  trap->tseen ?
				  "落岩の罠" : "何か");
			if (launch_obj(BOULDER, trap->launch.x, trap->launch.y,
				       trap->launch2.x, trap->launch2.y, ROLL)) {
			  if (in_sight) trap->tseen = TRUE;
/*JP
			  else You_hear(Hallucination ?
					"someone bowling." :
					"rumbling in the distance.");
*/
			  else You_hear(Hallucination ?
					"誰かがボーリングをしている音を聞いた" :
					"遠くのゴロゴロという音を聞いた");
			  if (mtmp->mhp <= 0) trapkilled = TRUE;
			} else {
			  deltrap(trap);
			  newsym(mtmp->mx,mtmp->my);
			}
		      }
		    break;

		default:
			impossible("Some monster encountered a strange trap of type %d.", tt);
	    }
	}
	if(trapkilled) return 2;
	return mtmp->mtrapped;
}

#endif /* OVL1 */
#ifdef OVLB

/* Combine cockatrice checks into single functions to avoid repeating code. */
void
instapetrify(str)
const char *str;
{
	if (resists_ston(&youmonst)) return;
	if (poly_when_stoned(uasmon) && polymon(PM_STONE_GOLEM))
	    return;
/*JP	You("turn to stone...");*/
	You("石化した．．．");
	killer_format = KILLED_BY;
	killer = str;
	done(STONING);
}

void
minstapetrify(mon,byplayer)
struct monst *mon;
boolean byplayer;
{
	if (resists_ston(mon)) return;
	if (cansee(mon->mx, mon->my))
/*JP		pline("%s turns to stone.", Monnam(mon));*/
		pline("%sは石化した．", Monnam(mon));
	if (poly_when_stoned(mon->data)) {
		mon_to_stone(mon);
		return;
	}
	if (byplayer) {
		stoned = TRUE;
		xkilled(mon,0);
	} else monstone(mon);
}

void
selftouch(arg)
const char *arg;
{
	if (uwep && uwep->otyp == CORPSE && uwep->corpsenm == PM_COCKATRICE) {
/*JP		pline("%s touch the cockatrice corpse.", arg);*/
		pline("%sコカトリスの死体に触った．",arg);
/*JP		instapetrify("cockatrice corpse");*/
		instapetrify("コカトリスの死体に触れて");
	}
}

void
mselftouch(mon,arg,byplayer)
struct monst *mon;
const char *arg;
boolean byplayer;
{
	struct obj *mwep = MON_WEP(mon);

	if (mwep && mwep->otyp == CORPSE && mwep->corpsenm == PM_COCKATRICE) {
		if (cansee(mon->mx, mon->my)) {
/*JP			pline("%s%s touches the cockatrice corpse.",
			    arg ? arg : "", arg ? mon_nam(mon) : Monnam(mon));*/
			pline("%s%sはコカトリスの死体に触った．",
			    arg ? arg : "", mon_nam(mon));
		}
		minstapetrify(mon, byplayer);
	}
}

void
float_up()
{
	if(u.utrap) {
		if(u.utraptype == TT_PIT) {
			u.utrap = 0;
/*JP			You("float up, out of the pit!");*/
			You("落し穴から浮き出た！");
			vision_full_recalc = 1;	/* vision limits change */
			fill_pit(u.ux, u.uy);
		} else if (u.utraptype == TT_INFLOOR) {
/*JP			Your("body pulls upward, but your %s are still stuck.",*/
			Your("体は引き上げられた．しかし%sはまだはまっている．",
			     makeplural(body_part(LEG)));
		} else {
/*JP			You("float up, only your %s is still stuck.",*/
			You("浮き出た．%sだけがはまっている",
				body_part(LEG));
		}
	}
	else if(Is_waterlevel(&u.uz))
/*JP		pline("It feels as though you'd lost some weight.");*/
		You("まるで体重が減ったように感じた．");
	else if(u.uinwater)
		spoteffects();
	else if(u.uswallow)
/*JP		You(is_animal(u.ustuck->data) ?
			"float away from the %s."  :
			"spiral up into %s.",
		    is_animal(u.ustuck->data) ?
			surface(u.ux, u.uy) :
			mon_nam(u.ustuck));*/
		You(is_animal(u.ustuck->data) ?
			"%sの中で浮いた．" :
			"%sの中でぐるぐる回転した．",
		    is_animal(u.ustuck->data) ?
			surface(u.ux, u.uy) :
			mon_nam(u.ustuck));
	else if (Hallucination)
/*JP		pline("Up, up, and awaaaay!  You're walking on air!");*/
		pline("上れ，上れ，上れぇぇぇぇ！あなたは空中を歩いている！");
	else if(Is_airlevel(&u.uz))
/*JP		You("gain control over your movements.");*/
		You("うまく歩けるようになった．");
	else
/*JP		You("start to float in the air!");*/
		You("空中に浮きはじめた！");
}

void
fill_pit(x, y)
int x, y;
{
	struct obj *otmp;
	struct trap *t;

	if ((t = t_at(x, y)) &&
	    ((t->ttyp == PIT) || (t->ttyp == SPIKED_PIT)) &&
	    (otmp = sobj_at(BOULDER, x, y))) {
		obj_extract_self(otmp);
/*JP		(void) flooreffects(otmp, x, y, "settle");*/
		(void) flooreffects(otmp, x, y, "はまった");
	}
}

int
float_down(override_mask)
long override_mask;	/* might cancel timeout */
{
	register struct trap *trap = (struct trap *)0;
	d_level current_dungeon_level;
	boolean no_msg = FALSE;

	HLevitation &= ~override_mask;
	if(Levitation) return(0); /* maybe another ring/potion/boots */

	if (Punished && !carried(uball) &&
	    (is_pool(uball->ox, uball->oy) ||
	     ((trap = t_at(uball->ox, uball->oy)) &&
	      ((trap->ttyp == PIT) || (trap->ttyp == SPIKED_PIT) ||
	       (trap->ttyp == TRAPDOOR) || (trap->ttyp == HOLE))))) {
			u.ux0 = u.ux;
			u.uy0 = u.uy;
			u.ux = uball->ox;
			u.uy = uball->oy;
			movobj(uchain, uball->ox, uball->oy);
			newsym(u.ux0, u.uy0);
			vision_full_recalc = 1;	/* in case the hero moved. */
	}
	/* check for falling into pool - added by GAN 10/20/86 */
	if(!is_flyer(uasmon)) {
		/* kludge alert:
		 * drown() and lava_effects() print various messages almost
		 * every time they're called which conflict with the "fall
		 * into" message below.  Thus, we want to avoid printing
		 * confusing, duplicate or out-of-order messages.
		 * Use knowledge of the two routines as a hack -- this
		 * should really handled differently -dlc
		 */
		if(is_pool(u.ux,u.uy) && !Wwalking && !u.uinwater)
			no_msg = drown();

		if(is_lava(u.ux,u.uy)) {
			(void) lava_effects();
			no_msg = TRUE;
		}
	}
	if (!trap) {
		if(Is_airlevel(&u.uz))
/*JP			You("begin to tumble in place.");*/
			You("その場で転落しはじめた．");
		else if (Is_waterlevel(&u.uz) && !no_msg)
/*JP			You_feel("heavier.");*/
			You("重くなったような気がした．");
		/* u.uinwater msgs already in spoteffects()/drown() */
		else if (!u.uinwater && !no_msg) {
			if (Hallucination)
/*JP				pline("Bummer!  You've %s.",
				      is_pool(u.ux,u.uy) ?
					"splashed down" : "hit the ground");*/
				pline("やめてぇ！あなたは%s．",
				      is_pool(u.ux,u.uy) ?
					"ザブンと落ちた" : "地面にたたきつけられた");
			else
/*JP				You("float gently to the %s.",*/
				You("静かに%sまで辿りついた．",
				    surface(u.ux, u.uy));
		}
		trap = t_at(u.ux,u.uy);
	}

	/* can't rely on u.uz0 for detecting trap door-induced level change;
	   it gets changed to reflect the new level before we can check it */
	assign_level(&current_dungeon_level, &u.uz);

	if(trap)
		switch(trap->ttyp) {
		case STATUE_TRAP:
			break;
		case HOLE:
		case TRAPDOOR:
			if(!Can_fall_thru(&u.uz) || u.ustuck)
				break;
			/* fall into next case */
		default:
			dotrap(trap);
	}

	if (!Is_airlevel(&u.uz) && !Is_waterlevel(&u.uz) && !u.uswallow &&
		/* falling through trap door calls goto_level,
		   and goto_level does its own pickup() call */
		on_level(&u.uz, &current_dungeon_level))
	    pickup(1);
	return 1;
}

STATIC_OVL void
dofiretrap(box)
struct obj *box;	/* null for floor trap */
{
	boolean see_it = !Blind;
	int num;

/* Bug: for box case, the equivalent of burn_floor_paper() ought
 * to be done upon its contents.
 */

	if ((box && !carried(box)) ? is_pool(box->ox, box->oy) : Underwater) {
/*JP	    pline("A cascade of steamy bubbles erupts from %s!",
		    the(box ? xname(box) : surface(u.ux,u.uy)));*/
	    pline("蒸気の泡が%sからしゅーっと発生した！",
		    box ? xname(box) : surface(u.ux,u.uy));
/*JP	    if (Fire_resistance) You("are uninjured.");*/
	    if (Fire_resistance) You("傷つかない．");
/*JP	    else losehp(rnd(3), "boiling water", KILLED_BY);*/
	    else losehp(rnd(3), "沸騰した水で", KILLED_BY);
	    return;
	}
/*JP	pline("A %s %s from %s!", tower_of_flame,
	      box ? "bursts" : "erupts",
	      the(box ? xname(box) : surface(u.ux,u.uy)));*/
	pline("火柱が%sから%s！",
	      box ? xname(box) : surface(u.ux,u.uy),
	      box ? "吹き出した" : "立ちのぼった");
	if (Fire_resistance) {
	    shieldeff(u.ux, u.uy);
	    num = rn2(2);
	} else {
	    num = d(2,4);
	    if (u.uhpmax > u.ulevel)
		u.uhpmax -= rn2(min(u.uhpmax,num + 1)), flags.botl = 1;
	}
	if (!num)
/*JP	    You("are uninjured.");*/
	    You("傷つかない．");
	else
	    losehp(num, "火柱で", KILLED_BY_AN);

	if (burnarmor() || rn2(3)) {
	    destroy_item(SCROLL_CLASS, AD_FIRE);
	    destroy_item(SPBOOK_CLASS, AD_FIRE);
	    destroy_item(POTION_CLASS, AD_FIRE);
	}
	if (!box && burn_floor_paper(u.ux, u.uy, see_it) && !see_it)
/*JP	    You("smell paper burning.");*/
	    You("紙のこげる匂いがした．");
	if (is_ice(u.ux, u.uy))
	    melt_ice(u.ux, u.uy);
}

STATIC_OVL void
domagictrap()
{
	register int fate = rnd(20);

	/* What happened to the poor sucker? */

	if (fate < 10) {
	  /* Most of the time, it creates some monsters. */
	  register int cnt = rnd(4);

	  if (!resists_blnd(&youmonst)) {
/*JP		You("are momentarily blinded by a flash of light!");*/
		You("まばゆい光で一瞬目がくらんだ！");
		make_blinded((long)rn1(5,10),FALSE);
	  } else if (!Blind) {
/*JP		You("see a flash of light!");*/
		You("まばゆい光を浴びた！");
	  }  else
/*JP		You_hear("a deafening roar!");*/
		You_hear("耳をつんざくような咆哮を聞いた！");
	  while(cnt--)
		(void) makemon((struct permonst *) 0, u.ux, u.uy, NO_MM_FLAGS);
	}
	else
	  switch (fate) {

	     case 10:
	     case 11:
		      /* sometimes nothing happens */
			break;
	     case 12: /* a flash of fire */
			dofiretrap((struct obj *)0);
			break;

	     /* odd feelings */
/*JP	     case 13:	pline("A shiver runs up and down your %s!",*/
	     case 13:	pline("震えがあなたの%sを走った！",
			      body_part(SPINE));
			break;
/*JP	     case 14:	You_hear(Hallucination ?
				"the moon howling at you." :
				"distant howling.");*/
	     case 14:	You_hear(Hallucination ?
				"ふにゃ？月が吠えている．" :
				"遠方の遠吠を聞いた．");
			break;
	     case 15:	if (on_level(&u.uz, &qstart_level))
/*JP			    You_feel("%slike the prodigal son.",
			      (flags.female || (Upolyd && is_neuter(uasmon))) ?
				     "oddly " : "");*/
			    You_feel("%s悔い改めた罪人を好きになったような気がした．",
			      (flags.female || (Upolyd && is_neuter(uasmon))) ?
				     "異常に" : "");
			else
/*JP			    You("suddenly yearn for %s.",
				Hallucination ? "Cleveland" :
			    (In_quest(&u.uz) || at_dgn_entrance("The Quest")) ?
						"your nearby homeland" :
						"your distant homeland");*/
			    You("突然%sが恋しくなった．",
				Hallucination ? "青森" :
			    (In_quest(&u.uz) || at_dgn_entrance("The Quest")) ?
						"すぐそこにある故郷" :
						"はるかかなたの故郷");

			break;
/*JP	     case 16:   Your("pack shakes violently!");*/
	     case 16:   Your("袋は激しく揺れた！");
			break;
	     case 17:	You(Hallucination ?
/*JP				"smell hamburgers." :
				"smell charred flesh.");*/
				"ハンバーガーの匂いがした．" :
				"黒焦げの肉の匂いがした．");
			break;
/*JP	     case 18:	You_feel("tired.");*/
	     case 18:	You("疲れを感じた．");
			break;

	     /* very occasionally something nice happens. */

	     case 19:
		    /* tame nearby monsters */
		   {   register int i,j;
		       register struct monst *mtmp;

		       (void) adjattrib(A_CHA,1,FALSE);
		       for(i = -1; i <= 1; i++) for(j = -1; j <= 1; j++) {
			   if(!isok(u.ux+i, u.uy+j)) continue;
			   mtmp = m_at(u.ux+i, u.uy+j);
			   if(mtmp)
			       (void) tamedog(mtmp, (struct obj *)0);
		       }
		       break;
		   }

	     case 20:
		    /* uncurse stuff */
		   {  register struct obj *obj;

			/* below plines added by GAN 10/30/86 */
/*JP			You_feel(Hallucination ?
				"in touch with the Universal Oneness." :
				"like someone is helping you.");*/
			You(Hallucination ?
				"宇宙原理の調和に触れているような気がした．":
				"誰かがあなたを助けてくれているような気がした．");
			for(obj = invent; obj ; obj = obj->nobj)
			       if(obj->owornmask || obj->otyp == LOADSTONE)
					uncurse(obj);
		       if(Punished) unpunish();
		       break;
		   }
	     default: break;
	  }
}

void
water_damage(obj, force, here)
register struct obj *obj;
register boolean force, here;
{
	/* Scrolls, spellbooks, potions, weapons and
	   pieces of armor may get affected by the water */
	for (; obj; obj = (here ? obj->nexthere : obj->nobj)) {

		(void) snuff_lit(obj);

		if(obj->greased) {
			if (force || !rn2(2)) obj->greased = 0;
		} else if(Is_container(obj) && !Is_box(obj) &&
			(obj->otyp != OILSKIN_SACK || (obj->cursed && !rn2(3)))) {
			water_damage(obj->cobj, force, FALSE);
		} else if (!force && (Luck + 5) > rn2(20)) {
			/*  chance per item of sustaining damage:
			 *	max luck (full moon):	 5%
			 *	max luck (elsewhen):	10%
			 *	avg luck (Luck==0):	75%
			 *	awful luck (Luck<-4):  100%
			 */
			continue;
		} else if (obj->oclass == SCROLL_CLASS) {
#ifdef MAIL
		    if (obj->otyp != SCR_MAIL)
#endif
			obj->otyp = SCR_BLANK_PAPER;
			obj->spe = 0;
		} else if (obj->oclass == SPBOOK_CLASS) {
			if (obj->otyp == SPE_BOOK_OF_THE_DEAD)
/*JP				pline("Steam rises from %s.", the(xname(obj)));*/
				pline("蒸気が%sから立ちのぼった．", the(xname(obj)));
			else obj->otyp = SPE_BLANK_PAPER;
		} else if (obj->oclass == POTION_CLASS) {
			if (obj->odiluted) {
				obj->otyp = POT_WATER;
				obj->blessed = obj->cursed = 0;
				obj->odiluted = 0;
			} else if (obj->otyp != POT_WATER)
				obj->odiluted++;
		} else if (is_rustprone(obj) && obj->oeroded < MAX_ERODE &&
			  !(obj->oerodeproof || (obj->blessed && !rnl(4)))) {
			/* all metal stuff and armor except (body armor
			   protected by oilskin cloak) */
			if(obj->oclass != ARMOR_CLASS || obj != uarm ||
			   !uarmc || uarmc->otyp != OILSKIN_CLOAK ||
			   (uarmc->cursed && !rn2(3)))
				obj->oeroded++;
		}
	}
}

/*
 * This function is potentially expensive - rolling
 * inventory list multiple times.  Luckily it's seldom needed.
 * Returns TRUE if disrobing made player unencumbered enough to
 * crawl out of the current predicament.
 */
STATIC_OVL boolean
emergency_disrobe(lostsome)
boolean *lostsome;
{
	int invc = inv_cnt();

	while (near_capacity() > (Punished ? UNENCUMBERED : SLT_ENCUMBER)) {
		register struct obj *obj, *otmp = (struct obj *)0;
		register int i = rn2(invc);

		for (obj = invent; obj; obj = obj->nobj) {
			/*
			 * Undroppables are: body armor, boots, gloves,
			 * amulets, and rings because of the time and effort
			 * in removing them + loadstone and other cursed stuff
			 * for obvious reasons.
			 */
			if (!((obj->otyp == LOADSTONE && obj->cursed) ||
			      obj == uamul || obj == uleft || obj == uright ||
			      obj == ublindf || obj == uarm || obj == uarmc ||
			      obj == uarmg || obj == uarmf ||
#ifdef TOURIST
			      obj == uarmu ||
#endif
			      (obj->cursed && (obj == uarmh || obj == uarms)) ||
			      welded(obj)))
				otmp = obj;
			/* reached the mark and found some stuff to drop? */
			if (--i < 0 && otmp) break;

			/* else continue */
		}

		/* nothing to drop and still overweight */
		if (!otmp) return(FALSE);

		if (otmp == uarmh) (void) Helmet_off();
		else if (otmp == uarms) (void) Shield_off();
		else if (otmp == uwep) setuwep((struct obj *)0);
		*lostsome = TRUE;
		dropx(otmp);
		invc--;
	}
	return(TRUE);
}

/*
 *  return(TRUE) == player relocated
 */
boolean
drown()
{
	boolean inpool_ok = FALSE, crawl_ok;
	int i, x, y;

	/* happily wading in the same contiguous pool */
	if (u.uinwater && is_pool(u.ux-u.dx,u.uy-u.dy) &&
	    (is_swimmer(uasmon) || Amphibious)) {
		/* water effects on objects every now and then */
		if (!rn2(5)) inpool_ok = TRUE;
		else return(FALSE);
	}

	if (!u.uinwater) {
/*JP	    You("%s into the water%c",
		Is_waterlevel(&u.uz) ? "plunge" : "fall",
		Amphibious ? '.' : '!');*/
	    You("水の中に%s%s",
		Is_waterlevel(&u.uz) ? "飛びこんだ" : "落ちた",
		Amphibious ? "．" : "！");
	    if(!is_swimmer(uasmon))
		if (!Is_waterlevel(&u.uz))
/*JP		    You("sink like %s.",
			Hallucination ? "the Titanic" : "a rock");*/
		    You("%sのように沈んだ．",
			Hallucination ? "タイタニック号" : "岩");
	}

	water_damage(invent, FALSE, FALSE);

	if(u.umonnum == PM_GREMLIN && rn2(3)) {
		struct monst *mtmp;
		if ((mtmp = cloneu()) != 0) {
			mtmp->mhpmax = (u.mhmax /= 2);
/*JP			You("multiply.");*/
			You("分裂した．");
		}
	}
	if (inpool_ok) return(FALSE);

	if ((i = number_leashed()) > 0) {
/*JP		pline_The("leash%s slip%s loose.",
			(i > 1) ? "es" : "",
			(i > 1) ? "" : "s");*/
		pline("紐がゆるんだ");
		unleash_all();
	}

	if (Amphibious || is_swimmer(uasmon)) {
		if (Amphibious) {
			if (flags.verbose)
/*JP				pline("But you aren't drowning.");*/
				pline("しかし，あなたは溺れなかった．");
			if (!Is_waterlevel(&u.uz)){
				if (Hallucination)
/*JP					Your("keel hits the bottom.");*/
					You("底にニードロップを決めた．");
				else
/*JP					You("touch bottom.");*/
					You("底についた．");
			}
		}
		if (Punished) {
			unplacebc();
			placebc();
		}
		vision_recalc(2);	/* unsee old position */
		u.uinwater = 1;
		under_water(1);
		vision_full_recalc = 1;
		return(FALSE);
	}
	if((Teleportation || can_teleport(uasmon)) &&
	   (Teleport_control || rn2(3) < Luck+2)) {
/*JP		You("attempt a teleport spell.");*/	/* utcsri!carroll */
		You("瞬間移動の魔法を唱えようとした．");	/* utcsri!carroll */
		(void) dotele();
		if(!is_pool(u.ux,u.uy))
			return(TRUE);
	}
	crawl_ok = FALSE;
	/* look around for a place to crawl to */
	for (i = 0; i < 100; i++) {
		x = rn1(3,u.ux - 1);
		y = rn1(3,u.uy - 1);
		if (goodpos(x, y, (struct monst *)0, &playermon)
			|| goodpos(x, y, (struct monst *)0, uasmon)) {
			crawl_ok = TRUE;
			goto crawl;
		}
	}
	/* one more scan */
	for (x = u.ux - 1; x <= u.ux + 1; x++)
		for (y = u.uy - 1; y <= u.uy + 1; y++)
			if (goodpos(x, y, (struct monst *)0, &playermon)
				|| goodpos(x, y, (struct monst *)0, uasmon)) {
				crawl_ok = TRUE;
				goto crawl;
			}
crawl:;
	if (crawl_ok) {
		boolean lost = FALSE;
		/* time to do some strip-tease... */
		boolean succ = Is_waterlevel(&u.uz) ? TRUE :
				emergency_disrobe(&lost);

/*JP		You("try to crawl out of the water.");*/
		You("水からはいあがろうとした．");
		if (lost)
/*JP			You("dump some of your gear to lose weight...");*/
			You("体を軽くするためいくつか物を投げすてた．．．");
		if (succ) {
/*JP			pline("Pheew!  That was close.");*/
			pline("ハァハァ！よかった．");
			teleds(x,y);
			return(TRUE);
		}
		/* still too much weight */
/*JP		pline("But in vain.");*/
		pline("が，無駄だった．");
	}
	u.uinwater = 1;
/*JP	You("drown.");*/
	You("溺れた．");
	killer_format = KILLED_BY_AN;
	killer = (levl[u.ux][u.uy].typ == POOL || Is_medusa_level(&u.uz)) ?
/*JP	    "pool of water" : "moat";*/
	    "水たまりで" : "堀で";
	done(DROWNING);
	/* oops, we're still alive.  better get out of the water. */
	while (!safe_teleds()) {
/*JP		pline("You're still drowning.");*/
		You("溺れている．");
		done(DROWNING);
	}
	u.uinwater = 0;
/*JP	You("find yourself back %s.", Is_waterlevel(&u.uz) ?
		"in an air bubble" : "on land");*/
	You("いつのまにか%sにいるのに気がついた．", Is_waterlevel(&u.uz) ?
		"空気の泡の中" : "地面");
	return(TRUE);
}

void
drain_en(n)
register int n;
{
	if (!u.uenmax) return;
/*JP	You_feel("your magical energy drain away!");*/
	You("魔法のエネルギーが吸いとられたような気がした！");
	u.uen -= n;
	if(u.uen < 0)  {
		u.uenmax += u.uen;
		if(u.uenmax < 0) u.uenmax = 0;
		u.uen = 0;
	}
	flags.botl = 1;
}

int
dountrap()	/* disarm a trap */
{
	if (near_capacity() >= HVY_ENCUMBER) {
/*JP	    pline("You're too strained to do that.");*/
	    pline("罠を解除しようにも物を持ちすぎている．");
	    return 0;
	}
	if (nohands(uasmon) || !uasmon->mmove) {
/*JP	    pline("And just how do you expect to do that?");*/
	    pline("いったい何を期待しているんだい？");
	    return 0;
	} else if (u.ustuck && sticks(uasmon)) {
/*JP	    pline("You'll have to let go of %s first.", mon_nam(u.ustuck));*/
	    pline("%sを手離さないことにはできない．", mon_nam(u.ustuck));
	    return 0;
	}
	if (u.ustuck || (welded(uwep) && bimanual(uwep))) {
/*JP	    Your("%s seem to be too busy for that.",
		 makeplural(body_part(HAND)));*/
	    Your("そんなことをする余裕なんてない．");
	    return 0;
	}
	return untrap(FALSE);
}
#endif /* OVLB */
#ifdef OVL2

/* Probability of disabling a trap.  Helge Hafting */
STATIC_OVL int
untrap_prob(ttmp)
struct trap *ttmp;
{
	int chance = 3;

	if (Confusion || Hallucination) chance++;
	if (Blind) chance++;
	if (Stunned) chance += 2;
	if (Fumbling) chance *= 2;
	/* Your own traps are better known than others. */
	if (ttmp && ttmp->madeby_u) chance--;
	if (Role_is('R')) {
	    if (rn2(2 * MAXULEV) < u.ulevel) chance--;
	    if (u.uhave.questart && chance > 1) chance--;
	}
	return rn2(chance);
}

/* Replace trap with object(s).  Helge Hafting */
STATIC_OVL void
cnv_trap_obj(otyp, cnt, ttmp)
int otyp;
int cnt;
struct trap *ttmp;
{
	struct obj *otmp = mksobj(otyp, TRUE, FALSE);
	otmp->quan=cnt;
	otmp->owt = weight(otmp);
	place_object(otmp, ttmp->tx, ttmp->ty);
	/* Sell your own traps only... */
	if (ttmp->madeby_u) sellobj(otmp, ttmp->tx, ttmp->ty);
	stackobj(otmp);
	newsym(ttmp->tx, ttmp->ty);
	deltrap(ttmp);
}

/* while attempting to disarm an adjacent trap, we've fallen into it */
STATIC_OVL void
move_into_trap(ttmp)
struct trap *ttmp;
{
	int bc;
	xchar x = ttmp->tx, y = ttmp->ty, bx, by, cx, cy;
	boolean unused;

	/* we know there's no monster in the way, and we're not trapped */
	if (!Punished || drag_ball(x, y, &bc, &bx, &by, &cx, &cy, &unused)) {
	    u.ux0 = u.ux,  u.uy0 = u.uy;
	    u.ux = x,  u.uy = y;
	    u.umoved = TRUE;
	    newsym(u.ux0, u.uy0);
	    vision_recalc(1);
	    check_leash(u.ux0, u.uy0);
	    if (Punished) move_bc(0, bc, bx, by, cx, cy);
	    spoteffects();	/* dotrap() */
	    exercise(A_WIS, FALSE);
	}
}

/* 0: doesn't even try
 * 1: tries and fails
 * 2: succeeds
 */
STATIC_OVL int
try_disarm(ttmp, force_failure)
struct trap *ttmp;
boolean force_failure;
{
	struct monst *mtmp = m_at(ttmp->tx,ttmp->ty);
	int ttype = ttmp->ttyp;
	boolean under_u = (!u.dx && !u.dy);

	/* Test for monster first, monsters are displayed instead of trap. */
	if (mtmp && (!mtmp->mtrapped || ttype != BEAR_TRAP)) {
/*JP		pline("%s is in the way.", Monnam(mtmp));*/
		pline("そこには%sがいる．", Monnam(mtmp));
		return 0;
	}
	/* We might be forced to move onto the trap's location. */
	if (sobj_at(BOULDER, ttmp->tx, ttmp->ty)
				&& !passes_walls(uasmon) && !under_u) {
/*JP		pline("There is a boulder in your way.");*/
		pline("そこには岩がある．");
		return 0;
	}
	/* untrappable traps are located on the ground. */
	if (!can_reach_floor()) {
/*JP		You("are unable to reach the %s!",*/
		You("%sに届かない！",
			jtrns_obj('^', defsyms[trap_to_defsym(ttype)].explanation));
		return 0;
	}

	/* Will our hero succeed? */
	if (force_failure || untrap_prob(ttmp)) {
		if (rnl(5)) {
/*JP		    pline("Whoops...");*/
		    pline("うわっ．．．");
		    if (mtmp) {		/* must be a bear trap */
			if (mtmp->mtame) abuse_dog(mtmp);
			if ((mtmp->mhp -= rnd(4)) <= 0) killed(mtmp);
		    } else if (under_u) {
			dotrap(ttmp);
		    } else {
			move_into_trap(ttmp);
		    }
		} else {
/*JP		    pline("%s %s is difficult to disarm.",*/
		    pline("%s%sを解除するのは困難だ．",
			  ttmp->madeby_u ? "あなたの仕掛けた" : under_u ? "この" : "その",
			  jtrns_obj('^', defsyms[trap_to_defsym(ttype)].explanation));
		}
		return 1;
	}
	return 2;
}

STATIC_OVL void
reward_untrap(ttmp, mtmp)
struct trap *ttmp;
struct monst *mtmp;
{
	if (!ttmp->madeby_u) {
		if (rnl(10)<8 && !mtmp->mpeaceful &&
						mtmp->data->mlet != S_HUMAN) {
			mtmp->mpeaceful = 1;
/*JP			pline("%s is grateful.", Monnam(mtmp));*/
			pline("%sは喜んでいる．", Monnam(mtmp));
		}
		/* Helping someone out of a trap is a nice thing to do,
		 * A lawful may be rewarded, but not too often.  */
		if (!rn2(3) && !rnl(8) && u.ualign.type == A_LAWFUL) {
			adjalign(1);
/*JP			You_feel("that you did the right thing.");*/
			You("正しいことをしたような気がした．");
		}
	}
}

STATIC_OVL int
disarm_beartrap(ttmp) /* Helge Hafting */
struct trap *ttmp;
{
	struct monst *mtmp;
	int fails = try_disarm(ttmp, FALSE);

	if (fails < 2) return fails;

	/* ok, disarm it. */

	/* untrap the monster, if any.
	   There's no need for a cockatrice test, only the trap is touched */
	if ((mtmp = m_at(ttmp->tx,ttmp->ty)) != 0) {
		mtmp->mtrapped = 0;
/*JP		You("remove %s bear trap from %s.", the_your[ttmp->madeby_u],
			mon_nam(mtmp));*/
		You("%s熊の罠を%sからはずした", set_you[ttmp->madeby_u],
			mon_nam(mtmp));
		reward_untrap(ttmp, mtmp);
/*JP	} else You("disarm %s bear trap.", the_your[ttmp->madeby_u]);*/
	} else You("%s熊の罠をはずした", set_you[ttmp->madeby_u]);
	cnv_trap_obj(BEARTRAP, 1, ttmp);
	return 1;
}

STATIC_OVL int
disarm_landmine(ttmp) /* Helge Hafting */
struct trap *ttmp;
{
	int fails = try_disarm(ttmp, FALSE);

	if (fails < 2) return fails;
/*JP	You("disarm %s land mine.", the_your[ttmp->madeby_u]);*/
	You("%s地雷を解除した．", set_you[ttmp->madeby_u]);
	cnv_trap_obj(LAND_MINE, 1, ttmp);
	return 1;
}

/* getobj will filter down to cans of grease and known potions of oil */
static NEARDATA const char oil[] = { ALL_CLASSES, TOOL_CLASS, POTION_CLASS, 0 };

/* it may not make much sense to use grease on floor boards, but so what? */
STATIC_OVL int
disarm_squeaky_board(ttmp)
struct trap *ttmp;
{
	struct obj *obj;
	boolean bad_tool;
	int fails;

/*JP	obj = getobj(oil, "untrap with");*/
	obj = getobj(oil, "使って解除する");
	if (!obj) return 0;

	bad_tool = (obj->cursed ||
			((obj->otyp != POT_OIL || obj->lamplit) &&
			 (obj->otyp != CAN_OF_GREASE || !obj->spe)));

	fails = try_disarm(ttmp, bad_tool);
	if (fails < 2) return fails;

	/* successfully used oil or grease to fix squeaky board */
	if (obj->otyp == CAN_OF_GREASE) {
	    check_unpaid(obj);
	    obj->spe--;
	} else {
	    useup(obj);	/* oil */
	    makeknown(POT_OIL);
	}
/*JP	You("repair the squeaky board.");*/	/* no madeby_u */
	You("きしむ板を修理した．");	/* no madeby_u */
	deltrap(ttmp);
	newsym(u.ux + u.dx, u.uy + u.dy);
	more_experienced(1, 5);
	return 1;
}

/* removes traps that shoot arrows, darts, etc. */
STATIC_OVL int
disarm_shooting_trap(ttmp, otyp)
struct trap *ttmp;
int otyp;
{
	int fails = try_disarm(ttmp, FALSE);

	if (fails < 2) return fails;
/*JP	You("disarm %s trap.", the_your[ttmp->madeby_u]);*/
	pline("%s罠を解除した．", set_you[ttmp->madeby_u]);
	cnv_trap_obj(otyp, 50-rnl(50), ttmp);
	return 1;
}

/* Is the weight too heavy?
 * Formula as in near_capacity() & check_capacity() */
STATIC_OVL int
try_lift(mtmp, ttmp, wt, stuff)
struct monst *mtmp;
struct trap *ttmp;
int wt;
boolean stuff;
{
	int wc = weight_cap();

	if ((((wt<<1) / wc)+1) >= EXT_ENCUMBER) {
/*JP		pline("%s is %s for you to lift.", Monnam(mtmp),
			stuff ? "carrying too much" : "too heavy");*/
		pline("%sは%s持ちあげることができない．", Monnam(mtmp),
		  stuff ? "物を持ちすぎており" : "重すぎて");
		if (!ttmp->madeby_u && !mtmp->mpeaceful
			&& mtmp->data->mlet != S_HUMAN && rnl(10) < 3) {
		    mtmp->mpeaceful = 1;
/*JP		    pline("%s thinks it was nice of you to try.", Monnam(mtmp));*/
		    pline("%sはあなたの努力に感謝しているようだ．", Monnam(mtmp));
		}
		return 0;
	}
	return 1;
}

/* Help trapped monster (out of a (spiked) pit) */
STATIC_OVL int
help_monster_out(mtmp, ttmp)
struct monst *mtmp;
struct trap *ttmp;
{
	int wt;
	struct obj *otmp;

	/*
	 * This works when levitating too -- consistent with the ability
	 * to hit monsters while levitating.
	 *
	 * Should perhaps check that our hero has arms/hands at the
	 * moment.  Helping can also be done by engulfing...
	 *
	 * Test the monster first - monsters are displayed before traps.
	 */
	if (!mtmp->mtrapped) {
/*JP		pline("%s isn't trapped.", Monnam(mtmp));*/
		pline("%sは罠にかかっていない．", Monnam(mtmp));
		return 0;
	}
	/* Do you have the necessary capacity to lift anything? */
	if (check_capacity((char *)0)) return 1;

	/* Will our hero succeed? */
	if (untrap_prob(ttmp)) {
/*JP		You("try to reach out your %s, but %s backs away skeptically.",
			makeplural(body_part(ARM)),
			mon_nam(mtmp));*/
		You("%sを差し延べようとしたが%sは警戒している．",
			makeplural(body_part(ARM)),
			mon_nam(mtmp));
		return 1;
	}


	/* is it a cockatrice?... */
	if (mtmp->data == &mons[PM_COCKATRICE] && !uarmg
		    && !resists_ston(&youmonst)) {
/*JP
		You("grab the trapped cockatrice using your bare %s.",
*/
		You("罠にかかっているコカトリスを素%sで掴んでしまった．",
			makeplural(body_part(HAND)));

		if (poly_when_stoned(uasmon) && polymon(PM_STONE_GOLEM))
			display_nhwindow(WIN_MESSAGE, FALSE);
		else {
/*JP
		      instapetrify("trying to help a cockatrice out of a pit");
*/
		      instapetrify("罠にかかっているコカトリスを助けようとして");
			return 1;
		}
	}
/*JP
	You("reach out your %s and grab %s.",
	    makeplural(body_part(ARM)), mon_nam(mtmp));
*/
	You("%sに%sを差し延べた．",
	    mon_nam(mtmp), makeplural(body_part(ARM))); 

	/* is the monster too heavy? */
	wt = inv_weight() + mtmp->data->cwt;
	if (!try_lift(mtmp, ttmp, wt, FALSE)) return 1;

	/* is the monster with inventory too heavy? */
	for (otmp = mtmp->minvent; otmp; otmp = otmp->nobj)
		wt += otmp->owt;
	if (!try_lift(mtmp, ttmp, wt, TRUE)) return 1;

/*JP	You("pull %s out of the pit.", mon_nam(mtmp));*/
	You("%sを落し穴からひっぱった．", mon_nam(mtmp));
	mtmp->mtrapped = 0;
	fill_pit(mtmp->mx, mtmp->my);
	reward_untrap(ttmp, mtmp);
	return 1;
}

int
untrap(force)
boolean force;
{
	register struct obj *otmp;
	register boolean confused = (Confusion > 0 || Hallucination > 0);
	register int x,y;
	int ch;
	struct trap *ttmp;
	struct monst *mtmp;
	boolean trap_skipped = FALSE;

	if(!getdir((char *)0)) return(0);
	x = u.ux + u.dx;
	y = u.uy + u.dy;

	if ((ttmp = t_at(x,y)) && ttmp->tseen) {
		if (u.utrap) {
/*JP			You("cannot deal with traps while trapped!");*/
			pline("罠にかかっている間は罠を解除できない！");
			return 1;
		}
		switch(ttmp->ttyp) {
			case BEAR_TRAP:
				return disarm_beartrap(ttmp);
			case LANDMINE:
				return disarm_landmine(ttmp);
			case SQKY_BOARD:
				return disarm_squeaky_board(ttmp);
			case DART_TRAP:
				return disarm_shooting_trap(ttmp, DART);
			case ARROW_TRAP:
				return disarm_shooting_trap(ttmp, ARROW);
			case PIT:
			case SPIKED_PIT:
				if (!u.dx && !u.dy) {
/*JP				    You("are already on the edge of the pit.");*/
				    You("もう落し穴の端にいる．");
				    return 0;
				}
				if (!(mtmp = m_at(x,y))) {
/*JP				    pline("Try filling the pit instead.");*/
				    pline("なんとか埋めることを考えてみたら？");
				    return 0;
				}
				return help_monster_out(mtmp, ttmp);
			default:
/*JP				You("cannot disable %s trap.", (u.dx || u.dy) ? "that" : "this");*/
				pline("%s罠は解除できない．", (u.dx || u.dy) ? "その" : "この");
				return 0;
		} /* end switch */
	} /* end if */

	if(!u.dx && !u.dy) {
	    for(otmp = level.objects[x][y]; otmp; otmp = otmp->nexthere)
		if(Is_box(otmp)) {
/*JP		    pline("There is %s here.", doname(otmp));*/
		    pline("ここには%sがある．", doname(otmp));

/*JP		    switch (ynq("Check for traps?")) {*/
		    switch (ynq("罠を調べますか？")) {
			case 'q': return(0);
			case 'n': continue;
		    }

		    if((otmp->otrapped && (force || (!confused
				&& rn2(MAXULEV + 1 - u.ulevel) < 10)))
		       || (!force && confused && !rn2(3))) {
/*JP			You("find a trap on %s!", the(xname(otmp)));*/
			pline("%sに罠を発見した！", the(xname(otmp)));
			exercise(A_WIS, TRUE);

/*JP			switch (ynq("Disarm it?")) {*/
			switch (ynq("解除しますか？")) {
			    case 'q': return(1);
			    case 'n': trap_skipped = TRUE;  continue;
			}

			if(otmp->otrapped) {
			    exercise(A_DEX, TRUE);
			    ch = ACURR(A_DEX) + u.ulevel;
			    if (Role_is('R')) ch *= 2;
			    if(!force && (confused || Fumbling ||
				rnd(75+level_difficulty()/2) > ch)) {
				(void) chest_trap(otmp, FINGER, TRUE);
			    } else {
/*JP				You("disarm it!");*/
				pline("解除した！");
				otmp->otrapped = 0;
			    }
/*JP			} else pline("That %s was not trapped.", doname(otmp));*/
			} else pline("その%sに罠はない．", doname(otmp));
			return(1);
		    } else {
/*JP			You("find no traps on %s.", the(xname(otmp)));*/
			pline("罠を発見できなかった．");
			return(1);
		    }
		}

/*JP	    You(trap_skipped ? "find no other traps here."
			     : "know of no traps here.");*/
	    You(trap_skipped ? "他の罠を見つけられなかった．"
			     : "ここに罠がないことを知っている．");
	    return(0);
	}

	if ((mtmp = m_at(x,y))				&&
		mtmp->m_ap_type == M_AP_FURNITURE	&&
		(mtmp->mappearance == S_hcdoor ||
			mtmp->mappearance == S_vcdoor)	&&
		!Protection_from_shape_changers)	 {

	    stumble_onto_mimic(mtmp);
	    return(1);
	}

	if (!IS_DOOR(levl[x][y].typ)) {
	    if ((ttmp = t_at(x,y)) && ttmp->tseen)
/*JP		You("cannot disable that trap.");*/
		You("罠を解除できなかった．");
	    else
/*JP		You("know of no traps there.");*/
		You("そこに罠がないことを知っている．");
	    return(0);
	}

	switch (levl[x][y].doormask) {
	    case D_NODOOR:
/*JP		You("%s no door there.", Blind ? "feel" : "see");*/
		pline("そこには扉がない%s．", Blind ? "ようだ" : "ように見える");
		return(0);
	    case D_ISOPEN:
/*JP		pline("This door is safely open.");*/
		pline("その扉は安全に開いている．");
		return(0);
	    case D_BROKEN:
/*JP		pline("This door is broken.");*/
		pline("その扉は壊れている．");
		return(0);
	}

	if ((levl[x][y].doormask & D_TRAPPED
	     && (force ||
		 (!confused && rn2(MAXULEV - u.ulevel + 11) < 10)))
	    || (!force && confused && !rn2(3))) {
/*JP		You("find a trap on the door!");*/
		pline("扉に罠を発見した！");
		exercise(A_WIS, TRUE);
/*JP		if (ynq("Disarm it?") != 'y') return(1);*/
		if (ynq("解除しますか？") != 'y') return(1);
		if (levl[x][y].doormask & D_TRAPPED) {
		    ch = 15 + (Role_is('R') ? u.ulevel*3 : u.ulevel);
		    exercise(A_DEX, TRUE);
		    if(!force && (confused || Fumbling ||
				     rnd(75+level_difficulty()/2) > ch)) {
/*JP			You("set it off!");*/
		        You("スイッチを入れてしまった！");
/*JP			b_trapped("door", FINGER);*/
			b_trapped("扉", FINGER);
			levl[x][y].doormask = D_NODOOR;
			unblock_point(x, y);
			newsym(x, y);
			/* (probably ought to charge for this damage...) */
			if (*in_rooms(x, y, SHOPBASE)) add_damage(x, y, 0L);
		    } else {
/*JP			You("disarm it!");*/
		        You("解除した！");
			levl[x][y].doormask &= ~D_TRAPPED;
		    }
/*JP		} else pline("This door was not trapped.");*/
		} else pline("扉に罠はなかった．");
		return(1);
	} else {
/*JP		You("find no traps on the door.");*/
		pline("扉に罠を発見できなかった．");
		return(1);
	}
}
#endif /* OVL2 */
#ifdef OVLB

/* only called when the player is doing something to the chest directly */
boolean
chest_trap(obj, bodypart, disarm)
register struct obj *obj;
register int bodypart;
boolean disarm;
{
	register struct obj *otmp = obj, *otmp2;
	char	buf[80];
	const char *msg;
	coord cc;

	if (get_obj_location(obj, &cc.x, &cc.y, 0))	/* might be carried */
	    obj->ox = cc.x,  obj->oy = cc.y;

	otmp->otrapped = 0;	/* trap is one-shot; clear flag first in case
				   chest kills you and ends up in bones file */
/*JP
	You(disarm ? "set it off!" : "trigger a trap!");
*/
	You(disarm ? "スイッチを入れてしまった！" : "罠にひっかかった！");
	display_nhwindow(WIN_MESSAGE, FALSE);
	if (Luck > -13 && rn2(13+Luck) > 7) {	/* saved by luck */
	    /* trap went off, but good luck prevents damage */
	    switch (rn2(13)) {
		case 12:
/*JP		case 11:  msg = "explosive charge is a dud";  break;*/
		case 11:  msg = "爆発は不発だった";  break;
		case 10:
/*JP		case  9:  msg = "electric charge is grounded";  break;*/
		case  9:  msg = "電撃が放出されたがアースされていた";  break;
		case  8:
/*JP		case  7:  msg = "flame fizzles out";  break;*/
		case  7:  msg = "炎はシューっと消えた";  break;
		case  6:
		case  5:
/*JP		case  4:  msg = "poisoned needle misses";  break;*/
		case  4:  msg = "毒針は刺さらなかった";  break;
		case  3:
		case  2:
		case  1:
/*JP		case  0:  msg = "gas cloud blows away";  break;*/
		case  0:  msg = "ガス雲は吹き飛んだ";  break;
		default:  impossible("chest disarm bug");  msg = (char *)0;
			  break;
	    }
/*JP
	    if (msg) pline("But luckily the %s!", msg);
*/
	    if (msg) pline("が運のよいことに%s！", msg);
	} else {
	    switch(rn2(20) ? ((Luck >= 13) ? 0 : rn2(13-Luck)) : rn2(26)) {
		case 25:
		case 24:
		case 23:
		case 22:
		case 21: {
			  struct monst *shkp = 0;
			  long loss = 0L;
			  boolean costly, insider;
			  register xchar ox = obj->ox, oy = obj->oy;

			  /* the obj location need not be that of player */
			  costly = (costly_spot(ox, oy) &&
				   (shkp = shop_keeper(*in_rooms(ox, oy,
				    SHOPBASE))) != (struct monst *)0);
			  insider = (*u.ushops && inside_shop(u.ux, u.uy) &&
				    *in_rooms(ox, oy, SHOPBASE) == *u.ushops);

/*JP			  pline("%s explodes!", The(xname(obj)));*/
			  pline("%sは爆発した！", The(xname(obj)));
/*JP			  Sprintf(buf, "exploding %s", xname(obj));*/
			  Sprintf(buf, "%sの爆発で", xname(obj));

			  if(costly)
			      loss += stolen_value(obj, ox, oy,
						(boolean)shkp->mpeaceful, TRUE);
			  delete_contents(obj);
			  for(otmp = level.objects[u.ux][u.uy];
							otmp; otmp = otmp2) {
			      otmp2 = otmp->nexthere;
			      if(costly)
				  loss += stolen_value(otmp, otmp->ox,
					  otmp->oy, (boolean)shkp->mpeaceful,
					  TRUE);
			      delobj(otmp);
			  }
			  wake_nearby();
			  losehp(d(6,6), buf, KILLED_BY_AN);
			  exercise(A_STR, FALSE);
			  if(costly && loss) {
			      if(insider)
/*JP			      You("owe %ld zorkmids for objects destroyed.",
							loss);*/
			      You("器物破損で%ldゴールドの借りをつくった．",
							loss);
			      else {
/*JP				  You("caused %ld zorkmids worth of damage!",*/
				  You("%ldゴールド分の損害を引きおこした！",
							loss);
				  make_angry_shk(shkp, ox, oy);
			      }
			  }
			  return TRUE;
			}
		case 20:
		case 19:
		case 18:
		case 17:
/*JP			pline("A cloud of noxious gas billows from %s.",*/
			pline("有毒ガスが%sから渦まいた．",
							the(xname(obj)));
/*JP			poisoned("gas cloud", A_STR, "cloud of poison gas",15);*/
			poisoned("ガス雲", A_STR, "ガス雲",15);
			exercise(A_CON, FALSE);
			break;
		case 16:
		case 15:
		case 14:
		case 13:
/*JP			You_feel("a needle prick your %s.",body_part(bodypart));*/
			You("%sチクッという痛みを感じた．", body_part(bodypart));
/*JP			poisoned("needle", A_CON, "poisoned needle",10);*/
			poisoned("針", A_CON, "毒針",10);
			exercise(A_CON, FALSE);
			break;
		case 12:
		case 11:
		case 10:
		case 9:
			dofiretrap(obj);
			break;
		case 8:
		case 7:
		case 6: {
			int dmg;

/*JP			You("are jolted by a surge of electricity!");*/
			You("電気ショックをくらった！");
			if(Shock_resistance)  {
			    shieldeff(u.ux, u.uy);
/*JP			    You("don't seem to be affected.");*/
			    pline("しかしあなたは影響を受けない．");
			    dmg = 0;
			} else
			    dmg = d(4, 4);
			destroy_item(RING_CLASS, AD_ELEC);
			destroy_item(WAND_CLASS, AD_ELEC);
/*JP			if (dmg) losehp(dmg, "electric shock", KILLED_BY_AN);*/
			if (dmg) losehp(dmg, "電気ショックで", KILLED_BY_AN);
			break;
		      }
		case 5:
		case 4:
		case 3:
/*JP			pline("Suddenly you are frozen in place!");*/
			pline("突然その場で動けなくなった！");
			nomul(-d(5, 6));
			exercise(A_DEX, FALSE);
/*JP			nomovemsg = You_can_move_again;*/
			nomovemsg = "また動けるようになった．";
			break;
		case 2:
		case 1:
		case 0:
/*JP			pline("A cloud of %s gas billows from %s.",
						hcolor((char *)0),
						the(xname(obj)));*/
			pline("%s光るガス雲が%sの底で渦まいた．",
						jconj_adj(hcolor((char *)0)),
						the(xname(obj)));
			if(!Stunned) {
			    if (Hallucination)
/*JP				pline("What a groovy feeling!");*/
				pline("なんて素敵なんだ！");
			    else if (Blind)
/*JP				You("stagger and get dizzy...");*/
				You("くらくらし，めまいがした．．．");
			    else
/*JP				You("stagger and your vision blurs...");*/
				You("くらくらし，景色がぼやけてきた．．．");
			}
			make_stunned(HStun + rn1(7, 16),FALSE);
			make_hallucinated(HHallucination + rn1(5, 16),FALSE,0L);
			break;
		default: impossible("bad chest trap");
			break;
	    }
	    bot();			/* to get immediate botl re-display */
	}

	return FALSE;
}

#endif /* OVLB */
#ifdef OVL0

struct trap *
t_at(x,y)
register int x, y;
{
	register struct trap *trap = ftrap;
	while(trap) {
		if(trap->tx == x && trap->ty == y) return(trap);
		trap = trap->ntrap;
	}
	return((struct trap *)0);
}

#endif /* OVL0 */
#ifdef OVLB

void
deltrap(trap)
register struct trap *trap;
{
	register struct trap *ttmp;

	if(trap == ftrap)
		ftrap = ftrap->ntrap;
	else {
		for(ttmp = ftrap; ttmp->ntrap != trap; ttmp = ttmp->ntrap) ;
		ttmp->ntrap = trap->ntrap;
	}
	dealloc_trap(trap);
}

boolean delfloortrap(ttmp)
register struct trap *ttmp;
{
	/* Destroy a trap that emanates from the floor. */
	/* some of these are arbitrary -dlc */
	if (ttmp && ((ttmp->ttyp == SQKY_BOARD) ||
		     (ttmp->ttyp == BEAR_TRAP) ||
		     (ttmp->ttyp == LANDMINE) ||
		     (ttmp->ttyp == FIRE_TRAP) ||
		     (ttmp->ttyp == PIT) ||
		     (ttmp->ttyp == SPIKED_PIT) ||
		     (ttmp->ttyp == HOLE) ||
		     (ttmp->ttyp == TRAPDOOR) ||
		     (ttmp->ttyp == TELEP_TRAP) ||
		     (ttmp->ttyp == LEVEL_TELEP) ||
		     (ttmp->ttyp == WEB) ||
		     (ttmp->ttyp == MAGIC_TRAP) ||
		     (ttmp->ttyp == ANTI_MAGIC))) {
	    register struct monst *mtmp;

	    if (ttmp->tx == u.ux && ttmp->ty == u.uy) {
		u.utrap = 0;
		u.utraptype = 0;
	    } else if ((mtmp = m_at(ttmp->tx, ttmp->ty)) != 0) {
		mtmp->mtrapped = 0;
	    }
	    deltrap(ttmp);
	    return TRUE;
	} else
	    return FALSE;
}

/* used for doors (also tins).  can be used for anything else that opens. */
void
b_trapped(item, bodypart)
register const char *item;
register int bodypart;
{
	register int lvl = level_difficulty();
	int dmg = rnd(5 + (lvl < 5 ? lvl : 2+lvl/2));

/*JP	pline("KABOOM!!  %s was booby-trapped!", The(item));*/
	pline("ちゅどーん！！%sにブービートラップが仕掛けられていた！", The(item));
	wake_nearby();
/*JP	losehp(dmg, "explosion", KILLED_BY_AN);*/
	losehp(dmg, "ブービートラップの爆発で", KILLED_BY_AN);
	exercise(A_STR, FALSE);
	if (bodypart) exercise(A_CON, FALSE);
	make_stunned(HStun + dmg, TRUE);
}

/* Monster is hit by trap. */
/* Note: doesn't work if both obj and d_override are null */
STATIC_OVL boolean
thitm(tlev, mon, obj, d_override)
register int tlev;
register struct monst *mon;
register struct obj *obj;
int d_override;
{
	register int strike;
	register boolean trapkilled = FALSE;

	if (d_override) strike = 1;
	else if (obj) strike = (find_mac(mon) + tlev + obj->spe <= rnd(20));
	else strike = (find_mac(mon) + tlev <= rnd(20));

	/* Actually more accurate than thitu, which doesn't take
	 * obj->spe into account.
	 */
	if(!strike) {
		if (cansee(mon->mx, mon->my))
/*JP			pline("%s is almost hit by %s!", Monnam(mon),
								doname(obj));*/
			pline("もう少しで%sが%sに命中するところだった！", doname(obj),
			      Monnam(mon));
	} else {
		int dam = 1;

		if (obj && cansee(mon->mx, mon->my))
/*JP			pline("%s is hit by %s!", Monnam(mon), doname(obj));*/
			pline("%sが%sに命中した！", doname(obj), Monnam(mon));
		if (d_override) dam = d_override;
		else if (obj) {
			dam = dmgval(obj, mon);
			if (dam < 1) dam = 1;
		}
		if ((mon->mhp -= dam) <= 0) {
			int xx = mon->mx;
			int yy = mon->my;

			monkilled(mon, "", AD_PHYS);
			if (mon->mhp <= 0) {
				newsym(xx, yy);
				trapkilled = TRUE;
			}
		}
	}
	if (obj && (!strike || d_override)) {
		place_object(obj, mon->mx, mon->my);
		stackobj(obj);
	} else if (obj) dealloc_obj(obj);

	return trapkilled;
}

boolean
unconscious()
{
/*
**	もう，かんべんしてよー．こんなコーディング．．．
**
**	You regain con  --  eat.c(2), potion.c(1)
**	You are consci  --  eat.c(2)
*/
	return((boolean)(multi < 0 && (!nomovemsg ||
		u.usleep ||
		!strncmp(nomovemsg,"あなたは正気づいた", 18) ||
		!strncmp(nomovemsg,"あなたはまた正気づ", 18) ||
		!strncmp(nomovemsg,"You regain con", 15) ||
		!strncmp(nomovemsg,"You are consci", 15))));
}

/*JPstatic char lava_killer[] = "molten lava";*/
static char lava_killer[] = "どろどろの溶岩で";

boolean
lava_effects()
{
    register struct obj *obj, *obj2;
    int dmg;

    if (likes_lava(uasmon)) return FALSE;

    if (!Fire_resistance) {
	if(Wwalking) {
	    dmg = d(6,6);
/*JP	    pline_The("lava here burns you!");*/
	    pline("溶岩があなたを焼きつくした！");
	    if(dmg < u.uhp) {
		losehp(dmg, lava_killer, KILLED_BY);
		goto burn_stuff;
	    }
	} else
/*JP	    You("fall into the lava!");*/
	    You("溶岩に落ちた！");

	for(obj = invent; obj; obj = obj2) {
	    obj2 = obj->nobj;
	    if(is_organic(obj) && !obj->oerodeproof) {
		if(obj->owornmask) {
		    if(obj == uarm) (void) Armor_gone();
		    else if(obj == uarmc) (void) Cloak_off();
		    else if(obj == uarmh) (void) Helmet_off();
		    else if(obj == uarms) (void) Shield_off();
		    else if(obj == uarmg) (void) Gloves_off();
		    else if(obj == uarmf) (void) Boots_off();
#ifdef TOURIST
		    else if(obj == uarmu) setnotworn(obj);
#endif
		    else if(obj == uleft) Ring_gone(obj);
		    else if(obj == uright) Ring_gone(obj);
		    else if(obj == ublindf) Blindf_off(obj);
		    else if(obj == uwep) uwepgone();
		    if(Lifesaved
#ifdef WIZARD
		       || wizard
#endif
/*JP		       ) Your("%s into flame!", aobjnam(obj, "burst"));*/
		       ) Your("%sは燃えた！", xname(obj));
		}
		useup(obj);
	    }
	}

	/* s/he died... */
	u.uhp = -1;
	killer_format = KILLED_BY;
	killer = lava_killer;
/*JP	You("burn to a crisp...");*/
	You("燃えてパリパリになった．．．");
	done(BURNING);
	while (!safe_teleds()) {
/*JP		pline("You're still burning.");*/
		You("まだ燃えている．");
		done(BURNING);
	}
/*JP	You("find yourself back on solid %s.", surface(u.ux, u.uy));*/
	You("いつのまにか固い%sに戻っていた．", surface(u.ux, u.uy));
	return(TRUE);
    }

    if (!Wwalking) {
	u.utrap = rn1(4, 4) + (rn1(4, 12) << 8);
	u.utraptype = TT_LAVA;
/*JP	You("sink into the lava, but it only burns slightly!");*/
	You("溶岩に沈んだが，ちょっと焦げただけだ！");
	if (u.uhp > 1)
	    losehp(1, lava_killer, KILLED_BY);
    }
    /* just want to burn boots, not all armor; destroy_item doesn't work on
       armor anyway */
burn_stuff:
    if(uarmf && !uarmf->oerodeproof && is_organic(uarmf)) {
	/* save uarmf value because Boots_off() sets uarmf to null */
	obj = uarmf;
/*JP	Your("%s burst into flame!", xname(obj));*/
	Your("%sは燃えた！", xname(obj));
	(void) Boots_off();
	useup(obj);
    }
    destroy_item(SCROLL_CLASS, AD_FIRE);
    destroy_item(SPBOOK_CLASS, AD_FIRE);
    destroy_item(POTION_CLASS, AD_FIRE);
    return(FALSE);
}

#endif /* OVLB */

/*trap.c*/
