path: root/internal/game/cmd_registry.go

package game

import (
	"fmt"
	"strings"

	"thehouseoficarus/internal/behavior"
	"thehouseoficarus/internal/casino"
	"thehouseoficarus/internal/net"
)

type commandHandler func(g *Game, sess *net.Session, args []string, rawInput string)

type commandDef struct {
	handler commandHandler
	class   CommandClass
}

var commandRegistry = map[string]commandDef{
	"get":    {(*Game).executeGet, ClassActive},
	"take":   {(*Game).executeGet, ClassActive},
	"grab":   {(*Game).executeGet, ClassActive},
	"pick":   {(*Game).executeGet, ClassActive},
	"drop":   {(*Game).executeDrop, ClassActive},
	"attack": {(*Game).executeAttack, ClassActive},
	"kill":   {(*Game).executeAttack, ClassActive},
	"work":   {(*Game).executeWork, ClassActive},
	"play":   {(*Game).executePlay, ClassActive},
	"rebet":  {(*Game).executeBet, ClassActive},
	"draw":   {func(g *Game, s *net.Session, _ []string, _ string) { g.executeTableAction(s, "draw") }, ClassActive},
	"hold": {func(g *Game, s *net.Session, args []string, _ string) {
		g.executeTableAction(s, "hold "+strings.Join(args, " "))
	}, ClassInstant},
	"deal": {func(g *Game, s *net.Session, args []string, _ string) {
		if len(args) > 0 {
			s.WriteLine("Use deal.")
			return
		}
		g.executeTableAction(s, "deal")
	}, ClassActive},
	"paytable": {func(g *Game, s *net.Session, _ []string, _ string) { g.executeTableAction(s, "paytable") }, ClassInstant},
	"denom": {func(g *Game, s *net.Session, args []string, _ string) {
		g.executeTableAction(s, "denom "+strings.Join(args, " "))
	}, ClassInstant},
	"denomination": {func(g *Game, s *net.Session, args []string, _ string) {
		g.executeTableAction(s, "denom "+strings.Join(args, " "))
	}, ClassInstant},
	"hands": {func(g *Game, s *net.Session, args []string, _ string) {
		g.executeTableAction(s, "hands "+strings.Join(args, " "))
	}, ClassInstant},
	"feature": {func(g *Game, s *net.Session, args []string, _ string) {
		g.executeTableAction(s, "feature "+strings.Join(args, " "))
	}, ClassInstant},
	"game": {func(g *Game, s *net.Session, args []string, _ string) {
		g.executeTableAction(s, "game "+strings.Join(args, " "))
	}, ClassInstant},
	"roll":     {func(g *Game, s *net.Session, _ []string, _ string) { g.executeTableAction(s, "roll") }, ClassActive},
	"autoroll": {func(g *Game, s *net.Session, _ []string, _ string) { g.executeTableAction(s, "autoroll") }, ClassInstant},
	"unbet": {func(g *Game, s *net.Session, _ []string, _ string) {
		g.executeTableAction(s, "unbet")
	}, ClassActive},
	"table":         {(*Game).executeTableStatus, ClassInstant},
	"status":        {(*Game).executeTableStatus, ClassInstant},
	"rules":         {(*Game).executeRules, ClassInstant},
	"list":          {(*Game).executeList, ClassInstant},
	"watch":         {(*Game).executeWatch, ClassInstant},
	"decline":       {func(g *Game, s *net.Session, _ []string, _ string) { g.executeTableAction(s, "decline") }, ClassActive},
	"h":             {func(g *Game, s *net.Session, _ []string, _ string) { g.executeTableAction(s, "hit") }, ClassActive},
	"st":            {func(g *Game, s *net.Session, _ []string, _ string) { g.executeTableAction(s, "stand") }, ClassActive},
	"dd":            {func(g *Game, s *net.Session, _ []string, _ string) { g.executeTableAction(s, "double") }, ClassActive},
	"sp":            {func(g *Game, s *net.Session, _ []string, _ string) { g.executeTableAction(s, "split") }, ClassActive},
	"bet":           {(*Game).executeBet, ClassActive},
	"spin":          {(*Game).executeSpin, ClassActive},
	"autobet":       {(*Game).executeAutoBet, ClassActive},
	"autospin":      {(*Game).executeAutoBet, ClassActive},
	"hit":           {func(g *Game, s *net.Session, _ []string, _ string) { g.executeTableAction(s, "hit") }, ClassActive},
	"stand":         {func(g *Game, s *net.Session, _ []string, _ string) { g.executeTableAction(s, "stand") }, ClassActive},
	"double":        {func(g *Game, s *net.Session, _ []string, _ string) { g.executeTableAction(s, "double") }, ClassActive},
	"split":         {func(g *Game, s *net.Session, _ []string, _ string) { g.executeTableAction(s, "split") }, ClassActive},
	"insurance":     {func(g *Game, s *net.Session, _ []string, _ string) { g.executeTableAction(s, "insurance") }, ClassActive},
	"surrender":     {func(g *Game, s *net.Session, _ []string, _ string) { g.executeTableAction(s, "surrender") }, ClassActive},
	"style":         {(*Game).executeStyle, ClassInstant},
	"look":          {(*Game).executeLook, ClassInstant},
	"l":             {(*Game).executeLook, ClassInstant},
	"north":         {(*Game).executeMove, ClassActive},
	"n":             {(*Game).executeMove, ClassActive},
	"south":         {(*Game).executeMove, ClassActive},
	"s":             {(*Game).executeMove, ClassActive},
	"east":          {(*Game).executeMove, ClassActive},
	"e":             {(*Game).executeMove, ClassActive},
	"west":          {(*Game).executeMove, ClassActive},
	"w":             {(*Game).executeMove, ClassActive},
	"northeast":     {(*Game).executeMove, ClassActive},
	"ne":            {(*Game).executeMove, ClassActive},
	"northwest":     {(*Game).executeMove, ClassActive},
	"nw":            {(*Game).executeMove, ClassActive},
	"southeast":     {(*Game).executeMove, ClassActive},
	"se":            {(*Game).executeMove, ClassActive},
	"southwest":     {(*Game).executeMove, ClassActive},
	"sw":            {(*Game).executeMove, ClassActive},
	"up":            {(*Game).executeMove, ClassActive},
	"u":             {(*Game).executeMove, ClassActive},
	"down":          {(*Game).executeMove, ClassActive},
	"d":             {(*Game).executeMove, ClassActive},
	"say":           {(*Game).executeSay, ClassInstant},
	"global":        {(*Game).executeGlobal, ClassInstant},
	"who":           {(*Game).executeWho, ClassInstant},
	"sc":            {(*Game).executeScore, ClassInstant},
	"score":         {(*Game).executeScore, ClassInstant},
	"skills":        {(*Game).executeSkills, ClassInstant},
	"sk":            {(*Game).executeSkills, ClassInstant},
	"task":          {(*Game).executeTask, ClassInstant},
	"stats":         {(*Game).executeStats, ClassInstant},
	"tech":          {(*Game).executeTech, ClassInstant},
	"t":             {(*Game).executeTech, ClassInstant},
	"i":             {(*Game).executeInventory, ClassInstant},
	"inv":           {(*Game).executeInventory, ClassInstant},
	"inventory":     {(*Game).executeInventory, ClassInstant},
	"quit":          {(*Game).executeQuit, ClassActive},
	"description":   {(*Game).executeDescription, ClassInstant},
	"desc":          {(*Game).executeDescription, ClassInstant},
	"option":        {(*Game).executeOption, ClassInstant},
	"options":       {(*Game).executeOption, ClassInstant},
	"color":         {(*Game).executeColor, ClassInstant},
	"colors":        {(*Game).executeColor, ClassInstant},
	"colortable":    {(*Game).executeColortable, ClassInstant},
	"prompt":        {(*Game).executePrompt, ClassInstant},
	"exits":         {(*Game).executeExits, ClassInstant},
	"map":           {(*Game).executeMap, ClassInstant},
	"symbol":        {(*Game).executeSymbol, ClassInstant},
	"queued":        {(*Game).executeQueued, ClassInstant},
	"help":          {(*Game).executeHelp, ClassInstant},
	"mine":          {(*Game).executeGather, ClassActive},
	"chop":          {(*Game).executeGather, ClassActive},
	"fish":          {(*Game).executeGather, ClassActive},
	"cut":           {(*Game).executeGather, ClassActive},
	"pull":          {(*Game).executeUse, ClassActive},
	"push":          {(*Game).executeUse, ClassActive},
	"use":           {(*Game).executeUse, ClassActive},
	"cook":          {(*Game).executeCook, ClassActive},
	"smelt":         {(*Game).executeSmelt, ClassActive},
	"smith":         {(*Game).executeSmith, ClassActive},
	"craft":         {(*Game).executeCraft, ClassActive},
	"eat":           {(*Game).executeEat, ClassFree},
	"drink":         {(*Game).executeDrink, ClassFree},
	"fletch":        {(*Game).executeFletch, ClassFree},
	"clean":         {(*Game).executeClean, ClassFree},
	"mix":           {(*Game).executeMix, ClassActive},
	"id":            {(*Game).executeIdentify, ClassActive},
	"identify":      {(*Game).executeIdentify, ClassActive},
	"autotrigger":   {(*Game).executeAutotrigger, ClassInstant},
	"auto":          {(*Game).executeAutotrigger, ClassInstant},
	"mods":          {(*Game).executeMods, ClassInstant},
	"modlist":       {(*Game).executeMods, ClassInstant},
	"mod":           {(*Game).executeMods, ClassInstant},
	"modules":       {(*Game).executeMods, ClassInstant},
	"module":        {(*Game).executeMods, ClassInstant},
	"sneak":         {(*Game).executeSneak, ClassInstant},
	"trigger":       {(*Game).executeTrigger, ClassActive},
	"home":          {(*Game).executeHome, ClassInstant},
	"recall":        {(*Game).executeHome, ClassInstant},
	"talk":          {(*Game).executeTalk, ClassActive},
	"speak":         {(*Game).executeTalk, ClassActive},
	"ask":           {(*Game).executeTalk, ClassActive},
	"burn":          {(*Game).executeBurn, ClassActive},
	"stoke":         {(*Game).executeStoke, ClassActive},
	"alias":         {(*Game).executeAlias, ClassInstant},
	"unalias":       {(*Game).executeUnalias, ClassInstant},
	"search":        {(*Game).executeSearch, ClassActive},
	"steal":         {(*Game).executeSteal, ClassActive},
	"thieve":        {(*Game).executeSteal, ClassActive},
	"plant":         {(*Game).executePlant, ClassActive},
	"harvest":       {(*Game).executeHarvest, ClassActive},
	"rake":          {(*Game).executeRake, ClassActive},
	"water":         {(*Game).executeWater, ClassActive},
	"cure":          {(*Game).executeCure, ClassActive},
	"inspect":       {(*Game).executeInspect, ClassInstant},
	"walk":          {(*Game).executeWalk, ClassActive},
	"bank":          {(*Game).executeBank, ClassActive},
	"browse":        {(*Game).executeShopList, ClassInstant},
	"buy":           {(*Game).executeShopBuy, ClassInstant},
	"sell":          {(*Game).executeShopSell, ClassInstant},
	"construct":     {(*Game).executeConstruct, ClassActive},
	"make":          {(*Game).executeConstruct, ClassActive},
	"jack":          {(*Game).executeJack, ClassActive},
	"jackin":        {(*Game).executeJack, ClassActive},
	"eq":            {(*Game).executeWear, ClassFree},
	"equipment":     {(*Game).executeWear, ClassFree},
	"equip":         {(*Game).executeWear, ClassFree},
	"wear":          {(*Game).executeWear, ClassFree},
	"wield":         {(*Game).executeWear, ClassFree},
	"remove":        {(*Game).executeRemove, ClassFree},
	"unwear":        {(*Game).executeRemove, ClassFree},
	"unwield":       {(*Game).executeRemove, ClassFree},
	"aps":           {(*Game).executeAps, ClassActive},
	"verbs":         {(*Game).executeVerbs, ClassInstant},
	"what":          {(*Game).executeVerbs, ClassInstant},
	"syntax":        {(*Game).executeVerbs, ClassInstant},
	"commands":      {(*Game).executeVerbs, ClassInstant},
	"stop":          {(*Game).executeStop, ClassInstant},
	"hide":          {(*Game).executeHide, ClassActive},
	"safespot":      {(*Game).executeHide, ClassActive},
	"unhide":        {(*Game).executeUnhide, ClassActive},
	"unsafespot":    {(*Game).executeUnhide, ClassActive},
	"goto":          {(*Game).executeGoto, ClassInstant},
	"summon":        {(*Game).executeSummon, ClassInstant},
	"dig":           {(*Game).executeDig, ClassInstant},
	"setglobalflag": {(*Game).executeSetGlobalFlag, ClassInstant},
	"setplayerflag": {(*Game).executeSetPlayerFlag, ClassInstant},
	"reload":        {(*Game).executeReload, ClassInstant},
	"shutdown":      {(*Game).executeShutdown, ClassInstant},
	"room":          {(*Game).executeRoom, ClassInstant},
	"swapid":        {(*Game).executeSwapID, ClassInstant},
	"undig":         {(*Game).executeUndig, ClassInstant},
	"close":         {(*Game).executeClose, ClassInstant},
	"god":           {(*Game).executeGod, ClassInstant},
	"ungod":         {(*Game).executeUnGod, ClassInstant},
	"hideallexits":  {(*Game).executeHideAllExits, ClassInstant},
}

func classifyCommand(cmd string) CommandClass {
	if _, ok := casino.ParsePokerDigits(cmd); ok {
		return ClassInstant
	}
	if _, ok := casino.ParsePaiGowDigits(cmd); ok {
		return ClassInstant
	}
	if def, ok := commandRegistry[cmd]; ok {
		return def.class
	}
	if _, ok := verbAliases[cmd]; ok {
		return ClassActive
	}
	obstacleVerbsMu.RLock()
	isObstacle := obstacleVerbs[cmd]
	obstacleVerbsMu.RUnlock()
	if isObstacle {
		return ClassActive
	}
	return ClassUnknown
}

// casinoCommonVerbs are the generic controls a seated player may abbreviate
// at any casino game; they are not tied to one game's rules.
var casinoCommonVerbs = []string{"watch", "game", "table", "list", "stop", "rules"}

// casinoVerbsByGame scopes the rest of the abbreviable verbs to the game the
// player is actually in. A prefix can therefore never match another game's
// command: "sp" is split at a blackjack table, but spin at a Big 6 wheel,
// because "split" is not a Big 6 verb and "spin" is not a blackjack verb.
var casinoVerbsByGame = map[casino.GameName][]string{
	casino.GameBlackjack:  {"bet", "rebet", "unbet", "hit", "stand", "double", "split", "insurance", "surrender", "decline"},
	casino.GameBaccarat:   {"bet", "rebet", "unbet"},
	casino.GameRoulette:   {"bet", "rebet", "unbet"},
	casino.GameCraps:      {"bet", "rebet", "unbet", "roll", "autoroll"},
	casino.GamePaiGow:     {"bet", "rebet", "unbet"},
	casino.GameVideoPoker: {"bet", "deal", "draw", "hold", "paytable", "denom", "denomination", "hands", "feature"},
	casino.GameSlots:      {"bet", "spin", "autospin", "autobet"},
	casino.GameBigSix:     {"bet", "rebet", "unbet", "spin"},
}

// casinoShortAliases maps the registry's terse aliases onto the verb they
// stand for. An alias only applies when its verb belongs to the current game;
// otherwise the letters are re-read as a fresh prefix, so "sp" is split at a
// blackjack table and spin at a Big 6 wheel.
var casinoShortAliases = map[string]string{
	"h": "hit", "st": "stand", "dd": "double", "sp": "split",
}

// casinoVerbsFor returns the game-scoped verb vocabulary for a seated player,
// or nil when they are not in a casino game.
func (g *Game) casinoVerbsFor(name string) []string {
	if g.Casino == nil {
		return nil
	}
	table, playing := g.Casino.Participation(name)
	if !playing {
		return nil
	}
	var game casino.GameName
	switch {
	case table != nil:
		game = table.Config.Game
	default:
		machine, ok := g.Casino.MachineFor(name)
		if !ok {
			return nil
		}
		game = machine.Config.Game
	}
	verbs := append([]string(nil), casinoCommonVerbs...)
	return append(verbs, casinoVerbsByGame[game]...)
}

// casinoAbbreviation resolves a seated casino player's partial command to the
// closest verb that is actually relevant to the game they are in. Exact
// commands always win, so movement, look and the game's own real verbs are
// never shadowed; a short alias applies only when its verb belongs to this
// game; an ambiguous prefix resolves to nothing and falls through unchanged.
func (g *Game) casinoAbbreviation(sess *net.Session, cmd string) (string, bool) {
	if sess == nil || sess.Player == nil || cmd == "" {
		return "", false
	}
	verbs := g.casinoVerbsFor(sess.Player.Name)
	if len(verbs) == 0 {
		return "", false
	}
	// A real casino verb needs no abbreviation: the registry dispatches it.
	for _, verb := range verbs {
		if verb == cmd {
			return "", false
		}
	}
	if target, ok := casinoShortAliases[cmd]; ok {
		for _, verb := range verbs {
			if verb == target {
				return target, true
			}
		}
		// The alias names another game's verb: fall through and read the
		// letters as a prefix of this game's vocabulary instead.
	} else if _, ok := commandRegistry[cmd]; ok {
		// Any other real command (movement, look, inventory, ...) wins over a
		// casino prefix.
		return "", false
	}
	match := ""
	for _, verb := range verbs {
		if !strings.HasPrefix(verb, cmd) {
			continue
		}
		if match != "" && match != verb {
			return "", false
		}
		match = verb
	}
	return match, match != ""
}

func (g *Game) executeCommand(sess *net.Session, cmd string, args []string, rawInput string) {
	p := sess.Player

	// Locked-sequence busy gate: a locked in-flight trigger sequence blocks every
	// verb except quit/logout (and god-mode admins) until it completes.
	if p != nil && !p.GodMode && g.playerLocked(p.Name) && cmd != "quit" && cmd != "logout" {
		sess.WriteLine("You're busy — wait for the current action to finish.")
		return
	}

	// Unlocked sequences are interruptable: any active/free verb cancels them
	// before running. (Instant info commands like look/inventory/help do not.)
	if p != nil {
		switch classifyCommand(cmd) {
		case ClassActive, ClassFree:
			g.cancelUnlockedSequences(p.Name)
		}
	}

	// Pai Gow owns these inputs only while seated; leave normal commands alone.
	if p != nil && g.Casino != nil {
		if t, playing := g.Casino.Participation(p.Name); playing && t != nil && t.Config.Game == casino.GamePaiGow {
			numeric := cmd != "" && cmd[0] >= '0' && cmd[0] <= '9'
			if numeric || cmd == "set" || cmd == "house" || cmd == "settle" || cmd == "autoset" {
				g.executeTableAction(sess, strings.Join(append([]string{cmd}, args...), " "))
				return
			}
		}
	}
	// Video poker: numeric tokens toggle holds and d draws, so both are
	// intercepted before the shared registry (where d means "down").
	_, pokerDigits := casino.ParsePokerDigits(cmd)
	if p != nil && g.Casino != nil && (cmd == "d" || pokerDigits) {
		if t, playing := g.Casino.Participation(p.Name); playing && t != nil && t.Config.Game == casino.GameVideoPoker {
			if cmd == "d" {
				if len(args) != 0 {
					sess.WriteLine("Use d or draw.")
					return
				}
				g.executeTableAction(sess, "draw")
				return
			}
			g.executeTableAction(sess, strings.Join(append([]string{cmd}, args...), " "))
			return
		}
	}
	if def, ok := commandRegistry[cmd]; ok {
		def.handler(g, sess, args, rawInput)
		return
	}

	obstacleVerbsMu.RLock()
	isObstacle := obstacleVerbs[cmd]
	obstacleVerbsMu.RUnlock()
	if isObstacle {
		g.doObstacle(sess, cmd)
		return
	}

	if a, ok := verbAliases[cmd]; ok {
		g.cancelAction(p)
		switch a {
		case behavior.TypeGather:
			if len(args) == 0 {
				target := g.defaultTarget(p.RoomID, cmd)
				if target == "" {
					sess.WriteLine(fmt.Sprintf("%s what?", cmd))
					return
				}
				g.startAction(sess, cmd, target)
			} else {
				g.startAction(sess, cmd, strings.Join(args, " "))
			}
		case behavior.TypeTalk:
			if len(args) == 0 {
				sess.WriteLine("Talk to whom?")
			} else {
				g.startAction(sess, "talk", strings.Join(args, " "))
			}
		default:
			// No handler for this alias: never return silently, or a typo'd
			// alias becomes an invisible no-op.
			sess.WriteLine("Unknown command.")
		}
		return
	}

	sess.WriteLine("Unknown command.")
}

func (g *Game) executeGather(sess *net.Session, args []string, rawInput string) {
	verb := strings.Fields(rawInput)[0]
	p := sess.Player
	g.cancelAction(p)
	if len(args) == 0 {
		target := g.defaultTarget(p.RoomID, verb)
		if target == "" {
			sess.WriteLine(fmt.Sprintf("%s what?", verb))
			return
		}
		g.startAction(sess, verb, target)
	} else {
		g.startAction(sess, verb, strings.Join(args, " "))
	}
}

func (g *Game) executeTalk(sess *net.Session, args []string, rawInput string) {
	p := sess.Player
	g.cancelAction(p)
	if len(args) == 0 {
		sess.WriteLine("Talk to whom?")
	} else {
		g.startAction(sess, "talk", strings.Join(args, " "))
	}
}