package d2term import ( "errors" "fmt" "image/color" "log" "math" "strings" "github.com/OpenDiablo2/OpenDiablo2/d2common/d2enum" "github.com/OpenDiablo2/OpenDiablo2/d2common/d2interface" "github.com/OpenDiablo2/OpenDiablo2/d2common/d2math" "github.com/OpenDiablo2/OpenDiablo2/d2common/d2util" ) const ( charWidth = 6 charHeight = 16 charDoubleWidth = charWidth * 2 rowCount = 24 rowCountMax = 32 colCountMax = 128 animLength = 0.5 ) const ( darkGrey = 0x2e3436b0 lightGrey = 0x555753b0 lightBlue = 0x3465a4b0 yellow = 0xfce94fb0 red = 0xcc0000b0 ) type visibility int const ( visHidden visibility = iota visShowing visShown visHiding ) const ( maxVisAnim = 1.0 minVisAnim = 0.0 ) type historyEntry struct { text string category d2enum.TermCategory } type commandEntry struct { description string arguments []string fn func([]string) error } // Terminal handles the in-game terminal type Terminal struct { outputHistory []historyEntry outputIndex int command string commandHistory []string commandIndex int lineCount int visState visibility visAnim float64 bgColor color.RGBA fgColor color.RGBA infoColor color.RGBA warningColor color.RGBA errorColor color.RGBA commands map[string]commandEntry } // NewTerminal creates and returns a terminal func NewTerminal() (*Terminal, error) { term := &Terminal{ lineCount: rowCount, bgColor: d2util.Color(darkGrey), fgColor: d2util.Color(lightGrey), infoColor: d2util.Color(lightBlue), warningColor: d2util.Color(yellow), errorColor: d2util.Color(red), commands: make(map[string]commandEntry), } term.Infof("::: OpenDiablo2 Terminal :::") term.Infof("type \"ls\" for a list of commands") if err := term.Bind("ls", "list available commands", nil, term.commandList); err != nil { return nil, err } if err := term.Bind("clear", "clear terminal", nil, term.commandClear); err != nil { return nil, err } return term, nil } // Bind binds commands to the terminal func (t *Terminal) Bind(name, description string, arguments []string, fn func(args []string) error) error { if name == "" || description == "" { return fmt.Errorf("missing name or description") } if _, ok := t.commands[name]; ok { t.Warningf("rebinding command with name: %s", name) } t.commands[name] = commandEntry{description, arguments, fn} return nil } // Unbind unbinds commands from the terminal func (t *Terminal) Unbind(names ...string) error { for _, name := range names { delete(t.commands, name) } return nil } // Advance advances the terminal animation func (t *Terminal) Advance(elapsed float64) error { switch t.visState { case visShowing: t.visAnim = math.Min(maxVisAnim, t.visAnim+elapsed/animLength) if t.visAnim == maxVisAnim { t.visState = visShown } case visHiding: t.visAnim = math.Max(minVisAnim, t.visAnim-elapsed/animLength) if t.visAnim == minVisAnim { t.visState = visHidden } } if !t.Visible() { return nil } return nil } // OnKeyDown handles key down in the terminal func (t *Terminal) OnKeyDown(event d2interface.KeyEvent) bool { if event.Key() == d2enum.KeyGraveAccent { t.toggle() } if !t.Visible() { return false } switch event.Key() { case d2enum.KeyEscape: t.command = "" case d2enum.KeyEnd: t.outputIndex = 0 case d2enum.KeyHome: t.outputIndex = d2math.MaxInt(0, len(t.outputHistory)-t.lineCount) case d2enum.KeyPageUp: maxOutputIndex := d2math.MaxInt(0, len(t.outputHistory)-t.lineCount) if t.outputIndex += t.lineCount; t.outputIndex >= maxOutputIndex { t.outputIndex = maxOutputIndex } case d2enum.KeyPageDown: if t.outputIndex -= t.lineCount; t.outputIndex < 0 { t.outputIndex = 0 } case d2enum.KeyUp, d2enum.KeyDown: t.handleControlKey(event.Key(), event.KeyMod()) case d2enum.KeyEnter: t.processCommand() case d2enum.KeyBackspace: if len(t.command) > 0 { t.command = t.command[:len(t.command)-1] } } return true } func (t *Terminal) processCommand() { if t.command == "" { return } n := 0 for _, command := range t.commandHistory { if command != t.command { t.commandHistory[n] = command n++ } } t.commandHistory = t.commandHistory[:n] t.commandHistory = append(t.commandHistory, t.command) t.Printf(t.command) if err := t.Execute(t.command); err != nil { t.Errorf(err.Error()) } t.commandIndex = len(t.commandHistory) - 1 t.command = "" } func (t *Terminal) handleControlKey(eventKey d2enum.Key, keyMod d2enum.KeyMod) { switch eventKey { case d2enum.KeyUp: if keyMod == d2enum.KeyModControl { t.lineCount = d2math.MaxInt(0, t.lineCount-1) } else if len(t.commandHistory) > 0 { t.command = t.commandHistory[t.commandIndex] if t.commandIndex == 0 { t.commandIndex = len(t.commandHistory) - 1 } else { t.commandIndex-- } } case d2enum.KeyDown: if keyMod == d2enum.KeyModControl { t.lineCount = d2math.MinInt(t.lineCount+1, rowCountMax) } } } // OnKeyChars handles char key in terminal func (t *Terminal) OnKeyChars(event d2interface.KeyCharsEvent) bool { if !t.Visible() { return false } var handled bool for _, c := range event.Chars() { if c != '`' { t.command += string(c) handled = true } } return handled } // Render renders the terminal func (t *Terminal) Render(surface d2interface.Surface) error { if !t.Visible() { return nil } totalWidth, _ := surface.GetSize() outputHeight := t.lineCount * charHeight totalHeight := outputHeight + charHeight offset := -int((1.0 - easeInOut(t.visAnim)) * float64(totalHeight)) surface.PushTranslation(0, offset) surface.DrawRect(totalWidth, outputHeight, t.bgColor) for i := 0; i < t.lineCount; i++ { historyIndex := len(t.outputHistory) - i - t.outputIndex - 1 if historyIndex < 0 { break } entry := t.outputHistory[historyIndex] surface.PushTranslation(charDoubleWidth, outputHeight-(i+1)*charHeight) surface.DrawTextf(entry.text) surface.PushTranslation(-charDoubleWidth, 0) switch entry.category { case d2enum.TermCategoryInfo: surface.DrawRect(charWidth, charHeight, t.infoColor) case d2enum.TermCategoryWarning: surface.DrawRect(charWidth, charHeight, t.warningColor) case d2enum.TermCategoryError: surface.DrawRect(charWidth, charHeight, t.errorColor) } surface.Pop() surface.Pop() } surface.PushTranslation(0, outputHeight) surface.DrawRect(totalWidth, charHeight, t.fgColor) surface.DrawTextf("> " + t.command) surface.Pop() surface.Pop() return nil } // Execute executes a command with arguments func (t *Terminal) Execute(command string) error { params := parseCommand(command) if len(params) == 0 { return errors.New("invalid command") } name := params[0] args := params[1:] entry, ok := t.commands[name] if !ok { return errors.New("command not found") } if len(args) != len(entry.arguments) { return errors.New("command requires different argument count") } if err := entry.fn(args); err != nil { return err } return nil } // Rawf writes a raw message to the terminal func (t *Terminal) Rawf(category d2enum.TermCategory, format string, params ...interface{}) { text := fmt.Sprintf(format, params...) lines := d2util.SplitIntoLinesWithMaxWidth(text, colCountMax) for _, line := range lines { // removes color token (this token ends with [0m ) l := strings.Split(line, "\033[0m") line = l[len(l)-1] t.outputHistory = append(t.outputHistory, historyEntry{line, category}) } } // Printf writes a message to the terminal func (t *Terminal) Printf(format string, params ...interface{}) { t.Rawf(d2enum.TermCategoryNone, format, params...) } // Infof writes a warning message to the terminal func (t *Terminal) Infof(format string, params ...interface{}) { t.Rawf(d2enum.TermCategoryInfo, format, params...) } // Warningf writes a warning message to the terminal func (t *Terminal) Warningf(format string, params ...interface{}) { t.Rawf(d2enum.TermCategoryWarning, format, params...) } // Errorf writes a error message to the terminal func (t *Terminal) Errorf(format string, params ...interface{}) { t.Rawf(d2enum.TermCategoryError, format, params...) } // Clear clears the terminal func (t *Terminal) Clear() { t.outputHistory = nil t.outputIndex = 0 } // Visible returns visible state func (t *Terminal) Visible() bool { return t.visState != visHidden } // Hide hides the terminal func (t *Terminal) Hide() { if t.visState != visHidden { t.visState = visHiding } } // Show shows the terminal func (t *Terminal) Show() { if t.visState != visShown { t.visState = visShowing } } func (t *Terminal) toggle() { if t.visState == visHiding || t.visState == visHidden { t.Show() return } t.Hide() } // BindLogger binds a log.Writer to the output func (t *Terminal) BindLogger() { log.SetOutput(&terminalLogger{writer: log.Writer(), terminal: t}) } func easeInOut(t float64) float64 { t *= 2 if t < 1 { return 0.5 * t * t * t * t } t -= 2 return -0.5 * (t*t*t*t - 2) } func parseCommand(command string) []string { var ( quoted bool escape bool param string params []string ) for _, c := range command { switch c { case '"': if escape { param += string(c) escape = false } else { quoted = !quoted } case ' ': if quoted { param += string(c) } else if len(param) > 0 { params = append(params, param) param = "" } case '\\': if escape { param += string(c) escape = false } else { escape = true } default: param += string(c) } } if len(param) > 0 { params = append(params, param) } return params }