warpscan.go

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
	"time"
)

// --- Interactive exact-value memory search (opt-in via -search) ---
//
// A minimal Cheat-Engine-style scanner for finding small state values (e.g. the
// selected episode and the world/painting id on the episode-select screen).
// Works on single bytes.
//
// Commands:
//   n <v>      new scan: addresses whose byte == <v>
//   n          new snapshot (unknown value) — then use inc/dec/diff/same
//   <v>        next scan: keep addresses whose byte == <v>
//   inc/dec    keep addresses whose value increased/decreased since last scan
//   diff/same  keep addresses whose value changed/stayed
//   le/ge <n>  keep addresses whose current value is <= / >= <n>
//   l          list current candidates (up to 40)
//   r <hex>    read the byte at a GC address (e.g. r 80A01C9B)
//   d <hex> <len>  hex-dump <len> bytes from a GC address
//   q          quit

const (
	searchRAMStart = 0x80000000
	searchBlock    = 0x400000
	searchBlocks   = 6 // 24 MB
)

func readAllRAM() []byte {
	buf := make([]byte, searchBlock*searchBlocks)
	for i := 0; i < searchBlocks; i++ {
		d, err := dm.Read(uint32(searchRAMStart)+uint32(i*searchBlock), searchBlock)
		if err == nil && d != nil {
			copy(buf[i*searchBlock:], d)
		}
	}
	return buf
}

func parseHexAddr(s string) (uint32, bool) {
	a, err := strconv.ParseUint(strings.TrimPrefix(s, "0x"), 16, 32)
	if err != nil {
		return 0, false
	}
	return uint32(a), true
}

// init dispatches the interactive search tool when -search is passed, so main.go
// carries no reference to it (this file stays uncommitted/local).
func init() {
	for _, a := range os.Args[1:] {
		if a == "-search" || a == "search" {
			RunSearch()
			os.Exit(0)
		}
	}
}

func RunSearch() {
	globalCfg = LoadConfig()
	fmt.Println("[SEARCH] waiting for Dolphin...")
	for !dm.IsHooked {
		if !dm.Hook() {
			time.Sleep(1 * time.Second)
			continue
		}
	}
	fmt.Println("[SEARCH] hooked. n <v> | n | <v> | inc | dec | diff | same | le/ge <n> | l | r <hex> | d <hex> <len> | q")

	var cands []uint32
	var prev []byte
	isAll := false  // true = candidate set is "everything" (right after `n` snapshot)
	haveScan := false

	report := func() {
		if isAll {
			fmt.Println("[SEARCH] snapshot taken (unknown value). Change it in-game, then: inc/dec/diff/same")
			return
		}
		fmt.Printf("[SEARCH] %d candidate(s)\n", len(cands))
		if len(cands) <= 40 {
			for _, a := range cands {
				off := int(a - searchRAMStart)
				v := byte(0)
				if off >= 0 && off < len(prev) {
					v = prev[off]
				}
				fmt.Printf("    0x%08X = %d\n", a, v)
			}
		}
	}

	// applyFilter narrows candidates by keep(oldVal, newVal).
	applyFilter := func(cur []byte, keep func(old, nw byte) bool) {
		var next []uint32
		if isAll {
			for i := 0; i < len(cur) && i < len(prev); i++ {
				if keep(prev[i], cur[i]) {
					next = append(next, uint32(searchRAMStart+i))
				}
			}
		} else {
			for _, a := range cands {
				off := int(a - searchRAMStart)
				if off >= 0 && off < len(cur) && keep(prev[off], cur[off]) {
					next = append(next, a)
				}
			}
		}
		cands = next
		isAll = false
		prev = cur
	}

	sc := bufio.NewScanner(os.Stdin)
	fmt.Print("> ")
	for sc.Scan() {
		fields := strings.Fields(strings.TrimSpace(sc.Text()))
		if len(fields) == 0 {
			fmt.Print("> ")
			continue
		}
		cmd := fields[0]

		switch {
		case cmd == "q":
			return

		case cmd == "l":
			report()

		case cmd == "r" && len(fields) == 2:
			addr, ok := parseHexAddr(fields[1])
			if !ok {
				fmt.Println("bad address")
				break
			}
			d, err := dm.Read(addr, 1)
			if err != nil || d == nil {
				fmt.Println("read failed")
				break
			}
			fmt.Printf("    0x%08X = %d\n", addr, d[0])

		case cmd == "d" && len(fields) == 3:
			addr, ok := parseHexAddr(fields[1])
			n, err := strconv.Atoi(fields[2])
			if !ok || err != nil || n <= 0 || n > 512 {
				fmt.Println("usage: d <hexaddr> <len 1-512>")
				break
			}
			d, err := dm.Read(addr, n)
			if err != nil || d == nil {
				fmt.Println("read failed")
				break
			}
			for off := 0; off < len(d); off += 16 {
				end := off + 16
				if end > len(d) {
					end = len(d)
				}
				fmt.Printf("    0x%08X  % X\n", addr+uint32(off), d[off:end])
			}

		case cmd == "n" && len(fields) == 2:
			v, err := strconv.Atoi(fields[1])
			if err != nil || v < 0 || v > 255 {
				fmt.Println("value must be 0-255")
				break
			}
			cur := readAllRAM()
			cands = nil
			for i := 0; i < len(cur); i++ {
				if cur[i] == byte(v) {
					cands = append(cands, uint32(searchRAMStart+i))
				}
			}
			isAll = false
			prev = cur
			haveScan = true
			report()

		case cmd == "n":
			prev = readAllRAM()
			cands = nil
			isAll = true
			haveScan = true
			report()

		case cmd == "inc" || cmd == "dec" || cmd == "diff" || cmd == "same":
			if !haveScan {
				fmt.Println("do a `n` scan first")
				break
			}
			cur := readAllRAM()
			applyFilter(cur, func(old, nw byte) bool {
				switch cmd {
				case "inc":
					return nw > old
				case "dec":
					return nw < old
				case "diff":
					return nw != old
				default:
					return nw == old
				}
			})
			report()

		case (cmd == "le" || cmd == "ge") && len(fields) == 2:
			if !haveScan {
				fmt.Println("do a `n` scan first")
				break
			}
			n, err := strconv.Atoi(fields[1])
			if err != nil {
				fmt.Println("bad number")
				break
			}
			cur := readAllRAM()
			applyFilter(cur, func(_, nw byte) bool {
				if cmd == "le" {
					return int(nw) <= n
				}
				return int(nw) >= n
			})
			report()

		default: // bare number -> exact filter
			v, err := strconv.Atoi(cmd)
			if err != nil || v < 0 || v > 255 {
				fmt.Println("unknown command")
				break
			}
			if !haveScan {
				fmt.Println("do a `n` scan first")
				break
			}
			cur := readAllRAM()
			applyFilter(cur, func(_, nw byte) bool { return nw == byte(v) })
			report()
		}
		fmt.Print("> ")
	}
}