rgoue/game/chase.go

package game

// chase.c — code for one creature to chase another.

// dragonShot: one chance in DRAGONSHOT that a dragon will flame.
const dragonShot = 5

// runners makes all the running monsters move (chase.c runners).
func (g *RogueGame) runners(int) {
	list := append([]*Monster(nil), g.Level.Monsters...)
	for _, tp := range list {
		g.runnerTurn(tp)
	}

	if g.HasHit {
		g.endmsg()
		g.HasHit = false
	}
}

// runnerTurn gives one monster its motion for the turn; flying monsters
// far from the hero move twice (the loop body of chase.c runners).
func (g *RogueGame) runnerTurn(tp *Monster) {
	if tp.On(Held) || !tp.On(Awake) {
		return
	}

	origPos := tp.Pos

	wastarget := tp.On(Targeted)
	if removed := g.moveMonster(tp); removed {
		return
	}

	if tp.On(Flying) && distCp(g.Player.Pos, tp.Pos) >= 3 {
		if removed := g.moveMonster(tp); removed {
			return
		}
	}

	if wastarget && origPos != tp.Pos {
		tp.Flags.Clear(Targeted)

		g.ToDeath = false
	}
}

// moveMonster executes a single turn of running for a monster (chase.c
// move_monst). The result reports that the monster died or left the
// level (the C -1 return).
func (g *RogueGame) moveMonster(tp *Monster) bool {
	if !tp.On(Slowed) || tp.Turn {
		if g.chaseStep(tp) {
			return true
		}
	}

	if tp.On(Hasted) {
		if g.chaseStep(tp) {
			return true
		}
	}

	tp.Turn = !tp.Turn

	return false
}

// relocate makes the monster's new location be the specified one, updating
// all the relevant state (chase.c relocate).
func (g *RogueGame) relocate(th *Monster, newLoc Coord) {
	if newLoc != th.Pos {
		g.mvaddch(th.Pos.Y, th.Pos.X, th.OldCh)
		th.Room = g.roomIn(newLoc)
		g.setOldChar(th, newLoc)
		oroom := th.Room
		g.Level.SetMonsterAt(th.Pos.Y, th.Pos.X, nil)

		if oroom != th.Room {
			th.Dest = g.findDest(th)
		}

		th.Pos = newLoc
		g.Level.SetMonsterAt(newLoc.Y, newLoc.X, th)
	}

	g.move(newLoc.Y, newLoc.X)

	if g.seeMonst(th) {
		g.addch(th.Disguise)
	} else if g.Player.On(SenseMonsters) {
		g.standout()
		g.addch(th.Type)
		g.standend()
	}
}

// chaseStep makes one thing chase another (chase.c do_chase). The
// result reports that the chaser died or left the level in the attempt
// (the C -1 return).
func (g *RogueGame) chaseStep(th *Monster) bool {
	stoprun := false // true means we are there

	rer, ree, door := g.chaseRooms(th)

	this, shot := g.chaseGoal(th, rer, ree, door, 32767)
	if shot {
		return false
	}
	// This now contains what we want to run to this time so we run to it.
	// If we hit it we either want to fight it or stop running
	if g.chase(th, this) {
		if th.Type == 'F' {
			return false
		}
	} else {
		switch this {
		case g.Player.Pos:
			return g.attack(th)
		case *th.Dest:
			g.chaseTakeObject(th)

			stoprun = th.Type != 'F'
		}
	}

	g.relocate(th, g.chRet)
	// And stop running if need be
	if stoprun && th.Pos == *th.Dest {
		th.Flags.Clear(Awake)
	}

	return false
}

// chaseRooms finds the rooms of the chaser and its desire; doors do not
// count as inside rooms here (the setup of chase.c do_chase).
func (g *RogueGame) chaseRooms(th *Monster) (*Room, *Room, bool) {
	p := &g.Player

	rer := th.Room // find room of chaser
	if th.On(Greedy) && rer.GoldVal == 0 {
		th.Dest = &p.Pos // if gold has been taken, run after hero
	}

	var ree *Room // find room of chasee
	if th.Dest == &p.Pos {
		ree = p.Room
	} else {
		ree = g.roomIn(*th.Dest)
	}

	return rer, ree, g.Level.Char(th.Pos.Y, th.Pos.X) == Door
}

// chaseGoal picks the spot the chaser runs toward this turn: the
// nearest exit toward its desire when it is in a different room, or the
// desire itself. shot means a dragon breathed flame instead of moving
// (the goal loop of chase.c do_chase).
func (g *RogueGame) chaseGoal(th *Monster, rer, ree *Room, door bool, mindist int) (Coord, bool) {
	var this Coord

	for {
		// If the object of our desire is in a different room, and we are
		// not in a corridor, run to the door nearest to our goal.
		if rer == ree {
			this = *th.Dest

			return this, g.dragonBreath(th)
		}

		for i := range rer.Exits {
			curdist := distCp(*th.Dest, rer.Exits[i])
			if curdist < mindist {
				this = rer.Exits[i]
				mindist = curdist
			}
		}

		if !door {
			return this, false
		}

		rer = &g.Level.Passages[*g.Level.FlagsAt(th.Pos.Y, th.Pos.X)&FPassNum]
		door = false
		// the C goto over: redo with the passage as room
	}
}

// dragonBreath checks whether a dragon shoots flame at the hero instead
// of moving, and shoots it (the D block of chase.c do_chase).
func (g *RogueGame) dragonBreath(th *Monster) bool {
	if th.Type != 'D' || !g.dragonShoots(th) {
		return false
	}

	p := &g.Player

	g.Delta.Y = sign(p.Pos.Y - th.Pos.Y)

	g.Delta.X = sign(p.Pos.X - th.Pos.X)
	if g.HasHit {
		g.endmsg()
	}

	g.fireBolt(th.Pos, &g.Delta, "flame")
	g.Running = false
	g.Count = 0

	g.Quiet = 0
	if g.ToDeath && !th.On(Targeted) {
		g.ToDeath = false
		g.Kamikaze = false
	}

	return true
}

// dragonShoots decides whether the dragon takes the shot: the hero is
// on a straight line from it, within shooting distance but outside
// striking range, it is not cancelled, and the shot roll comes up
// (chase.c do_chase).
func (g *RogueGame) dragonShoots(th *Monster) bool {
	p := &g.Player
	if th.Pos.Y != p.Pos.Y && th.Pos.X != p.Pos.X &&
		abs(th.Pos.Y-p.Pos.Y) != abs(th.Pos.X-p.Pos.X) {
		return false
	}

	return distCp(th.Pos, p.Pos) <= BoltLength*BoltLength &&
		!th.On(Cancelled) && g.rnd(dragonShot) == 0
}

// chaseTakeObject has the monster pick up the object it was running to
// (the dest arm of chase.c do_chase).
func (g *RogueGame) chaseTakeObject(th *Monster) {
	for _, obj := range g.Level.Objects {
		if th.Dest == &obj.Pos {
			g.Level.RemoveObject(obj)
			attachObj(&th.Pack, obj)

			if th.Room.Flags.Has(Gone) {
				g.Level.SetChar(obj.Pos.Y, obj.Pos.X, Passage)
			} else {
				g.Level.SetChar(obj.Pos.Y, obj.Pos.X, Floor)
			}

			th.Dest = g.findDest(th)

			break
		}
	}
}

// chase finds the spot for the chaser to move closer to the chasee
// (chase.c chase). Returns true if we want to keep on chasing later, false
// if we reach the goal. The chosen spot lands in g.chRet.
func (g *RogueGame) chase(tp *Monster, ee Coord) bool {
	var curdist int

	// If the thing is confused, let it move randomly. Invisible Stalkers
	// are slightly confused all of the time, and bats are quite confused
	// all the time
	if (tp.On(Confused) && g.rnd(5) != 0) || (tp.Type == 'P' && g.rnd(5) == 0) ||
		(tp.Type == 'B' && g.rnd(2) == 0) {
		// get a valid random move
		g.chRet = g.randomStep(&tp.Creature)
		curdist = distCp(g.chRet, ee)
		// Small chance that it will become un-confused
		if g.rnd(20) == 0 {
			tp.Flags.Clear(Confused)
		}
	} else {
		curdist = g.chaseBestSpot(tp, ee)
	}

	return curdist != 0 && g.chRet != g.Player.Pos
}

// chaseSearch is the scan state while chase looks for the step that
// gets a monster closest to its chasee.
type chaseSearch struct {
	er      Coord // where the chaser is
	ee      Coord // where it wants to go
	curdist int
	plcnt   int
}

// chaseBestSpot finds the empty spot next to the chaser that is closest
// to the chasee, leaving it in g.chRet; if there is none, the chaser
// stays where it is (the search half of chase.c chase).
func (g *RogueGame) chaseBestSpot(tp *Monster, ee Coord) int {
	er := tp.Pos
	s := chaseSearch{er: er, ee: ee, curdist: distCp(er, ee), plcnt: 1}
	g.chRet = er

	ey := er.Y + 1
	if ey >= NumLines-1 {
		ey = NumLines - 2
	}

	ex := er.X + 1
	if ex >= NumCols {
		ex = NumCols - 1
	}

	for x := er.X - 1; x <= ex; x++ {
		if x < 0 {
			continue
		}

		for y := er.Y - 1; y <= ey; y++ {
			g.chaseTry(&s, y, x)
		}
	}

	return s.curdist
}

// chaseTry scores one candidate square, reservoir-sampling among ties
// (the scan body of chase.c chase).
func (g *RogueGame) chaseTry(s *chaseSearch, y, x int) {
	tryp := Coord{X: x, Y: y}
	if !g.diagOk(s.er, tryp) {
		return
	}

	ch := g.Level.VisibleChar(y, x)
	if !stepOk(ch) {
		return
	}
	// If it is a scroll, it might be a scare monster scroll so we need
	// to look it up to see what type it is.
	if ch == Scroll && g.scareScrollAt(y, x) {
		return
	}
	// It can also be a Xeroc, which we shouldn't step on
	if m := g.Level.MonsterAt(y, x); m != nil && m.Type == 'X' {
		return
	}
	// If we didn't find any scrolls at this place or it wasn't a scare
	// scroll, then this place counts
	thisdist := distance(y, x, s.ee.Y, s.ee.X)
	if thisdist < s.curdist {
		s.plcnt = 1
		g.chRet = tryp
		s.curdist = thisdist
	} else if thisdist == s.curdist {
		if s.plcnt++; g.rnd(s.plcnt) == 0 {
			g.chRet = tryp
			s.curdist = thisdist
		}
	}
}

// scareScrollAt reports whether the object lying at (y, x) is a scare
// monster scroll (chase.c chase).
func (g *RogueGame) scareScrollAt(y, x int) bool {
	for _, obj := range g.Level.Objects {
		if y == obj.Pos.Y && x == obj.Pos.X {
			return obj.ScrollKind() == ScrollScareMonster
		}
	}

	return false
}

// setOldChar sets the oldch character for the monster (chase.c set_oldch).
func (g *RogueGame) setOldChar(tp *Monster, cp Coord) {
	if tp.Pos == cp {
		return
	}

	sch := tp.OldCh

	tp.OldCh = g.mvinch(cp.Y, cp.X)
	if !g.Player.On(Blind) {
		if (sch == Floor || tp.OldCh == Floor) && tp.Room.Flags.Has(Dark) {
			tp.OldCh = ' '
		} else if distCp(cp, g.Player.Pos) <= LampDist && g.Options.SeeFloor {
			tp.OldCh = g.Level.Char(cp.Y, cp.X)
		}
	}
}

// seeMonst returns true if the hero can see the monster (chase.c
// see_monst).
func (g *RogueGame) seeMonst(mp *Monster) bool {
	p := &g.Player
	if p.On(Blind) {
		return false
	}

	if mp.On(Invisible) && !p.On(CanSeeInvisible) {
		return false
	}

	y, x := mp.Pos.Y, mp.Pos.X
	if distance(y, x, p.Pos.Y, p.Pos.X) < LampDist {
		if y != p.Pos.Y && x != p.Pos.X &&
			!stepOk(g.Level.Char(y, p.Pos.X)) && !stepOk(g.Level.Char(p.Pos.Y, x)) {
			return false
		}

		return true
	}

	if mp.Room != p.Room {
		return false
	}

	return !mp.Room.Flags.Has(Dark)
}

// runTo sets a monster running after the hero (chase.c runto).
func (g *RogueGame) runTo(runner Coord) {
	tp := g.Level.MonsterAt(runner.Y, runner.X)
	if tp == nil {
		return
	}
	// Start the beastie running
	tp.Flags.Set(Awake)
	tp.Flags.Clear(Held)
	tp.Dest = g.findDest(tp)
}

// roomIn finds what room some coordinates are in; nil means they aren't in
// any room (chase.c roomin).
func (g *RogueGame) roomIn(cp Coord) *Room {
	fp := *g.Level.FlagsAt(cp.Y, cp.X)
	if fp.Has(FPassage) {
		return &g.Level.Passages[fp&FPassNum]
	}

	for i := range g.Level.Rooms {
		rp := &g.Level.Rooms[i]
		if cp.X <= rp.Pos.X+rp.Max.X && rp.Pos.X <= cp.X &&
			cp.Y <= rp.Pos.Y+rp.Max.Y && rp.Pos.Y <= cp.Y {
			return rp
		}
	}

	g.msg("in some bizarre place (%d, %d)", cp.Y, cp.X)

	return nil
}

// diagOk checks to see if a diagonal move is legal (chase.c diag_ok).
func (g *RogueGame) diagOk(sp, ep Coord) bool {
	if ep.X < 0 || ep.X >= NumCols || ep.Y <= 0 || ep.Y >= NumLines-1 {
		return false
	}

	if ep.X == sp.X || ep.Y == sp.Y {
		return true
	}

	return stepOk(g.Level.Char(ep.Y, sp.X)) && stepOk(g.Level.Char(sp.Y, ep.X))
}

// canSee returns true if the hero can see a certain coordinate (chase.c
// cansee).
func (g *RogueGame) canSee(y, x int) bool {
	p := &g.Player
	if p.On(Blind) {
		return false
	}

	if distance(y, x, p.Pos.Y, p.Pos.X) < LampDist {
		if g.Level.FlagsAt(y, x).Has(FPassage) {
			if y != p.Pos.Y && x != p.Pos.X &&
				!stepOk(g.Level.Char(y, p.Pos.X)) &&
				!stepOk(g.Level.Char(p.Pos.Y, x)) {
				return false
			}
		}

		return true
	}
	// We can only see if the hero is in the same room as the coordinate
	// and the room is lit, or if it is close.
	rer := g.roomIn(Coord{X: x, Y: y})

	return rer == p.Room && !rer.Flags.Has(Dark)
}

// findDest finds the proper destination for the monster (chase.c
// find_dest).
func (g *RogueGame) findDest(tp *Monster) *Coord {
	prob := g.Monsters[tp.Type-'A'].Carry
	if prob <= 0 || tp.Room == g.Player.Room || g.seeMonst(tp) {
		return &g.Player.Pos
	}

	for _, obj := range g.Level.Objects {
		if obj.Kind == KindScroll && obj.ScrollKind() == ScrollScareMonster {
			continue
		}

		if g.roomIn(obj.Pos) == tp.Room && g.rnd(100) < prob &&
			!g.objectClaimed(obj) {
			return &obj.Pos
		}
	}

	return &g.Player.Pos
}

// objectClaimed reports whether some monster already runs toward this
// object (chase.c find_dest).
func (g *RogueGame) objectClaimed(obj *Object) bool {
	for _, other := range g.Level.Monsters {
		if other.Dest == &obj.Pos {
			return true
		}
	}

	return false
}