package game

// wizard.c — special wizard commands, some of which are also non-wizard
// commands under strange circumstances. The DES password check is not
// ported: wizard mode is enabled by configuration instead.

// createObj is the wizard command for getting anything he wants (wizard.c
// create_obj).
func (g *RogueGame) createObj() {
	obj := newObject()

	g.msg("type of item: ")
	obj.Kind = objectKindForGlyph(g.readchar())
	g.Msgs.Mpos = 0
	g.msg("which %c do you want? (0-f)", obj.Kind.Glyph())

	ch := g.readchar()
	if isDigit(ch) {
		obj.Which = int(ch - '0')
	} else {
		obj.Which = int(ch-'a') + 10
	}

	obj.Group = 0
	obj.Count = 1
	g.Msgs.Mpos = 0

	switch obj.Kind {
	case KindWeapon, KindArmor:
		g.msg("blessing? (+,-,n)")
		bless := g.readchar()
		g.Msgs.Mpos = 0

		if bless == '-' {
			obj.Flags.Set(Cursed)
		}

		if obj.Kind == KindWeapon {
			g.initWeapon(obj, WeaponKind(obj.Which))

			if bless == '-' {
				obj.HPlus -= g.rnd(3) + 1
			}

			if bless == '+' {
				obj.HPlus += g.rnd(3) + 1
			}
		} else {
			obj.ArmorClass = g.data.aClass[obj.Which]
			if bless == '-' {
				obj.ArmorClass += g.rnd(3) + 1
			}

			if bless == '+' {
				obj.ArmorClass -= g.rnd(3) + 1
			}
		}
	case KindRing:
		switch obj.RingKind() {
		case RingProtection, RingAddStrength, RingDexterity, RingIncreaseDamage:
			g.msg("blessing? (+,-,n)")
			bless := g.readchar()
			g.Msgs.Mpos = 0

			if bless == '-' {
				obj.Flags.Set(Cursed)
				obj.Bonus = -1
			} else {
				obj.Bonus = g.rnd(2) + 1
			}
		case RingAggravateMonsters, RingTeleportation:
			obj.Flags.Set(Cursed)
		}
	case KindWand:
		g.fixStick(obj)
	case KindGold:
		g.msg("how much?")

		buf := ""
		if g.getStr(&buf, g.scr.Std) == Norm {
			obj.GoldValue = cAtoi(buf)
		}
	}

	g.addPack(obj, false)
}

// showMap prints out the whole map for the wizard (wizard.c show_map).
func (g *RogueGame) showMap() {
	hw := g.scr.Hw
	hw.Clear()

	for y := 1; y < NumLines-1; y++ {
		for x := range NumCols {
			isReal := g.Level.FlagsAt(y, x).Has(FReal)
			if !isReal {
				hw.Standout(true)
			}

			hw.MvAddCh(y, x, g.Level.Char(y, x))

			if !isReal {
				hw.Standout(false)
			}
		}
	}

	g.showWin("---More (level map)---")
}

// whatis identifies what a certain object is (wizard.c whatis).
func (g *RogueGame) whatis(insist bool, kind ObjectKind) {
	p := &g.Player
	if len(p.Pack) == 0 {
		g.msg("you don't have anything in your pack to identify")

		return
	}

	var obj *Object
	for {
		obj = g.getItem("identify", kind)

		if !insist {
			break
		}

		if g.NObjs == 0 {
			return
		}

		if obj == nil {
			g.msg("you must identify something")

			continue
		}

		if !matchesFilter(kind, obj) {
			g.msg("you must identify a %s", kind)

			continue
		}

		break
	}

	if obj == nil {
		return
	}

	switch obj.Kind {
	case KindScroll:
		setKnow(obj, g.Items.Scrolls[:])
	case KindPotion:
		setKnow(obj, g.Items.Potions[:])
	case KindWand:
		setKnow(obj, g.Items.Sticks[:])
	case KindWeapon, KindArmor:
		obj.Flags.Set(Known)
	case KindRing:
		setKnow(obj, g.Items.Rings[:])
	}

	g.msg("%s", g.invName(obj, false))
}

// setKnow sets things up when we really know what a thing is (wizard.c
// set_know).
func setKnow(obj *Object, info []ObjInfo) {
	info[obj.Which].Know = true
	obj.Flags.Set(Known)
	info[obj.Which].Guess = ""
}

// The C type_name()/tlist table is gone: ObjectKind.String() carries the
// same vocabulary.

// teleport bamfs the hero someplace else (wizard.c teleport).
func (g *RogueGame) teleport() {
	p := &g.Player
	g.mvaddch(p.Pos.Y, p.Pos.X, g.floorAt())

	c, _ := g.findFloor(true)
	if g.roomIn(c) != p.Room {
		g.leaveRoom(p.Pos)
		p.Pos = c
		g.enterRoom(p.Pos)
	} else {
		p.Pos = c

		g.look(true)
	}

	g.mvaddch(p.Pos.Y, p.Pos.X, PlayerCh)
	// turn off ISHELD in case teleportation was done while fighting a
	// Flytrap
	if p.On(Held) {
		p.Flags.Clear(Held)
		p.VfHit = 0
		g.Monsters['F'-'A'].Stats.Dmg = dice("000x0")
	}

	g.NoMove = 0
	g.Count = 0
	g.Running = false
	g.flushType()
}