package game

// Creature is the _t arm of the C THING union: the player or a monster.
type Creature struct {
	Pos      Coord  // position
	Turn     bool   // if slowed, is it a turn to move
	Type     byte   // what it is: 'A'..'Z' for monsters, '@' for the player
	Disguise byte   // what mimic looks like
	OldCh    byte   // character that was where it was
	Dest     *Coord // where it is running to — aliases live coords (hero pos, room gold, another monster's pos)
	Flags    CreatureFlags
	Stats    Stats
	Room     *Room     // current room for thing
	Pack     []*Object // what the thing is carrying
}

// Monster is a hostile creature on the level.
type Monster struct {
	Creature
}

// Player embeds Creature and owns the player-only state that was global
// in the C sources (cur_armor, purse, food_left, ...).
type Player struct {
	Creature

	CurArmor    *Object    // what he is wearing
	CurWeapon   *Object    // which weapon he is wielding
	CurRing     [2]*Object // which rings are being worn (Left/Right)
	PackUsed    [26]bool   // is the character used in the pack?
	Inpack      int        // number of things in pack
	Purse       int        // how much gold he has
	FoodLeft    int        // amount of food in hero's stomach
	HungryState int        // how hungry is he (0..3)
	NoFood      int        // number of levels without food
	MaxStats    Stats      // the maximum for the player
	VfHit       int        // number of times the flytrap has hit
}

// On is the C on(thing, flag) macro.
func (c *Creature) On(f CreatureFlags) bool { return c.Flags.Has(f) }

// IsRing is the C ISRING(hand, ring) macro.
func (p *Player) IsRing(hand int, ring RingKind) bool {
	return p.CurRing[hand] != nil && p.CurRing[hand].RingKind() == ring
}

// IsWearing is the C ISWEARING(ring) macro: is the ring on either hand.
func (p *Player) IsWearing(ring RingKind) bool {
	return p.IsRing(Left, ring) || p.IsRing(Right, ring)
}

// attachMon pushes a monster onto the front of a list (list.c attach).
func attachMon(list *[]*Monster, item *Monster) {
	*list = append([]*Monster{item}, *list...)
}

// detachMon removes a monster (by identity) from a list (list.c detach).
func detachMon(list *[]*Monster, item *Monster) {
	for i, m := range *list {
		if m == item {
			*list = append((*list)[:i], (*list)[i+1:]...)

			return
		}
	}
}