rgoue/game/move.go

package game

// move.c — hero movement commands.

// startRun starts the hero running (move.c do_run).
func (g *RogueGame) startRun(ch byte) {
	g.Running = true
	g.After = false
	g.RunCh = ch
}

// moveHero checks that a move is legal and handles the consequences —
// fighting, picking up, etc. (move.c do_move). The C `goto over`
// re-check after a passage turn is the retry loop.
func (g *RogueGame) moveHero(dy, dx int) {
	p := &g.Player

	g.Firstmove = false
	if g.NoMove > 0 {
		g.NoMove--
		g.msg("you are still stuck in the bear trap")

		return
	}
	// Do a confused move (maybe)
	var nh Coord
	if p.On(Confused) && g.rnd(5) != 0 {
		nh = g.randomStep(&p.Creature)
		if nh == p.Pos {
			g.After = false
			g.Running = false
			g.ToDeath = false

			return
		}
	} else {
		nh = Coord{Y: p.Pos.Y + dy, X: p.Pos.X + dx}
	}

	for {
		ch, fl, stop := g.moveTarget(nh)
		if stop {
			return
		}

		turned, ndy, ndx := g.moveResolve(nh, ch, fl, dy, dx)
		if !turned {
			return
		}

		// the C goto over: re-check the turned move
		dy, dx = ndy, ndx

		g.turnRefresh()

		nh = Coord{Y: p.Pos.Y + dy, X: p.Pos.X + dx}
	}
}

// moveResolve acts on the square the hero stepped at: a wall may turn a
// passage runner (reported with the new deltas); anything else completes
// or refuses the move (the switch of move.c do_move).
func (g *RogueGame) moveResolve(nh Coord, ch byte, fl PlaceFlags, dy, dx int) (bool, int, int) {
	switch ch {
	case ' ', '|', '-':
		if turn, ndy, ndx := g.passageTurn(dy, dx); turn {
			return true, ndy, ndx
		}

		g.Running = false
		g.After = false
	default:
		g.moveEnter(nh, fl, ch)
	}

	return false, 0, 0
}

// moveEnter completes a step onto a walkable square: doors, traps,
// passages, floor, and things (the entry arms of the move.c do_move
// switch).
func (g *RogueGame) moveEnter(nh Coord, fl PlaceFlags, ch byte) {
	p := &g.Player

	switch ch {
	case Door:
		g.Running = false
		if g.Level.FlagsAt(p.Pos.Y, p.Pos.X).Has(FPassage) {
			g.enterRoom(nh)
		}
	case Trap:
		tr := g.springTrap(nh)
		if tr == TrapDoor || tr == TrapTeleport {
			return
		}
	case Passage:
		// when you're in a corridor, you don't know if you're in a maze
		// room or not, and there ain't no way to find out if you're
		// leaving a maze room, so it is necessary to always recalculate
		// proom.
		p.Room = g.roomIn(p.Pos)
	case Floor:
		if !fl.Has(FReal) {
			g.springTrap(p.Pos)
		}
	default:
		g.moveOnto(nh, fl, ch)

		return
	}

	g.finishMove(nh, fl)
}

// offMap reports coordinates outside the walkable map (move.c do_move).
func offMap(nh Coord) bool {
	return nh.X < 0 || nh.X >= NumCols || nh.Y <= 0 || nh.Y >= NumLines-1
}

// moveTarget inspects the square the hero is stepping onto: bounds and
// diagonal legality, hidden traps underfoot, and being held. stop means
// the move is refused (the checks of move.c do_move).
func (g *RogueGame) moveTarget(nh Coord) (byte, PlaceFlags, bool) {
	p := &g.Player

	// Check if he tried to move off the screen or make an illegal
	// diagonal move, and stop him if he did.
	if offMap(nh) {
		return ' ', 0, false // fall into the wall case
	}

	if !g.diagOk(p.Pos, nh) {
		g.After = false
		g.Running = false

		return 0, 0, true
	}

	if g.Running && p.Pos == nh {
		g.After = false
		g.Running = false
	}

	fl := *g.Level.FlagsAt(nh.Y, nh.X)

	ch := g.Level.VisibleChar(nh.Y, nh.X)
	if !fl.Has(FReal) && ch == Floor {
		if !p.On(Levitating) {
			ch = Trap
			g.Level.SetChar(nh.Y, nh.X, Trap)
			g.Level.FlagsAt(nh.Y, nh.X).Set(FReal)
		}
	} else if p.On(Held) && ch != 'F' {
		g.msg("you are being held")

		return 0, 0, true
	}

	return ch, fl, false
}

// moveOnto handles stepping at a monster or onto an item (the default
// arm of the move.c do_move switch).
func (g *RogueGame) moveOnto(nh Coord, fl PlaceFlags, ch byte) {
	p := &g.Player
	if ch == Stairs {
		g.SeenStairs = true
	}

	g.Running = false
	if isUpper(ch) || g.Level.MonsterAt(nh.Y, nh.X) != nil {
		g.fight(nh, p.CurWeapon, false)
	} else {
		if ch != Stairs {
			g.Take = ch
		}

		g.finishMove(nh, fl)
	}
}

// passageTurn checks whether a runner in a gone-room passage should turn
// the corner instead of stopping at a wall (the PASSGO block of move.c
// do_move). It reports whether to turn and the new deltas, updating RunCh.
func (g *RogueGame) passageTurn(dy, dx int) (bool, int, int) {
	p := &g.Player
	if !g.Options.PassGo || !g.Running || !p.Room.Flags.Has(Gone) ||
		p.On(Blind) {
		return false, dy, dx
	}

	switch g.RunCh {
	case 'h', 'l':
		if turn, ndy := g.passageTurnVertical(); turn {
			return true, ndy, 0
		}
	case 'j', 'k':
		if turn, ndx := g.passageTurnHorizontal(); turn {
			return true, 0, ndx
		}
	}

	return false, dy, dx
}

// passageTurnVertical decides whether a horizontal runner turns up or
// down at a corner (move.c do_move).
func (g *RogueGame) passageTurnVertical() (bool, int) {
	p := &g.Player

	b1 := p.Pos.Y != 1 && g.turnOk(p.Pos.Y-1, p.Pos.X)

	b2 := p.Pos.Y != NumLines-2 && g.turnOk(p.Pos.Y+1, p.Pos.X)
	if b1 == b2 {
		return false, 0
	}

	if b1 {
		g.RunCh = 'k'

		return true, -1
	}

	g.RunCh = 'j'

	return true, 1
}

// passageTurnHorizontal decides whether a vertical runner turns left or
// right at a corner (move.c do_move).
func (g *RogueGame) passageTurnHorizontal() (bool, int) {
	p := &g.Player

	b1 := p.Pos.X != 0 && g.turnOk(p.Pos.Y, p.Pos.X-1)

	b2 := p.Pos.X != NumCols-1 && g.turnOk(p.Pos.Y, p.Pos.X+1)
	if b1 == b2 {
		return false, 0
	}

	if b1 {
		g.RunCh = 'h'

		return true, -1
	}

	g.RunCh = 'l'

	return true, 1
}

// finishMove is the move_stuff label in do_move: complete the step.
func (g *RogueGame) finishMove(nh Coord, fl PlaceFlags) {
	p := &g.Player
	g.mvaddch(p.Pos.Y, p.Pos.X, g.floorAt())

	if fl.Has(FPassage) && g.Level.Char(g.Oldpos.Y, g.Oldpos.X) == Door {
		g.leaveRoom(nh)
	}

	p.Pos = nh
}

// turnOk decides whether it is legal to turn onto the given space
// (move.c turn_ok).
func (g *RogueGame) turnOk(y, x int) bool {
	pp := g.Level.At(y, x)

	return pp.Ch == Door || pp.Flags&(FReal|FPassage) == (FReal|FPassage)
}

// turnRefresh decides whether to refresh at a passage turning (move.c
// turnref).
func (g *RogueGame) turnRefresh() {
	p := &g.Player

	pp := g.Level.At(p.Pos.Y, p.Pos.X)
	if !pp.Flags.Has(FSeen) {
		if g.Options.Jump {
			g.refresh()
		}

		pp.Flags.Set(FSeen)
	}
}

// doorOpen is called to wake up things in a room that might move when the
// hero enters (move.c door_open).
func (g *RogueGame) doorOpen(rp *Room) {
	if rp.Flags.Has(Gone) {
		return
	}

	for y := rp.Pos.Y; y < rp.Pos.Y+rp.Max.Y; y++ {
		for x := rp.Pos.X; x < rp.Pos.X+rp.Max.X; x++ {
			if isUpper(g.Level.VisibleChar(y, x)) {
				g.wakeMonster(y, x)
			}
		}
	}
}

// springTrap makes him pay for stepping on a trap (move.c be_trapped).
func (g *RogueGame) springTrap(tc Coord) TrapKind {
	p := &g.Player
	if p.On(Levitating) {
		return TrapRust // anything that's not a door or teleport
	}

	g.Running = false
	g.Count = 0
	pp := g.Level.At(tc.Y, tc.X)
	pp.Ch = Trap
	tr := TrapKind(pp.Flags & FTrapMask)
	pp.Flags.Set(FSeen)

	if h := g.data.trapHandlers[tr]; h != nil {
		h(g, tc)
	}

	g.flushType()

	return tr
}

// The per-trap effect handlers, dispatched through
// gameData.trapHandlers. Each is one case of the C be_trapped switch.

func (g *RogueGame) trapFall(Coord) {
	g.Depth++
	g.NewLevel()
	g.msg("you fell into a trap!")
}

func (g *RogueGame) trapBear(Coord) {
	g.NoMove += g.spread(3) // BEARTIME
	g.msg("you are caught in a bear trap")
}

func (g *RogueGame) trapMystery(Coord) {
	which := g.rnd(11)
	switch which {
	case 0:
		g.msg("you are suddenly in a parallel dimension")
	case 1:
		g.msg("the light in here suddenly seems %s", g.data.rainbow[g.rnd(len(g.data.rainbow))])
	case 2:
		g.msg("you feel a sting in the side of your neck")
	case 3:
		g.msg("multi-colored lines swirl around you, then fade")
	case 4:
		g.msg("a %s light flashes in your eyes", g.data.rainbow[g.rnd(len(g.data.rainbow))])
	case 5:
		g.msg("a spike shoots past your ear!")
	default:
		g.trapMysteryMore(which)
	}
}

// trapMysteryMore holds the back half of the mystery-trap messages.
func (g *RogueGame) trapMysteryMore(which int) {
	switch which {
	case 6:
		g.msg("%s sparks dance across your armor", g.data.rainbow[g.rnd(len(g.data.rainbow))])
	case 7:
		g.msg("you suddenly feel very thirsty")
	case 8:
		g.msg("you feel time speed up suddenly")
	case 9:
		g.msg("time now seems to be going slower")
	case 10:
		g.msg("you pack turns %s!", g.data.rainbow[g.rnd(len(g.data.rainbow))])
	}
}

func (g *RogueGame) trapSleep(Coord) {
	g.NoCommand += g.spread(5) // SLEEPTIME

	g.Player.Flags.Clear(Awake)
	g.msg("a strange white mist envelops you and you fall asleep")
}

func (g *RogueGame) trapArrow(Coord) {
	p := &g.Player
	if g.swing(p.Stats.Lvl-1, p.Stats.ArmorClass, 1) {
		p.Stats.HP -= g.roll(1, 6)
		if p.Stats.HP <= 0 {
			g.msg("an arrow killed you")
			g.death('a')
		} else {
			g.msg("oh no! An arrow shot you")
		}
	} else {
		arrow := newObject()
		g.initWeapon(arrow, WeaponArrow)
		arrow.Count = 1
		arrow.Pos = p.Pos
		g.fall(arrow, false)
		g.msg("an arrow shoots past you")
	}
}

func (g *RogueGame) trapTeleport(tc Coord) {
	// since the hero's leaving, look() won't put a TRAP down for us,
	// so we have to do it ourself
	g.teleport()
	g.mvaddch(tc.Y, tc.X, Trap)
}

func (g *RogueGame) trapDart(Coord) {
	p := &g.Player
	if !g.swing(p.Stats.Lvl+1, p.Stats.ArmorClass, 1) {
		g.msg("a small dart whizzes by your ear and vanishes")

		return
	}

	p.Stats.HP -= g.roll(1, 4)
	if p.Stats.HP <= 0 {
		g.msg("a poisoned dart killed you")
		g.death('d')
	}

	if !p.IsWearing(RingSustainStrength) && !g.save(VsPoison) {
		g.changeStrength(-1)
	}

	g.msg("a small dart just hit you in the shoulder")
}

func (g *RogueGame) trapRust(Coord) {
	g.msg("a gush of water hits you on the head")
	g.rustArmor(g.Player.CurArmor)
}

// randomStep moves in a random direction if the monster/person is
// confused (move.c rndmove).
func (g *RogueGame) randomStep(who *Creature) Coord {
	ret := Coord{
		Y: who.Pos.Y + g.rnd(3) - 1,
		X: who.Pos.X + g.rnd(3) - 1,
	}
	// Now check to see if that's a legal move.  If not, don't move.
	// (I.e., bump into the wall or whatever)
	if ret == who.Pos {
		return ret
	}

	if !g.diagOk(who.Pos, ret) {
		return who.Pos
	}

	ch := g.Level.VisibleChar(ret.Y, ret.X)
	if !stepOk(ch) {
		return who.Pos
	}

	if ch == Scroll {
		var found *Object

		for _, obj := range g.Level.Objects {
			if ret.Y == obj.Pos.Y && ret.X == obj.Pos.X {
				found = obj

				break
			}
		}

		if found != nil && found.ScrollKind() == ScrollScareMonster {
			return who.Pos
		}
	}

	return ret
}

// rustArmor rusts the given armor, if it is a legal kind to rust, and we
// aren't wearing a magic ring (move.c rust_armor).
func (g *RogueGame) rustArmor(arm *Object) {
	if arm == nil || arm.Kind != KindArmor || arm.ArmorKind() == ArmorLeather ||
		arm.ArmorClass >= 9 {
		return
	}

	if arm.Flags.Has(Protected) || g.Player.IsWearing(RingMaintainArmor) {
		if !g.ToDeath {
			g.msg("the rust vanishes instantly")
		}
	} else {
		arm.ArmorClass++

		if !g.Options.Terse {
			g.msg("your armor appears to be weaker now. Oh my!")
		} else {
			g.msg("your armor weakens")
		}
	}
}