gravestench/OpenDiablo2
1
1
Fork 0
mirror of https://github.com/OpenDiablo2/OpenDiablo2 synced 2024-06-19 21:55:24 +00:00
Code Issues Releases Wiki Activity

moving enumerations out of d2interface (#552)

Browse Source 
* moved filter constants back to d2enum

* moving key and mouse button enums into d2enum

* moving render type enum into d2enum

* moving input even priority enums into d2enum

* moving terminal enums into d2enum
This commit is contained in:
dk 2020-07-06 18:26:08 -07:00 committed by GitHub
parent 473a0b3b19
commit 60e6fcb7ac
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
37 changed files with 305 additions and 281 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
d2common/d2interface/filter.go → d2common/d2enum/filter.go
View File

@ -1,4 +1,4 @@
package d2interface package d2enum
// Filter represents the type of texture filter to be used when an image is magnified or minified. // Filter represents the type of texture filter to be used when an image is magnified or minified.
type Filter int type Filter int

2
d2common/d2interface/input_button.go → d2common/d2enum/input_button.go
View File

@ -1,4 +1,4 @@
package d2interface package d2enum
// MouseButton represents a traditional 3-button mouse // MouseButton represents a traditional 3-button mouse
type MouseButton int type MouseButton int

2
d2common/d2interface/input_key.go → d2common/d2enum/input_key.go
View File

@ -1,4 +1,4 @@
package d2interface package d2enum
// Key represents button on a traditional keyboard. // Key represents button on a traditional keyboard.
type Key int type Key int

2
d2common/d2interface/input_priority.go → d2common/d2enum/input_priority.go
View File

@ -1,4 +1,4 @@
package d2interface package d2enum
// Priority of the event handler // Priority of the event handler
type Priority int type Priority int

2
d2common/d2interface/render_type.go → d2common/d2enum/render_type.go
View File

@ -1,4 +1,4 @@
package d2interface package d2enum
// RenderType defines the type of rendering engine to use // RenderType defines the type of rendering engine to use
type RenderType int type RenderType int

12
d2common/d2enum/terminal_category.go Normal file
View File

@ -0,0 +1,12 @@
package d2enum
// TermCategory applies styles to the lines in the Terminal
type TermCategory int
// Terminal Category types
const (
TermCategoryNone TermCategory = iota
TermCategoryInfo
TermCategoryWarning
TermCategoryError
)

10
d2common/d2interface/input_events.go
View File

@ -1,9 +1,11 @@
package d2interface package d2interface
import "github.com/OpenDiablo2/OpenDiablo2/d2common/d2enum"
// HandlerEvent holds the qualifiers for a key or mouse event // HandlerEvent holds the qualifiers for a key or mouse event
type HandlerEvent interface { type HandlerEvent interface {
KeyMod() KeyMod KeyMod() d2enum.KeyMod
ButtonMod() MouseButtonMod ButtonMod() d2enum.MouseButtonMod
X() int X() int
Y() int Y() int
} }
@ -11,7 +13,7 @@ type HandlerEvent interface {
// KeyEvent represents an event associated with a keyboard key // KeyEvent represents an event associated with a keyboard key
type KeyEvent interface { type KeyEvent interface {
HandlerEvent HandlerEvent
Key() Key Key() d2enum.Key
// Duration represents the number of frames this key has been pressed for // Duration represents the number of frames this key has been pressed for
Duration() int Duration() int
} }
@ -25,7 +27,7 @@ type KeyCharsEvent interface {
// MouseEvent represents a mouse event // MouseEvent represents a mouse event
type MouseEvent interface { type MouseEvent interface {
HandlerEvent HandlerEvent
Button() MouseButton Button() d2enum.MouseButton
} }
// MouseMoveEvent represents a mouse movement event // MouseMoveEvent represents a mouse movement event

4
d2common/d2interface/input_manager.go
View File

@ -1,9 +1,11 @@
package d2interface package d2interface
import "github.com/OpenDiablo2/OpenDiablo2/d2common/d2enum"
// InputManager manages an InputService // InputManager manages an InputService
type InputManager interface { type InputManager interface {
Advance(elapsedTime, currentTime float64) error Advance(elapsedTime, currentTime float64) error
BindHandlerWithPriority(InputEventHandler, Priority) error BindHandlerWithPriority(InputEventHandler, d2enum.Priority) error
BindHandler(h InputEventHandler) error BindHandler(h InputEventHandler) error
UnbindHandler(handler InputEventHandler) error UnbindHandler(handler InputEventHandler) error
} }

16
d2common/d2interface/input_service.go
View File

@ -1,5 +1,7 @@
package d2interface package d2interface
import "github.com/OpenDiablo2/OpenDiablo2/d2common/d2enum"
// InputService represents an interface offering Keyboard and Mouse interactions. // InputService represents an interface offering Keyboard and Mouse interactions.
type InputService interface { type InputService interface {
// CursorPosition returns a position of a mouse cursor relative to the game screen (window). // CursorPosition returns a position of a mouse cursor relative to the game screen (window).
@ -7,17 +9,17 @@ type InputService interface {
// InputChars return "printable" runes read from the keyboard at the time update is called. // InputChars return "printable" runes read from the keyboard at the time update is called.
InputChars() []rune InputChars() []rune
// IsKeyPressed checks if the provided key is down. // IsKeyPressed checks if the provided key is down.
IsKeyPressed(key Key) bool IsKeyPressed(key d2enum.Key) bool
// IsKeyJustPressed checks if the provided key is just transitioned from up to down. // IsKeyJustPressed checks if the provided key is just transitioned from up to down.
IsKeyJustPressed(key Key) bool IsKeyJustPressed(key d2enum.Key) bool
// IsKeyJustReleased checks if the provided key is just transitioned from down to up. // IsKeyJustReleased checks if the provided key is just transitioned from down to up.
IsKeyJustReleased(key Key) bool IsKeyJustReleased(key d2enum.Key) bool
// IsMouseButtonPressed checks if the provided mouse button is down. // IsMouseButtonPressed checks if the provided mouse button is down.
IsMouseButtonPressed(button MouseButton) bool IsMouseButtonPressed(button d2enum.MouseButton) bool
// IsMouseButtonJustPressed checks if the provided mouse button is just transitioned from up to down. // IsMouseButtonJustPressed checks if the provided mouse button is just transitioned from up to down.
IsMouseButtonJustPressed(button MouseButton) bool IsMouseButtonJustPressed(button d2enum.MouseButton) bool
// IsMouseButtonJustReleased checks if the provided mouse button is just transitioned from down to up. // IsMouseButtonJustReleased checks if the provided mouse button is just transitioned from down to up.
IsMouseButtonJustReleased(button MouseButton) bool IsMouseButtonJustReleased(button d2enum.MouseButton) bool
// KeyPressDuration returns how long the key is pressed in frames. // KeyPressDuration returns how long the key is pressed in frames.
KeyPressDuration(key Key) int KeyPressDuration(key d2enum.Key) int
} }

4
d2common/d2interface/renderer.go
View File

@ -1,5 +1,7 @@
package d2interface package d2interface
import "github.com/OpenDiablo2/OpenDiablo2/d2common/d2enum"
// Renderer interface defines the functionality of a renderer // Renderer interface defines the functionality of a renderer
type Renderer interface { type Renderer interface {
GetRendererName() string GetRendererName() string
@ -7,7 +9,7 @@ type Renderer interface {
Run(f func(Surface) error, width, height int, title string) error Run(f func(Surface) error, width, height int, title string) error
IsDrawingSkipped() bool IsDrawingSkipped() bool
CreateSurface(surface Surface) (Surface, error) CreateSurface(surface Surface) (Surface, error)
NewSurface(width, height int, filter Filter) (Surface, error) NewSurface(width, height int, filter d2enum.Filter) (Surface, error)
IsFullScreen() bool IsFullScreen() bool
SetFullScreen(fullScreen bool) SetFullScreen(fullScreen bool)
SetVSyncEnabled(vsync bool) SetVSyncEnabled(vsync bool)

2
d2common/d2interface/surface.go
View File

@ -19,7 +19,7 @@ type Surface interface {
PopN(n int) PopN(n int)
PushColor(color color.Color) PushColor(color color.Color)
PushCompositeMode(mode d2enum.CompositeMode) PushCompositeMode(mode d2enum.CompositeMode)
PushFilter(filter Filter) PushFilter(filter d2enum.Filter)
PushTranslation(x, y int) PushTranslation(x, y int)
PushBrightness(brightness float64) PushBrightness(brightness float64)
Render(surface Surface) error Render(surface Surface) error

13
d2common/d2interface/terminal.go
View File

@ -1,15 +1,6 @@
package d2interface package d2interface
// TermCategory applies styles to the lines in the Terminal import "github.com/OpenDiablo2/OpenDiablo2/d2common/d2enum"
type TermCategory int
// Terminal Category types
const (
TermCategoryNone TermCategory = iota
TermCategoryInfo
TermCategoryWarning
TermCategoryError
)
// Terminal is a drop-down terminal and shell // Terminal is a drop-down terminal and shell
// It is used throughout the codebase, most parts of the engine will // It is used throughout the codebase, most parts of the engine will
@ -22,7 +13,7 @@ type Terminal interface {
OnKeyChars(event KeyCharsEvent) bool OnKeyChars(event KeyCharsEvent) bool
Render(surface Surface) error Render(surface Surface) error
Execute(command string) error Execute(command string) error
OutputRaw(text string, category TermCategory) OutputRaw(text string, category d2enum.TermCategory)
Outputf(format string, params ...interface{}) Outputf(format string, params ...interface{})
OutputInfof(format string, params ...interface{}) OutputInfof(format string, params ...interface{})
OutputWarningf(format string, params ...interface{}) OutputWarningf(format string, params ...interface{})

3
d2core/d2asset/dc6_animation.go
View File

@ -2,6 +2,7 @@ package d2asset
import ( import (
"errors" "errors"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2enum"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2fileformats/d2dcc" "github.com/OpenDiablo2/OpenDiablo2/d2common/d2fileformats/d2dcc"
d2iface "github.com/OpenDiablo2/OpenDiablo2/d2common/d2interface" d2iface "github.com/OpenDiablo2/OpenDiablo2/d2common/d2interface"
@ -75,7 +76,7 @@ func (a *DC6Animation) decodeDirection(directionIndex int) error {
dc6Frame := dc6.Frames[startFrame+i] dc6Frame := dc6.Frames[startFrame+i]
sfc, err := a.renderer.NewSurface(int(dc6Frame.Width), int(dc6Frame.Height), sfc, err := a.renderer.NewSurface(int(dc6Frame.Width), int(dc6Frame.Height),
d2iface.FilterNearest) d2enum.FilterNearest)
if err != nil { if err != nil {
return err return err
} }

3
d2core/d2asset/dcc_animation.go
View File

@ -2,6 +2,7 @@ package d2asset
import ( import (
"errors" "errors"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2enum"
"math" "math"
"github.com/OpenDiablo2/OpenDiablo2/d2common" "github.com/OpenDiablo2/OpenDiablo2/d2common"
@ -118,7 +119,7 @@ func (a *DCCAnimation) decodeDirection(directionIndex int) error {
} }
} }
sfc, err := a.renderer.NewSurface(frameWidth, frameHeight, d2iface.FilterNearest) sfc, err := a.renderer.NewSurface(frameWidth, frameHeight, d2enum.FilterNearest)
if err != nil { if err != nil {
return err return err
} }

3
d2core/d2gui/button.go
View File

@ -2,6 +2,7 @@ package d2gui
import ( import (
"errors" "errors"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2enum"
"image/color" "image/color"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2interface" "github.com/OpenDiablo2/OpenDiablo2/d2common/d2interface"
@ -71,7 +72,7 @@ func createButton(renderer d2interface.Renderer, text string, buttonStyle Button
surfaceCount := animation.GetFrameCount() / (config.segmentsX * config.segmentsY) surfaceCount := animation.GetFrameCount() / (config.segmentsX * config.segmentsY)
surfaces := make([]d2interface.Surface, surfaceCount) surfaces := make([]d2interface.Surface, surfaceCount)
for i := 0; i < surfaceCount; i++ { for i := 0; i < surfaceCount; i++ {
surface, err := renderer.NewSurface(buttonWidth, buttonHeight, d2interface.FilterNearest) surface, err := renderer.NewSurface(buttonWidth, buttonHeight, d2enum.FilterNearest)
if err != nil { if err != nil {
return nil, err return nil, err
} }

3
d2core/d2gui/label.go
View File

@ -1,6 +1,7 @@
package d2gui package d2gui
import ( import (
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2enum"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2interface" "github.com/OpenDiablo2/OpenDiablo2/d2common/d2interface"
) )
@ -51,7 +52,7 @@ func (l *Label) SetText(text string) error {
func (l *Label) setText(text string) error { func (l *Label) setText(text string) error {
width, height := l.font.GetTextMetrics(text) width, height := l.font.GetTextMetrics(text)
surface, err := l.renderer.NewSurface(width, height, d2interface.FilterNearest) surface, err := l.renderer.NewSurface(width, height, d2enum.FilterNearest)
if err != nil { if err != nil {
return err return err
} }

5
d2core/d2input/d2input.go
View File

@ -2,6 +2,7 @@ package d2input
import ( import (
"errors" "errors"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2enum"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2interface" "github.com/OpenDiablo2/OpenDiablo2/d2common/d2interface"
@ -32,13 +33,13 @@ func Advance(elapsed, current float64) error {
} }
// BindHandlerWithPriority adds an event handler with a specific call priority // BindHandlerWithPriority adds an event handler with a specific call priority
func BindHandlerWithPriority(handler d2interface.InputEventHandler, priority d2interface.Priority) error { func BindHandlerWithPriority(handler d2interface.InputEventHandler, priority d2enum.Priority) error {
return singleton.BindHandlerWithPriority(handler, priority) return singleton.BindHandlerWithPriority(handler, priority)
} }
// BindHandler adds an event handler // BindHandler adds an event handler
func BindHandler(handler d2interface.InputEventHandler) error { func BindHandler(handler d2interface.InputEventHandler) error {
return BindHandlerWithPriority(handler, d2interface.PriorityDefault) return BindHandlerWithPriority(handler, d2enum.PriorityDefault)
} }
// UnbindHandler removes a previously bound event handler // UnbindHandler removes a previously bound event handler

226
d2core/d2input/ebiten/ebiten_input.go
View File

@ -2,120 +2,120 @@
package ebiten package ebiten
import ( import (
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2interface" "github.com/OpenDiablo2/OpenDiablo2/d2common/d2enum"
"github.com/hajimehoshi/ebiten" "github.com/hajimehoshi/ebiten"
"github.com/hajimehoshi/ebiten/inpututil" "github.com/hajimehoshi/ebiten/inpututil"
) )
var ( var (
//nolint:gochecknoglobals This is a constant in all but by name, no constant map in go //nolint:gochecknoglobals This is a constant in all but by name, no constant map in go
keyToEbiten = map[d2interface.Key]ebiten.Key{ keyToEbiten = map[d2enum.Key]ebiten.Key{
d2interface.Key0: ebiten.Key0, d2enum.Key0: ebiten.Key0,
d2interface.Key1: ebiten.Key1, d2enum.Key1: ebiten.Key1,
d2interface.Key2: ebiten.Key2, d2enum.Key2: ebiten.Key2,
d2interface.Key3: ebiten.Key3, d2enum.Key3: ebiten.Key3,
d2interface.Key4: ebiten.Key4, d2enum.Key4: ebiten.Key4,
d2interface.Key5: ebiten.Key5, d2enum.Key5: ebiten.Key5,
d2interface.Key6: ebiten.Key6, d2enum.Key6: ebiten.Key6,
d2interface.Key7: ebiten.Key7, d2enum.Key7: ebiten.Key7,
d2interface.Key8: ebiten.Key8, d2enum.Key8: ebiten.Key8,
d2interface.Key9: ebiten.Key9, d2enum.Key9: ebiten.Key9,
d2interface.KeyA: ebiten.KeyA, d2enum.KeyA: ebiten.KeyA,
d2interface.KeyB: ebiten.KeyB, d2enum.KeyB: ebiten.KeyB,
d2interface.KeyC: ebiten.KeyC, d2enum.KeyC: ebiten.KeyC,
d2interface.KeyD: ebiten.KeyD, d2enum.KeyD: ebiten.KeyD,
d2interface.KeyE: ebiten.KeyE, d2enum.KeyE: ebiten.KeyE,
d2interface.KeyF: ebiten.KeyF, d2enum.KeyF: ebiten.KeyF,
d2interface.KeyG: ebiten.KeyG, d2enum.KeyG: ebiten.KeyG,
d2interface.KeyH: ebiten.KeyH, d2enum.KeyH: ebiten.KeyH,
d2interface.KeyI: ebiten.KeyI, d2enum.KeyI: ebiten.KeyI,
d2interface.KeyJ: ebiten.KeyJ, d2enum.KeyJ: ebiten.KeyJ,
d2interface.KeyK: ebiten.KeyK, d2enum.KeyK: ebiten.KeyK,
d2interface.KeyL: ebiten.KeyL, d2enum.KeyL: ebiten.KeyL,
d2interface.KeyM: ebiten.KeyM, d2enum.KeyM: ebiten.KeyM,
d2interface.KeyN: ebiten.KeyN, d2enum.KeyN: ebiten.KeyN,
d2interface.KeyO: ebiten.KeyO, d2enum.KeyO: ebiten.KeyO,
d2interface.KeyP: ebiten.KeyP, d2enum.KeyP: ebiten.KeyP,
d2interface.KeyQ: ebiten.KeyQ, d2enum.KeyQ: ebiten.KeyQ,
d2interface.KeyR: ebiten.KeyR, d2enum.KeyR: ebiten.KeyR,
d2interface.KeyS: ebiten.KeyS, d2enum.KeyS: ebiten.KeyS,
d2interface.KeyT: ebiten.KeyT, d2enum.KeyT: ebiten.KeyT,
d2interface.KeyU: ebiten.KeyU, d2enum.KeyU: ebiten.KeyU,
d2interface.KeyV: ebiten.KeyV, d2enum.KeyV: ebiten.KeyV,
d2interface.KeyW: ebiten.KeyW, d2enum.KeyW: ebiten.KeyW,
d2interface.KeyX: ebiten.KeyX, d2enum.KeyX: ebiten.KeyX,
d2interface.KeyY: ebiten.KeyY, d2enum.KeyY: ebiten.KeyY,
d2interface.KeyZ: ebiten.KeyZ, d2enum.KeyZ: ebiten.KeyZ,
d2interface.KeyApostrophe: ebiten.KeyApostrophe, d2enum.KeyApostrophe: ebiten.KeyApostrophe,
d2interface.KeyBackslash: ebiten.KeyBackslash, d2enum.KeyBackslash: ebiten.KeyBackslash,
d2interface.KeyBackspace: ebiten.KeyBackspace, d2enum.KeyBackspace: ebiten.KeyBackspace,
d2interface.KeyCapsLock: ebiten.KeyCapsLock, d2enum.KeyCapsLock: ebiten.KeyCapsLock,
d2interface.KeyComma: ebiten.KeyComma, d2enum.KeyComma: ebiten.KeyComma,
d2interface.KeyDelete: ebiten.KeyDelete, d2enum.KeyDelete: ebiten.KeyDelete,
d2interface.KeyDown: ebiten.KeyDown, d2enum.KeyDown: ebiten.KeyDown,
d2interface.KeyEnd: ebiten.KeyEnd, d2enum.KeyEnd: ebiten.KeyEnd,
d2interface.KeyEnter: ebiten.KeyEnter, d2enum.KeyEnter: ebiten.KeyEnter,
d2interface.KeyEqual: ebiten.KeyEqual, d2enum.KeyEqual: ebiten.KeyEqual,
d2interface.KeyEscape: ebiten.KeyEscape, d2enum.KeyEscape: ebiten.KeyEscape,
d2interface.KeyF1: ebiten.KeyF1, d2enum.KeyF1: ebiten.KeyF1,
d2interface.KeyF2: ebiten.KeyF2, d2enum.KeyF2: ebiten.KeyF2,
d2interface.KeyF3: ebiten.KeyF3, d2enum.KeyF3: ebiten.KeyF3,
d2interface.KeyF4: ebiten.KeyF4, d2enum.KeyF4: ebiten.KeyF4,
d2interface.KeyF5: ebiten.KeyF5, d2enum.KeyF5: ebiten.KeyF5,
d2interface.KeyF6: ebiten.KeyF6, d2enum.KeyF6: ebiten.KeyF6,
d2interface.KeyF7: ebiten.KeyF7, d2enum.KeyF7: ebiten.KeyF7,
d2interface.KeyF8: ebiten.KeyF8, d2enum.KeyF8: ebiten.KeyF8,
d2interface.KeyF9: ebiten.KeyF9, d2enum.KeyF9: ebiten.KeyF9,
d2interface.KeyF10: ebiten.KeyF10, d2enum.KeyF10: ebiten.KeyF10,
d2interface.KeyF11: ebiten.KeyF11, d2enum.KeyF11: ebiten.KeyF11,
d2interface.KeyF12: ebiten.KeyF12, d2enum.KeyF12: ebiten.KeyF12,
d2interface.KeyGraveAccent: ebiten.KeyGraveAccent, d2enum.KeyGraveAccent: ebiten.KeyGraveAccent,
d2interface.KeyHome: ebiten.KeyHome, d2enum.KeyHome: ebiten.KeyHome,
d2interface.KeyInsert: ebiten.KeyInsert, d2enum.KeyInsert: ebiten.KeyInsert,
d2interface.KeyKP0: ebiten.KeyKP0, d2enum.KeyKP0: ebiten.KeyKP0,
d2interface.KeyKP1: ebiten.KeyKP1, d2enum.KeyKP1: ebiten.KeyKP1,
d2interface.KeyKP2: ebiten.KeyKP2, d2enum.KeyKP2: ebiten.KeyKP2,
d2interface.KeyKP3: ebiten.KeyKP3, d2enum.KeyKP3: ebiten.KeyKP3,
d2interface.KeyKP4: ebiten.KeyKP4, d2enum.KeyKP4: ebiten.KeyKP4,
d2interface.KeyKP5: ebiten.KeyKP5, d2enum.KeyKP5: ebiten.KeyKP5,
d2interface.KeyKP6: ebiten.KeyKP6, d2enum.KeyKP6: ebiten.KeyKP6,
d2interface.KeyKP7: ebiten.KeyKP7, d2enum.KeyKP7: ebiten.KeyKP7,
d2interface.KeyKP8: ebiten.KeyKP8, d2enum.KeyKP8: ebiten.KeyKP8,
d2interface.KeyKP9: ebiten.KeyKP9, d2enum.KeyKP9: ebiten.KeyKP9,
d2interface.KeyKPAdd: ebiten.KeyKPAdd, d2enum.KeyKPAdd: ebiten.KeyKPAdd,
d2interface.KeyKPDecimal: ebiten.KeyKPDecimal, d2enum.KeyKPDecimal: ebiten.KeyKPDecimal,
d2interface.KeyKPDivide: ebiten.KeyKPDivide, d2enum.KeyKPDivide: ebiten.KeyKPDivide,
d2interface.KeyKPEnter: ebiten.KeyKPEnter, d2enum.KeyKPEnter: ebiten.KeyKPEnter,
d2interface.KeyKPEqual: ebiten.KeyKPEqual, d2enum.KeyKPEqual: ebiten.KeyKPEqual,
d2interface.KeyKPMultiply: ebiten.KeyKPMultiply, d2enum.KeyKPMultiply: ebiten.KeyKPMultiply,
d2interface.KeyKPSubtract: ebiten.KeyKPSubtract, d2enum.KeyKPSubtract: ebiten.KeyKPSubtract,
d2interface.KeyLeft: ebiten.KeyLeft, d2enum.KeyLeft: ebiten.KeyLeft,
d2interface.KeyLeftBracket: ebiten.KeyLeftBracket, d2enum.KeyLeftBracket: ebiten.KeyLeftBracket,
d2interface.KeyMenu: ebiten.KeyMenu, d2enum.KeyMenu: ebiten.KeyMenu,
d2interface.KeyMinus: ebiten.KeyMinus, d2enum.KeyMinus: ebiten.KeyMinus,
d2interface.KeyNumLock: ebiten.KeyNumLock, d2enum.KeyNumLock: ebiten.KeyNumLock,
d2interface.KeyPageDown: ebiten.KeyPageDown, d2enum.KeyPageDown: ebiten.KeyPageDown,
d2interface.KeyPageUp: ebiten.KeyPageUp, d2enum.KeyPageUp: ebiten.KeyPageUp,
d2interface.KeyPause: ebiten.KeyPause, d2enum.KeyPause: ebiten.KeyPause,
d2interface.KeyPeriod: ebiten.KeyPeriod, d2enum.KeyPeriod: ebiten.KeyPeriod,
d2interface.KeyPrintScreen: ebiten.KeyPrintScreen, d2enum.KeyPrintScreen: ebiten.KeyPrintScreen,
d2interface.KeyRight: ebiten.KeyRight, d2enum.KeyRight: ebiten.KeyRight,
d2interface.KeyRightBracket: ebiten.KeyRightBracket, d2enum.KeyRightBracket: ebiten.KeyRightBracket,
d2interface.KeyScrollLock: ebiten.KeyScrollLock, d2enum.KeyScrollLock: ebiten.KeyScrollLock,
d2interface.KeySemicolon: ebiten.KeySemicolon, d2enum.KeySemicolon: ebiten.KeySemicolon,
d2interface.KeySlash: ebiten.KeySlash, d2enum.KeySlash: ebiten.KeySlash,
d2interface.KeySpace: ebiten.KeySpace, d2enum.KeySpace: ebiten.KeySpace,
d2interface.KeyTab: ebiten.KeyTab, d2enum.KeyTab: ebiten.KeyTab,
d2interface.KeyUp: ebiten.KeyUp, d2enum.KeyUp: ebiten.KeyUp,
d2interface.KeyAlt: ebiten.KeyAlt, d2enum.KeyAlt: ebiten.KeyAlt,
d2interface.KeyControl: ebiten.KeyControl, d2enum.KeyControl: ebiten.KeyControl,
d2interface.KeyShift: ebiten.KeyShift, d2enum.KeyShift: ebiten.KeyShift,
} }
//nolint:gochecknoglobals This is a constant in all but by name, no constant map in go //nolint:gochecknoglobals This is a constant in all but by name, no constant map in go
mouseButtonToEbiten = map[d2interface.MouseButton]ebiten.MouseButton{ mouseButtonToEbiten = map[d2enum.MouseButton]ebiten.MouseButton{
d2interface.MouseButtonLeft: ebiten.MouseButtonLeft, d2enum.MouseButtonLeft: ebiten.MouseButtonLeft,
d2interface.MouseButtonMiddle: ebiten.MouseButtonMiddle, d2enum.MouseButtonMiddle: ebiten.MouseButtonMiddle,
d2interface.MouseButtonRight: ebiten.MouseButtonRight, d2enum.MouseButtonRight: ebiten.MouseButtonRight,
} }
) )
@ -133,36 +133,36 @@ func (is InputService) InputChars() []rune {
} }
// IsKeyPressed checks if the provided key is down. // IsKeyPressed checks if the provided key is down.
func (is InputService) IsKeyPressed(key d2interface.Key) bool { func (is InputService) IsKeyPressed(key d2enum.Key) bool {
return ebiten.IsKeyPressed(keyToEbiten[key]) return ebiten.IsKeyPressed(keyToEbiten[key])
} }
// IsKeyJustPressed checks if the provided key is just transitioned from up to down. // IsKeyJustPressed checks if the provided key is just transitioned from up to down.
func (is InputService) IsKeyJustPressed(key d2interface.Key) bool { func (is InputService) IsKeyJustPressed(key d2enum.Key) bool {
return inpututil.IsKeyJustPressed(keyToEbiten[key]) return inpututil.IsKeyJustPressed(keyToEbiten[key])
} }
// IsKeyJustReleased checks if the provided key is just transitioned from down to up. // IsKeyJustReleased checks if the provided key is just transitioned from down to up.
func (is InputService) IsKeyJustReleased(key d2interface.Key) bool { func (is InputService) IsKeyJustReleased(key d2enum.Key) bool {
return inpututil.IsKeyJustReleased(keyToEbiten[key]) return inpututil.IsKeyJustReleased(keyToEbiten[key])
} }
// IsMouseButtonPressed checks if the provided mouse button is down. // IsMouseButtonPressed checks if the provided mouse button is down.
func (is InputService) IsMouseButtonPressed(button d2interface.MouseButton) bool { func (is InputService) IsMouseButtonPressed(button d2enum.MouseButton) bool {
return ebiten.IsMouseButtonPressed(mouseButtonToEbiten[button]) return ebiten.IsMouseButtonPressed(mouseButtonToEbiten[button])
} }
// IsMouseButtonJustPressed checks if the provided mouse button is just transitioned from up to down. // IsMouseButtonJustPressed checks if the provided mouse button is just transitioned from up to down.
func (is InputService) IsMouseButtonJustPressed(button d2interface.MouseButton) bool { func (is InputService) IsMouseButtonJustPressed(button d2enum.MouseButton) bool {
return inpututil.IsMouseButtonJustPressed(mouseButtonToEbiten[button]) return inpututil.IsMouseButtonJustPressed(mouseButtonToEbiten[button])
} }
// IsMouseButtonJustReleased checks if the provided mouse button is just transitioned from down to up. // IsMouseButtonJustReleased checks if the provided mouse button is just transitioned from down to up.
func (is InputService) IsMouseButtonJustReleased(button d2interface.MouseButton) bool { func (is InputService) IsMouseButtonJustReleased(button d2enum.MouseButton) bool {
return inpututil.IsMouseButtonJustReleased(mouseButtonToEbiten[button]) return inpututil.IsMouseButtonJustReleased(mouseButtonToEbiten[button])
} }
// KeyPressDuration returns how long the key is pressed in frames. // KeyPressDuration returns how long the key is pressed in frames.
func (is InputService) KeyPressDuration(key d2interface.Key) int { func (is InputService) KeyPressDuration(key d2enum.Key) int {
return inpututil.KeyPressDuration(keyToEbiten[key]) return inpututil.KeyPressDuration(keyToEbiten[key])
} }

26
d2core/d2input/input_events.go
View File

@ -1,24 +1,24 @@
package d2input package d2input
import ( import (
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2interface" "github.com/OpenDiablo2/OpenDiablo2/d2common/d2enum"
) )
// HandlerEvent is an event that EventHandlers will process and respond to // HandlerEvent is an event that EventHandlers will process and respond to
type HandlerEvent struct { type HandlerEvent struct {
keyMod d2interface.KeyMod keyMod d2enum.KeyMod
buttonMod d2interface.MouseButtonMod buttonMod d2enum.MouseButtonMod
x int x int
y int y int
} }
// KeyMod yields the modifier for a key action // KeyMod yields the modifier for a key action
func (e *HandlerEvent) KeyMod() d2interface.KeyMod { func (e *HandlerEvent) KeyMod() d2enum.KeyMod {
return e.keyMod return e.keyMod
} }
// ButtonMod yields the modifier for a button action // ButtonMod yields the modifier for a button action
func (e *HandlerEvent) ButtonMod() d2interface.MouseButtonMod { func (e *HandlerEvent) ButtonMod() d2enum.MouseButtonMod {
return e.buttonMod return e.buttonMod
} }
@ -43,12 +43,12 @@ func (e *KeyCharsEvent) Chars() []rune {
type KeyEvent struct { type KeyEvent struct {
HandlerEvent HandlerEvent
key d2interface.Key key d2enum.Key
// Duration represents the number of frames this key has been pressed for // Duration represents the number of frames this key has been pressed for
duration int duration int
} }
func (e *KeyEvent) Key() d2interface.Key { func (e *KeyEvent) Key() d2enum.Key {
return e.key return e.key
} }
func (e *KeyEvent) Duration() int { func (e *KeyEvent) Duration() int {
@ -57,14 +57,14 @@ func (e *KeyEvent) Duration() int {
type MouseEvent struct { type MouseEvent struct {
HandlerEvent HandlerEvent
mouseButton d2interface.MouseButton mouseButton d2enum.MouseButton
} }
func (e *MouseEvent) KeyMod() d2interface.KeyMod { func (e *MouseEvent) KeyMod() d2enum.KeyMod {
return e.HandlerEvent.keyMod return e.HandlerEvent.keyMod
} }
func (e *MouseEvent) ButtonMod() d2interface.MouseButtonMod { func (e *MouseEvent) ButtonMod() d2enum.MouseButtonMod {
return e.HandlerEvent.buttonMod return e.HandlerEvent.buttonMod
} }
@ -76,7 +76,7 @@ func (e *MouseEvent) Y() int {
return e.HandlerEvent.y return e.HandlerEvent.y
} }
func (e *MouseEvent) Button() d2interface.MouseButton { func (e *MouseEvent) Button() d2enum.MouseButton {
return e.mouseButton return e.mouseButton
} }
@ -84,11 +84,11 @@ type MouseMoveEvent struct {
HandlerEvent HandlerEvent
} }
func (e *MouseMoveEvent) KeyMod() d2interface.KeyMod { func (e *MouseMoveEvent) KeyMod() d2enum.KeyMod {
return e.HandlerEvent.keyMod return e.HandlerEvent.keyMod
} }
func (e *MouseMoveEvent) ButtonMod() d2interface.MouseButtonMod { func (e *MouseMoveEvent) ButtonMod() d2enum.MouseButtonMod {
return e.HandlerEvent.buttonMod return e.HandlerEvent.buttonMod
} }

55
d2core/d2input/input_manager.go
View File

@ -1,6 +1,7 @@
package d2input package d2input
import ( import (
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2enum"
"sort" "sort"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2interface" "github.com/OpenDiablo2/OpenDiablo2/d2common/d2interface"
@ -11,8 +12,8 @@ type inputManager struct {
cursorX int cursorX int
cursorY int cursorY int
buttonMod d2interface.MouseButtonMod buttonMod d2enum.MouseButtonMod
keyMod d2interface.KeyMod keyMod d2enum.KeyMod
entries handlerEntryList entries handlerEntryList
} }
@ -30,7 +31,7 @@ func (im *inputManager) Advance(_, _ float64) error {
cursorY, cursorY,
} }
for key := d2interface.KeyMin; key <= d2interface.KeyMax; key++ { for key := d2enum.KeyMin; key <= d2enum.KeyMax; key++ {
im.updateJustPressedKey(key, eventBase) im.updateJustPressedKey(key, eventBase)
im.updateJustReleasedKey(key, eventBase) im.updateJustReleasedKey(key, eventBase)
im.updatePressedKey(key, eventBase) im.updatePressedKey(key, eventBase)
@ -38,7 +39,7 @@ func (im *inputManager) Advance(_, _ float64) error {
im.updateInputChars(eventBase) im.updateInputChars(eventBase)
for button := d2interface.MouseButtonMin; button <= d2interface.MouseButtonMax; button++ { for button := d2enum.MouseButtonMin; button <= d2enum.MouseButtonMax; button++ {
im.updateJustPressedButton(button, eventBase) im.updateJustPressedButton(button, eventBase)
im.updateJustReleasedButton(button, eventBase) im.updateJustReleasedButton(button, eventBase)
im.updatePressedButton(button, eventBase) im.updatePressedButton(button, eventBase)
@ -51,35 +52,35 @@ func (im *inputManager) Advance(_, _ float64) error {
func (im *inputManager) updateKeyMod() { func (im *inputManager) updateKeyMod() {
im.keyMod = 0 im.keyMod = 0
if im.inputService.IsKeyPressed(d2interface.KeyAlt) { if im.inputService.IsKeyPressed(d2enum.KeyAlt) {
im.keyMod |= d2interface.KeyModAlt im.keyMod |= d2enum.KeyModAlt
} }
if im.inputService.IsKeyPressed(d2interface.KeyControl) { if im.inputService.IsKeyPressed(d2enum.KeyControl) {
im.keyMod |= d2interface.KeyModControl im.keyMod |= d2enum.KeyModControl
} }
if im.inputService.IsKeyPressed(d2interface.KeyShift) { if im.inputService.IsKeyPressed(d2enum.KeyShift) {
im.keyMod |= d2interface.KeyModShift im.keyMod |= d2enum.KeyModShift
} }
} }
func (im *inputManager) updateButtonMod() { func (im *inputManager) updateButtonMod() {
im.buttonMod = 0 im.buttonMod = 0
if im.inputService.IsMouseButtonPressed(d2interface.MouseButtonLeft) { if im.inputService.IsMouseButtonPressed(d2enum.MouseButtonLeft) {
im.buttonMod |= d2interface.MouseButtonModLeft im.buttonMod |= d2enum.MouseButtonModLeft
} }
if im.inputService.IsMouseButtonPressed(d2interface.MouseButtonMiddle) { if im.inputService.IsMouseButtonPressed(d2enum.MouseButtonMiddle) {
im.buttonMod |= d2interface.MouseButtonModMiddle im.buttonMod |= d2enum.MouseButtonModMiddle
} }
if im.inputService.IsMouseButtonPressed(d2interface.MouseButtonRight) { if im.inputService.IsMouseButtonPressed(d2enum.MouseButtonRight) {
im.buttonMod |= d2interface.MouseButtonModRight im.buttonMod |= d2enum.MouseButtonModRight
} }
} }
func (im *inputManager) updateJustPressedKey(k d2interface.Key, e HandlerEvent) { func (im *inputManager) updateJustPressedKey(k d2enum.Key, e HandlerEvent) {
if im.inputService.IsKeyJustPressed(k) { if im.inputService.IsKeyJustPressed(k) {
event := KeyEvent{HandlerEvent: e, key: k} event := KeyEvent{HandlerEvent: e, key: k}
@ -95,7 +96,7 @@ func (im *inputManager) updateJustPressedKey(k d2interface.Key, e HandlerEvent)
} }
} }
func (im *inputManager) updateJustReleasedKey(k d2interface.Key, e HandlerEvent) { func (im *inputManager) updateJustReleasedKey(k d2enum.Key, e HandlerEvent) {
if im.inputService.IsKeyJustReleased(k) { if im.inputService.IsKeyJustReleased(k) {
event := KeyEvent{HandlerEvent: e, key: k} event := KeyEvent{HandlerEvent: e, key: k}
@ -110,7 +111,7 @@ func (im *inputManager) updateJustReleasedKey(k d2interface.Key, e HandlerEvent)
} }
} }
func (im *inputManager) updatePressedKey(k d2interface.Key, e HandlerEvent) { func (im *inputManager) updatePressedKey(k d2enum.Key, e HandlerEvent) {
if im.inputService.IsKeyPressed(k) { if im.inputService.IsKeyPressed(k) {
event := KeyEvent{ event := KeyEvent{
HandlerEvent: e, HandlerEvent: e,
@ -144,7 +145,7 @@ func (im *inputManager) updateInputChars(eventBase HandlerEvent) {
} }
} }
func (im *inputManager) updateJustPressedButton(b d2interface.MouseButton, e HandlerEvent) { func (im *inputManager) updateJustPressedButton(b d2enum.MouseButton, e HandlerEvent) {
if im.inputService.IsMouseButtonJustPressed(b) { if im.inputService.IsMouseButtonJustPressed(b) {
event := MouseEvent{e, b} event := MouseEvent{e, b}
@ -159,7 +160,7 @@ func (im *inputManager) updateJustPressedButton(b d2interface.MouseButton, e Han
} }
} }
func (im *inputManager) updateJustReleasedButton(b d2interface.MouseButton, e HandlerEvent) { func (im *inputManager) updateJustReleasedButton(b d2enum.MouseButton, e HandlerEvent) {
if im.inputService.IsMouseButtonJustReleased(b) { if im.inputService.IsMouseButtonJustReleased(b) {
event := MouseEvent{e, b} event := MouseEvent{e, b}
@ -174,7 +175,7 @@ func (im *inputManager) updateJustReleasedButton(b d2interface.MouseButton, e Ha
} }
} }
func (im *inputManager) updatePressedButton(b d2interface.MouseButton, e HandlerEvent) { func (im *inputManager) updatePressedButton(b d2enum.MouseButton, e HandlerEvent) {
if im.inputService.IsMouseButtonPressed(b) { if im.inputService.IsMouseButtonPressed(b) {
event := MouseEvent{e, b} event := MouseEvent{e, b}
@ -209,17 +210,17 @@ func (im *inputManager) updateCursor(cursorX, cursorY int, e HandlerEvent) {
// BindHandlerWithPriority adds an event handler with a specific call priority // BindHandlerWithPriority adds an event handler with a specific call priority
func (im *inputManager) BindHandlerWithPriority( func (im *inputManager) BindHandlerWithPriority(
h d2interface.InputEventHandler, h d2interface.InputEventHandler,
p d2interface.Priority) error { p d2enum.Priority) error {
return singleton.bindHandler(h, p) return singleton.bindHandler(h, p)
} }
// BindHandler adds an event handler // BindHandler adds an event handler
func (im *inputManager) BindHandler(h d2interface.InputEventHandler) error { func (im *inputManager) BindHandler(h d2interface.InputEventHandler) error {
return im.bindHandler(h, d2interface.PriorityDefault) return im.bindHandler(h, d2enum.PriorityDefault)
} }
// BindHandler adds an event handler // BindHandler adds an event handler
func (im *inputManager) bindHandler(h d2interface.InputEventHandler, p d2interface.Priority) error { func (im *inputManager) bindHandler(h d2interface.InputEventHandler, p d2enum.Priority) error {
for _, entry := range im.entries { for _, entry := range im.entries {
if entry.handler == h { if entry.handler == h {
return ErrHasReg return ErrHasReg
@ -248,7 +249,7 @@ func (im *inputManager) UnbindHandler(handler d2interface.InputEventHandler) err
} }
func (im *inputManager) propagate(callback func(d2interface.InputEventHandler) bool) { func (im *inputManager) propagate(callback func(d2interface.InputEventHandler) bool) {
var priority d2interface.Priority var priority d2enum.Priority
var handled bool var handled bool
@ -267,7 +268,7 @@ func (im *inputManager) propagate(callback func(d2interface.InputEventHandler) b
type handlerEntry struct { type handlerEntry struct {
handler d2interface.InputEventHandler handler d2interface.InputEventHandler
priority d2interface.Priority priority d2enum.Priority
} }
type handlerEntryList []handlerEntry type handlerEntryList []handlerEntry

7
d2core/d2map/d2maprenderer/tile_cache.go
View File

@ -7,7 +7,6 @@ import (
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2enum" "github.com/OpenDiablo2/OpenDiablo2/d2common/d2enum"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2fileformats/d2ds1" "github.com/OpenDiablo2/OpenDiablo2/d2common/d2fileformats/d2ds1"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2fileformats/d2dt1" "github.com/OpenDiablo2/OpenDiablo2/d2common/d2fileformats/d2dt1"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2interface"
) )
func (mr *MapRenderer) generateTileCache() { func (mr *MapRenderer) generateTileCache() {
@ -73,7 +72,7 @@ func (mr *MapRenderer) generateFloorCache(tile *d2ds1.FloorShadowRecord, tileX,
} }
tileYOffset := d2common.AbsInt32(tileYMinimum) tileYOffset := d2common.AbsInt32(tileYMinimum)
tileHeight := d2common.AbsInt32(tileData[i].Height) tileHeight := d2common.AbsInt32(tileData[i].Height)
image, _ := mr.renderer.NewSurface(int(tileData[i].Width), int(tileHeight), d2interface.FilterNearest) image, _ := mr.renderer.NewSurface(int(tileData[i].Width), int(tileHeight), d2enum.FilterNearest)
pixels := make([]byte, 4*tileData[i].Width*tileHeight) pixels := make([]byte, 4*tileData[i].Width*tileHeight)
mr.decodeTileGfxData(tileData[i].Blocks, &pixels, tileYOffset, tileData[i].Width) mr.decodeTileGfxData(tileData[i].Blocks, &pixels, tileYOffset, tileData[i].Width)
_ = image.ReplacePixels(pixels) _ = image.ReplacePixels(pixels)
@ -112,7 +111,7 @@ func (mr *MapRenderer) generateShadowCache(tile *d2ds1.FloorShadowRecord, tileX,
return return
} }
image, _ := mr.renderer.NewSurface(int(tileData.Width), tileHeight, d2interface.FilterNearest) image, _ := mr.renderer.NewSurface(int(tileData.Width), tileHeight, d2enum.FilterNearest)
pixels := make([]byte, 4*tileData.Width*int32(tileHeight)) pixels := make([]byte, 4*tileData.Width*int32(tileHeight))
mr.decodeTileGfxData(tileData.Blocks, &pixels, tileYOffset, tileData.Width) mr.decodeTileGfxData(tileData.Blocks, &pixels, tileYOffset, tileData.Width)
_ = image.ReplacePixels(pixels) _ = image.ReplacePixels(pixels)
@ -173,7 +172,7 @@ func (mr *MapRenderer) generateWallCache(tile *d2ds1.WallRecord, tileX, tileY in
return return
} }
image, _ := mr.renderer.NewSurface(160, int(realHeight), d2interface.FilterNearest) image, _ := mr.renderer.NewSurface(160, int(realHeight), d2enum.FilterNearest)
pixels := make([]byte, 4*160*realHeight) pixels := make([]byte, 4*160*realHeight)
mr.decodeTileGfxData(tileData.Blocks, &pixels, tileYOffset, 160) mr.decodeTileGfxData(tileData.Blocks, &pixels, tileYOffset, 160)

3
d2core/d2render/ebiten/ebiten_renderer.go
View File

@ -1,6 +1,7 @@
package ebiten package ebiten
import ( import (
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2enum"
"image" "image"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2interface" "github.com/OpenDiablo2/OpenDiablo2/d2common/d2interface"
@ -75,7 +76,7 @@ func (r *Renderer) CreateSurface(surface d2interface.Surface) (d2interface.Surfa
return result, nil return result, nil
} }
func (r *Renderer) NewSurface(width, height int, filter d2interface.Filter) (d2interface.Surface, error) { func (r *Renderer) NewSurface(width, height int, filter d2enum.Filter) (d2interface.Surface, error) {
ebitenFilter := d2ToEbitenFilter(filter) ebitenFilter := d2ToEbitenFilter(filter)
img, err := ebiten.NewImage(width, height, ebitenFilter) img, err := ebiten.NewImage(width, height, ebitenFilter)
if err != nil { if err != nil {

2
d2core/d2render/ebiten/ebiten_surface.go
View File

@ -30,7 +30,7 @@ func (s *ebitenSurface) PushCompositeMode(mode d2enum.CompositeMode) {
s.stateCurrent.mode = d2ToEbitenCompositeMode(mode) s.stateCurrent.mode = d2ToEbitenCompositeMode(mode)
} }
func (s *ebitenSurface) PushFilter(filter d2interface.Filter) { func (s *ebitenSurface) PushFilter(filter d2enum.Filter) {
s.stateStack = append(s.stateStack, s.stateCurrent) s.stateStack = append(s.stateStack, s.stateCurrent)
s.stateCurrent.filter = d2ToEbitenFilter(filter) s.stateCurrent.filter = d2ToEbitenFilter(filter)
} }

20
d2core/d2render/ebiten/filter_helper.go
View File

@ -1,32 +1,32 @@
package ebiten package ebiten
import ( import (
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2interface" "github.com/OpenDiablo2/OpenDiablo2/d2common/d2enum"
"github.com/hajimehoshi/ebiten" "github.com/hajimehoshi/ebiten"
) )
func d2ToEbitenFilter(filter d2interface.Filter) ebiten.Filter { func d2ToEbitenFilter(filter d2enum.Filter) ebiten.Filter {
switch filter { switch filter {
case d2interface.FilterDefault: case d2enum.FilterDefault:
return ebiten.FilterDefault return ebiten.FilterDefault
case d2interface.FilterLinear: case d2enum.FilterLinear:
return ebiten.FilterLinear return ebiten.FilterLinear
case d2interface.FilterNearest: case d2enum.FilterNearest:
return ebiten.FilterNearest return ebiten.FilterNearest
} }
return ebiten.FilterDefault return ebiten.FilterDefault
} }
func ebitenToD2Filter(filter ebiten.Filter) d2interface.Filter { func ebitenToD2Filter(filter ebiten.Filter) d2enum.Filter {
switch filter { switch filter {
case ebiten.FilterDefault: case ebiten.FilterDefault:
return d2interface.FilterDefault return d2enum.FilterDefault
case ebiten.FilterLinear: case ebiten.FilterLinear:
return d2interface.FilterLinear return d2enum.FilterLinear
case ebiten.FilterNearest: case ebiten.FilterNearest:
return d2interface.FilterNearest return d2enum.FilterNearest
} }
return d2interface.FilterDefault return d2enum.FilterDefault
} }

3
d2core/d2term/d2term.go
View File

@ -1,6 +1,7 @@
package d2term package d2term
import ( import (
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2enum"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2interface" "github.com/OpenDiablo2/OpenDiablo2/d2common/d2interface"
"github.com/OpenDiablo2/OpenDiablo2/d2core/d2input" "github.com/OpenDiablo2/OpenDiablo2/d2core/d2input"
) )
@ -12,7 +13,7 @@ func Initialize() (d2interface.Terminal, error) {
return nil, err return nil, err
} }
if err := d2input.BindHandlerWithPriority(term, d2interface.PriorityHigh); err != nil { if err := d2input.BindHandlerWithPriority(term, d2enum.PriorityHigh); err != nil {
return nil, err return nil, err
} }

57
d2core/d2term/terminal.go
View File

@ -3,6 +3,7 @@ package d2term
import ( import (
"errors" "errors"
"fmt" "fmt"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2enum"
"image/color" "image/color"
"log" "log"
"math" "math"
@ -17,14 +18,14 @@ import (
) )
// TermCategory applies styles to the lines in the Terminal // TermCategory applies styles to the lines in the Terminal
type TermCategory d2interface.TermCategory type TermCategory d2enum.TermCategory
// Terminal Category types // Terminal Category types
const ( const (
TermCategoryNone = TermCategory(d2interface.TermCategoryNone) TermCategoryNone = TermCategory(d2enum.TermCategoryNone)
TermCategoryInfo = TermCategory(d2interface.TermCategoryInfo) TermCategoryInfo = TermCategory(d2enum.TermCategoryInfo)
TermCategoryWarning = TermCategory(d2interface.TermCategoryWarning) TermCategoryWarning = TermCategory(d2enum.TermCategoryWarning)
TermCategoryError = TermCategory(d2interface.TermCategoryError) TermCategoryError = TermCategory(d2enum.TermCategoryError)
) )
const ( const (
termCharWidth = 6 termCharWidth = 6
@ -51,7 +52,7 @@ const (
type termHistoryEntry struct { type termHistoryEntry struct {
text string text string
category d2interface.TermCategory category d2enum.TermCategory
} }
type termActionEntry struct { type termActionEntry struct {
@ -102,7 +103,7 @@ func (t *terminal) Advance(elapsed float64) error {
} }
func (t *terminal) OnKeyDown(event d2interface.KeyEvent) bool { func (t *terminal) OnKeyDown(event d2interface.KeyEvent) bool {
if event.Key() == d2interface.KeyGraveAccent { if event.Key() == d2enum.KeyGraveAccent {
t.toggleTerminal() t.toggleTerminal()
} }
@ -111,26 +112,26 @@ func (t *terminal) OnKeyDown(event d2interface.KeyEvent) bool {
} }
switch event.Key() { switch event.Key() {
case d2interface.KeyEscape: case d2enum.KeyEscape:
t.command = "" t.command = ""
case d2interface.KeyEnd: case d2enum.KeyEnd:
t.outputIndex = 0 t.outputIndex = 0
case d2interface.KeyHome: case d2enum.KeyHome:
t.outputIndex = d2common.MaxInt(0, len(t.outputHistory)-t.lineCount) t.outputIndex = d2common.MaxInt(0, len(t.outputHistory)-t.lineCount)
case d2interface.KeyPageUp: case d2enum.KeyPageUp:
maxOutputIndex := d2common.MaxInt(0, len(t.outputHistory)-t.lineCount) maxOutputIndex := d2common.MaxInt(0, len(t.outputHistory)-t.lineCount)
if t.outputIndex += t.lineCount; t.outputIndex >= maxOutputIndex { if t.outputIndex += t.lineCount; t.outputIndex >= maxOutputIndex {
t.outputIndex = maxOutputIndex t.outputIndex = maxOutputIndex
} }
case d2interface.KeyPageDown: case d2enum.KeyPageDown:
if t.outputIndex -= t.lineCount; t.outputIndex < 0 { if t.outputIndex -= t.lineCount; t.outputIndex < 0 {
t.outputIndex = 0 t.outputIndex = 0
} }
case d2interface.KeyUp, d2interface.KeyDown: case d2enum.KeyUp, d2enum.KeyDown:
t.handleControlKey(event.Key(), event.KeyMod()) t.handleControlKey(event.Key(), event.KeyMod())
case d2interface.KeyEnter: case d2enum.KeyEnter:
t.processCommand() t.processCommand()
case d2interface.KeyBackspace: case d2enum.KeyBackspace:
if len(t.command) > 0 { if len(t.command) > 0 {
t.command = t.command[:len(t.command)-1] t.command = t.command[:len(t.command)-1]
} }
@ -166,10 +167,10 @@ func (t *terminal) processCommand() {
t.command = "" t.command = ""
} }
func (t *terminal) handleControlKey(eventKey d2interface.Key, keyMod d2interface.KeyMod) { func (t *terminal) handleControlKey(eventKey d2enum.Key, keyMod d2enum.KeyMod) {
switch eventKey { switch eventKey {
case d2interface.KeyUp: case d2enum.KeyUp:
if keyMod == d2interface.KeyModControl { if keyMod == d2enum.KeyModControl {
t.lineCount = d2common.MaxInt(0, t.lineCount-1) t.lineCount = d2common.MaxInt(0, t.lineCount-1)
} else if len(t.commandHistory) > 0 { } else if len(t.commandHistory) > 0 {
t.command = t.commandHistory[t.commandIndex] t.command = t.commandHistory[t.commandIndex]
@ -179,8 +180,8 @@ func (t *terminal) handleControlKey(eventKey d2interface.Key, keyMod d2interface
t.commandIndex-- t.commandIndex--
} }
} }
case d2interface.KeyDown: case d2enum.KeyDown:
if keyMod == d2interface.KeyModControl { if keyMod == d2enum.KeyModControl {
t.lineCount = d2common.MinInt(t.lineCount+1, termRowCountMax) t.lineCount = d2common.MinInt(t.lineCount+1, termRowCountMax)
} }
} }
@ -238,11 +239,11 @@ func (t *terminal) Render(surface d2interface.Surface) error {
surface.PushTranslation(-termCharWidth*2, 0) surface.PushTranslation(-termCharWidth*2, 0)
switch historyEntry.category { switch historyEntry.category {
case d2interface.TermCategoryInfo: case d2enum.TermCategoryInfo:
surface.DrawRect(termCharWidth, termCharHeight, t.infoColor) surface.DrawRect(termCharWidth, termCharHeight, t.infoColor)
case d2interface.TermCategoryWarning: case d2enum.TermCategoryWarning:
surface.DrawRect(termCharWidth, termCharHeight, t.warningColor) surface.DrawRect(termCharWidth, termCharHeight, t.warningColor)
case d2interface.TermCategoryError: case d2enum.TermCategoryError:
surface.DrawRect(termCharWidth, termCharHeight, t.errorColor) surface.DrawRect(termCharWidth, termCharHeight, t.errorColor)
} }
@ -347,7 +348,7 @@ func parseActionParams(actionType reflect.Type, actionParams []string) ([]reflec
return paramValues, nil return paramValues, nil
} }
func (t *terminal) OutputRaw(text string, category d2interface.TermCategory) { func (t *terminal) OutputRaw(text string, category d2enum.TermCategory) {
var line string var line string
for _, word := range strings.Split(text, " ") { for _, word := range strings.Split(text, " ") {
@ -370,19 +371,19 @@ func (t *terminal) OutputRaw(text string, category d2interface.TermCategory) {
} }
func (t *terminal) Outputf(format string, params ...interface{}) { func (t *terminal) Outputf(format string, params ...interface{}) {
t.OutputRaw(fmt.Sprintf(format, params...), d2interface.TermCategoryNone) t.OutputRaw(fmt.Sprintf(format, params...), d2enum.TermCategoryNone)
} }
func (t *terminal) OutputInfof(format string, params ...interface{}) { func (t *terminal) OutputInfof(format string, params ...interface{}) {
t.OutputRaw(fmt.Sprintf(format, params...), d2interface.TermCategoryInfo) t.OutputRaw(fmt.Sprintf(format, params...), d2enum.TermCategoryInfo)
} }
func (t *terminal) OutputWarningf(format string, params ...interface{}) { func (t *terminal) OutputWarningf(format string, params ...interface{}) {
t.OutputRaw(fmt.Sprintf(format, params...), d2interface.TermCategoryWarning) t.OutputRaw(fmt.Sprintf(format, params...), d2enum.TermCategoryWarning)
} }
func (t *terminal) OutputErrorf(format string, params ...interface{}) { func (t *terminal) OutputErrorf(format string, params ...interface{}) {
t.OutputRaw(fmt.Sprintf(format, params...), d2interface.TermCategoryError) t.OutputRaw(fmt.Sprintf(format, params...), d2enum.TermCategoryError)
} }
func (t *terminal) OutputClear() { func (t *terminal) OutputClear() {

12
d2core/d2ui/button.go
View File

@ -126,7 +126,7 @@ func CreateButton(renderer d2interface.Renderer, buttonType ButtonType, text str
result.height += h result.height += h
} }
result.normalSurface, _ = renderer.NewSurface(result.width, result.height, d2interface.FilterNearest) result.normalSurface, _ = renderer.NewSurface(result.width, result.height, d2enum.FilterNearest)
_, fontHeight := font.GetTextMetrics(text) _, fontHeight := font.GetTextMetrics(text)
textY := (result.height / 2) - (fontHeight / 2) + buttonLayout.TextOffset textY := (result.height / 2) - (fontHeight / 2) + buttonLayout.TextOffset
@ -136,22 +136,22 @@ func CreateButton(renderer d2interface.Renderer, buttonType ButtonType, text str
font.Render(0, textY, text, color.RGBA{R: 100, G: 100, B: 100, A: 255}, result.normalSurface) font.Render(0, textY, text, color.RGBA{R: 100, G: 100, B: 100, A: 255}, result.normalSurface)
if buttonLayout.AllowFrameChange { if buttonLayout.AllowFrameChange {
if totalButtonTypes > 1 { if totalButtonTypes > 1 {
result.pressedSurface, _ = renderer.NewSurface(result.width, result.height, d2interface.FilterNearest) result.pressedSurface, _ = renderer.NewSurface(result.width, result.height, d2enum.FilterNearest)
buttonSprite.RenderSegmented(result.pressedSurface, buttonLayout.XSegments, buttonLayout.YSegments, buttonLayout.BaseFrame+1) buttonSprite.RenderSegmented(result.pressedSurface, buttonLayout.XSegments, buttonLayout.YSegments, buttonLayout.BaseFrame+1)
font.Render(-2, textY+2, text, color.RGBA{R: 100, G: 100, B: 100, A: 255}, result.pressedSurface) font.Render(-2, textY+2, text, color.RGBA{R: 100, G: 100, B: 100, A: 255}, result.pressedSurface)
} }
if totalButtonTypes > 2 { if totalButtonTypes > 2 {
result.toggledSurface, _ = renderer.NewSurface(result.width, result.height, d2interface.FilterNearest) result.toggledSurface, _ = renderer.NewSurface(result.width, result.height, d2enum.FilterNearest)
buttonSprite.RenderSegmented(result.toggledSurface, buttonLayout.XSegments, buttonLayout.YSegments, buttonLayout.BaseFrame+2) buttonSprite.RenderSegmented(result.toggledSurface, buttonLayout.XSegments, buttonLayout.YSegments, buttonLayout.BaseFrame+2)
font.Render(0, textY, text, color.RGBA{R: 100, G: 100, B: 100, A: 255}, result.toggledSurface) font.Render(0, textY, text, color.RGBA{R: 100, G: 100, B: 100, A: 255}, result.toggledSurface)
} }
if totalButtonTypes > 3 { if totalButtonTypes > 3 {
result.pressedToggledSurface, _ = renderer.NewSurface(result.width, result.height, d2interface.FilterNearest) result.pressedToggledSurface, _ = renderer.NewSurface(result.width, result.height, d2enum.FilterNearest)
buttonSprite.RenderSegmented(result.pressedToggledSurface, buttonLayout.XSegments, buttonLayout.YSegments, buttonLayout.BaseFrame+3) buttonSprite.RenderSegmented(result.pressedToggledSurface, buttonLayout.XSegments, buttonLayout.YSegments, buttonLayout.BaseFrame+3)
font.Render(0, textY, text, color.RGBA{R: 100, G: 100, B: 100, A: 255}, result.pressedToggledSurface) font.Render(0, textY, text, color.RGBA{R: 100, G: 100, B: 100, A: 255}, result.pressedToggledSurface)
} }
if buttonLayout.DisabledFrame != -1 { if buttonLayout.DisabledFrame != -1 {
result.disabledSurface, _ = renderer.NewSurface(result.width, result.height, d2interface.FilterNearest) result.disabledSurface, _ = renderer.NewSurface(result.width, result.height, d2enum.FilterNearest)
buttonSprite.RenderSegmented(result.disabledSurface, buttonLayout.XSegments, buttonLayout.YSegments, buttonLayout.DisabledFrame) buttonSprite.RenderSegmented(result.disabledSurface, buttonLayout.XSegments, buttonLayout.YSegments, buttonLayout.DisabledFrame)
font.Render(0, textY, text, color.RGBA{R: 100, G: 100, B: 100, A: 255}, result.disabledSurface) font.Render(0, textY, text, color.RGBA{R: 100, G: 100, B: 100, A: 255}, result.disabledSurface)
} }
@ -175,7 +175,7 @@ func (v *Button) Activate() {
// Render renders the button // Render renders the button
func (v *Button) Render(target d2interface.Surface) { func (v *Button) Render(target d2interface.Surface) {
target.PushCompositeMode(d2enum.CompositeModeSourceAtop) target.PushCompositeMode(d2enum.CompositeModeSourceAtop)
target.PushFilter(d2interface.FilterNearest) target.PushFilter(d2enum.FilterNearest)
target.PushTranslation(v.x, v.y) target.PushTranslation(v.x, v.y)
defer target.PopN(3) defer target.PopN(3)

6
d2core/d2ui/checkbox.go
View File

@ -32,11 +32,11 @@ func CreateCheckbox(renderer d2interface.Renderer, checkState bool) Checkbox {
result.width, result.height, _ = checkboxSprite.GetFrameSize(0) result.width, result.height, _ = checkboxSprite.GetFrameSize(0)
checkboxSprite.SetPosition(0, 0) checkboxSprite.SetPosition(0, 0)
result.Image, _ = renderer.NewSurface(result.width, result.height, d2interface.FilterNearest) result.Image, _ = renderer.NewSurface(result.width, result.height, d2enum.FilterNearest)
_ = checkboxSprite.RenderSegmented(result.Image, 1, 1, 0) _ = checkboxSprite.RenderSegmented(result.Image, 1, 1, 0)
result.checkedImage, _ = renderer.NewSurface(result.width, result.height, d2interface.FilterNearest) result.checkedImage, _ = renderer.NewSurface(result.width, result.height, d2enum.FilterNearest)
_ = checkboxSprite.RenderSegmented(result.checkedImage, 1, 1, 1) _ = checkboxSprite.RenderSegmented(result.checkedImage, 1, 1, 1)
return result return result
@ -45,7 +45,7 @@ func CreateCheckbox(renderer d2interface.Renderer, checkState bool) Checkbox {
func (v *Checkbox) Render(target d2interface.Surface) { func (v *Checkbox) Render(target d2interface.Surface) {
target.PushCompositeMode(d2enum.CompositeModeSourceAtop) target.PushCompositeMode(d2enum.CompositeModeSourceAtop)
target.PushTranslation(v.x, v.y) target.PushTranslation(v.x, v.y)
target.PushFilter(d2interface.FilterNearest) target.PushFilter(d2enum.FilterNearest)
defer target.PopN(3) defer target.PopN(3)
if v.checkState { if v.checkState {

7
d2core/d2ui/d2ui.go
View File

@ -1,6 +1,7 @@
package d2ui package d2ui
import ( import (
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2enum"
"log" "log"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2interface" "github.com/OpenDiablo2/OpenDiablo2/d2common/d2interface"
@ -54,7 +55,7 @@ func AddWidget(widget Widget) {
func (u *UI) OnMouseButtonUp(event d2interface.MouseEvent) bool { func (u *UI) OnMouseButtonUp(event d2interface.MouseEvent) bool {
singleton.CursorX, singleton.CursorY = event.X(), event.Y() singleton.CursorX, singleton.CursorY = event.X(), event.Y()
if event.Button() == d2interface.MouseButtonLeft { if event.Button() == d2enum.MouseButtonLeft {
singleton.cursorButtons |= CursorButtonLeft singleton.cursorButtons |= CursorButtonLeft
// activate previously pressed widget if cursor is still hovering // activate previously pressed widget if cursor is still hovering
w := singleton.pressedWidget w := singleton.pressedWidget
@ -71,7 +72,7 @@ func (u *UI) OnMouseButtonUp(event d2interface.MouseEvent) bool {
func (u *UI) OnMouseButtonDown(event d2interface.MouseEvent) bool { func (u *UI) OnMouseButtonDown(event d2interface.MouseEvent) bool {
singleton.CursorX, singleton.CursorY = event.X(), event.Y() singleton.CursorX, singleton.CursorY = event.X(), event.Y()
if event.Button() == d2interface.MouseButtonLeft { if event.Button() == d2enum.MouseButtonLeft {
// find and press a widget on screen // find and press a widget on screen
singleton.pressedWidget = nil singleton.pressedWidget = nil
for _, w := range singleton.widgets { for _, w := range singleton.widgets {
@ -83,7 +84,7 @@ func (u *UI) OnMouseButtonDown(event d2interface.MouseEvent) bool {
} }
} }
} }
if event.Button() == d2interface.MouseButtonRight { if event.Button() == d2enum.MouseButtonRight {
singleton.cursorButtons |= CursorButtonRight singleton.cursorButtons |= CursorButtonRight
} }
return false return false

4
d2core/d2ui/label.go
View File

@ -60,7 +60,7 @@ func (v *Label) Render(target d2interface.Surface) {
x, y = v.X-v.Width, v.Y x, y = v.X-v.Width, v.Y
} }
target.PushFilter(d2interface.FilterNearest) target.PushFilter(d2enum.FilterNearest)
target.PushCompositeMode(d2enum.CompositeModeSourceAtop) target.PushCompositeMode(d2enum.CompositeModeSourceAtop)
target.PushTranslation(x, y) target.PushTranslation(x, y)
defer target.PopN(3) defer target.PopN(3)
@ -85,7 +85,7 @@ func (v *Label) cacheImage() {
width, height := v.font.GetTextMetrics(v.text) width, height := v.font.GetTextMetrics(v.text)
v.Width = width v.Width = width
v.Height = height v.Height = height
v.imageData[v.text], _ = v.renderer.NewSurface(width, height, d2interface.FilterNearest) v.imageData[v.text], _ = v.renderer.NewSurface(width, height, d2enum.FilterNearest)
surface, _ := v.renderer.CreateSurface(v.imageData[v.text]) surface, _ := v.renderer.CreateSurface(v.imageData[v.text])
v.font.Render(0, 0, v.text, v.Color, surface) v.font.Render(0, 0, v.text, v.Color, surface)
} }

3
d2core/d2ui/textbox.go
View File

@ -1,6 +1,7 @@
package d2ui package d2ui
import ( import (
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2enum"
"strings" "strings"
"time" "time"
@ -71,7 +72,7 @@ func (v *TextBox) OnKeyChars(event d2interface.KeyCharsEvent) bool {
} }
func (v *TextBox) OnKeyRepeat(event d2interface.KeyEvent) bool { func (v *TextBox) OnKeyRepeat(event d2interface.KeyEvent) bool {
if event.Key() == d2interface.KeyBackspace && debounceEvents(event.Duration()) { if event.Key() == d2enum.KeyBackspace && debounceEvents(event.Duration()) {
if len(v.text) >= 1 { if len(v.text) >= 1 {
v.text = v.text[:len(v.text)-1] v.text = v.text[:len(v.text)-1]
} }

3
d2game/d2gamescreen/character_select.go
View File

@ -2,6 +2,7 @@ package d2gamescreen
import ( import (
"fmt" "fmt"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2enum"
"image/color" "image/color"
"math" "math"
"os" "os"
@ -282,7 +283,7 @@ func (v *CharacterSelect) moveSelectionBox() {
// OnMouseButtonDown is called when a mouse button is clicked // OnMouseButtonDown is called when a mouse button is clicked
func (v *CharacterSelect) OnMouseButtonDown(event d2interface.MouseEvent) bool { func (v *CharacterSelect) OnMouseButtonDown(event d2interface.MouseEvent) bool {
if !v.showDeleteConfirmation { if !v.showDeleteConfirmation {
if event.Button() == d2interface.MouseButtonLeft { if event.Button() == d2enum.MouseButtonLeft {
mx, my := event.X(), event.Y() mx, my := event.X(), event.Y()
bw := 272 bw := 272
bh := 92 bh := 92

9
d2game/d2gamescreen/escape_menu.go
View File

@ -2,6 +2,7 @@ package d2gamescreen
import ( import (
"fmt" "fmt"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2enum"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2interface" "github.com/OpenDiablo2/OpenDiablo2/d2common/d2interface"
@ -435,13 +436,13 @@ func (m *EscapeMenu) onEnterKey() {
// OnKeyDown defines the actions of the Escape Menu when a key is pressed // OnKeyDown defines the actions of the Escape Menu when a key is pressed
func (m *EscapeMenu) OnKeyDown(event d2interface.KeyEvent) bool { func (m *EscapeMenu) OnKeyDown(event d2interface.KeyEvent) bool {
switch event.Key() { switch event.Key() {
case d2interface.KeyEscape: case d2enum.KeyEscape:
m.onEscKey() m.onEscKey()
case d2interface.KeyUp: case d2enum.KeyUp:
m.onUpKey() m.onUpKey()
case d2interface.KeyDown: case d2enum.KeyDown:
m.onDownKey() m.onDownKey()
case d2interface.KeyEnter: case d2enum.KeyEnter:
m.onEnterKey() m.onEnterKey()
default: default:
return false return false

3
d2game/d2gamescreen/main_menu.go
View File

@ -3,6 +3,7 @@ package d2gamescreen
import ( import (
"fmt" "fmt"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2enum"
"image/color" "image/color"
"log" "log"
"os" "os"
@ -431,7 +432,7 @@ func (v *MainMenu) Advance(tickTime float64) error {
// OnMouseButtonDown is called when a mouse button is clicked // OnMouseButtonDown is called when a mouse button is clicked
func (v *MainMenu) OnMouseButtonDown(event d2interface.MouseEvent) bool { func (v *MainMenu) OnMouseButtonDown(event d2interface.MouseEvent) bool {
if v.screenMode == screenModeTrademark && event.Button() == d2interface.MouseButtonLeft { if v.screenMode == screenModeTrademark && event.Button() == d2enum.MouseButtonLeft {
v.setScreenMode(screenModeMainMenu) v.setScreenMode(screenModeMainMenu)
return true return true
} }

24
d2game/d2gamescreen/map_engine_testing.go
View File

@ -296,26 +296,26 @@ func (met *MapEngineTest) Advance(tickTime float64) error {
// OnKeyRepeat is called to handle repeated key presses // OnKeyRepeat is called to handle repeated key presses
func (met *MapEngineTest) OnKeyRepeat(event d2interface.KeyEvent) bool { func (met *MapEngineTest) OnKeyRepeat(event d2interface.KeyEvent) bool {
var moveSpeed float64 = 8 var moveSpeed float64 = 8
if event.KeyMod() == d2interface.KeyModShift { if event.KeyMod() == d2enum.KeyModShift {
moveSpeed *= 2 moveSpeed *= 2
} }
if event.Key() == d2interface.KeyDown { if event.Key() == d2enum.KeyDown {
met.mapRenderer.MoveCameraBy(0, moveSpeed) met.mapRenderer.MoveCameraBy(0, moveSpeed)
return true return true
} }
if event.Key() == d2interface.KeyUp { if event.Key() == d2enum.KeyUp {
met.mapRenderer.MoveCameraBy(0, -moveSpeed) met.mapRenderer.MoveCameraBy(0, -moveSpeed)
return true return true
} }
if event.Key() == d2interface.KeyRight { if event.Key() == d2enum.KeyRight {
met.mapRenderer.MoveCameraBy(moveSpeed, 0) met.mapRenderer.MoveCameraBy(moveSpeed, 0)
return true return true
} }
if event.Key() == d2interface.KeyLeft { if event.Key() == d2enum.KeyLeft {
met.mapRenderer.MoveCameraBy(-moveSpeed, 0) met.mapRenderer.MoveCameraBy(-moveSpeed, 0)
return true return true
} }
@ -325,17 +325,17 @@ func (met *MapEngineTest) OnKeyRepeat(event d2interface.KeyEvent) bool {
// OnKeyDown defines the actions of the Map Engine Test screen when a key is pressed // OnKeyDown defines the actions of the Map Engine Test screen when a key is pressed
func (met *MapEngineTest) OnKeyDown(event d2interface.KeyEvent) bool { func (met *MapEngineTest) OnKeyDown(event d2interface.KeyEvent) bool {
if event.Key() == d2interface.KeyEscape { if event.Key() == d2enum.KeyEscape {
os.Exit(0) os.Exit(0)
return true return true
} }
if event.Key() == d2interface.KeyN { if event.Key() == d2enum.KeyN {
switch event.KeyMod() { switch event.KeyMod() {
case d2interface.KeyModControl: case d2enum.KeyModControl:
met.fileIndex++ met.fileIndex++
d2screen.SetNextScreen(met) d2screen.SetNextScreen(met)
case d2interface.KeyModShift: case d2enum.KeyModShift:
met.levelPreset = increment(met.levelPreset, met.regionSpec.startPresetIndex, met.regionSpec.endPresetIndex) met.levelPreset = increment(met.levelPreset, met.regionSpec.startPresetIndex, met.regionSpec.endPresetIndex)
d2screen.SetNextScreen(met) d2screen.SetNextScreen(met)
default: default:
@ -346,12 +346,12 @@ func (met *MapEngineTest) OnKeyDown(event d2interface.KeyEvent) bool {
return true return true
} }
if event.Key() == d2interface.KeyP { if event.Key() == d2enum.KeyP {
switch event.KeyMod() { switch event.KeyMod() {
case d2interface.KeyModControl: case d2enum.KeyModControl:
met.fileIndex-- met.fileIndex--
d2screen.SetNextScreen(met) d2screen.SetNextScreen(met)
case d2interface.KeyModShift: case d2enum.KeyModShift:
met.levelPreset = decrement(met.levelPreset, met.regionSpec.startPresetIndex, met.regionSpec.endPresetIndex) met.levelPreset = decrement(met.levelPreset, met.regionSpec.startPresetIndex, met.regionSpec.endPresetIndex)
d2screen.SetNextScreen(met) d2screen.SetNextScreen(met)
default: default:

26
d2game/d2player/game_controls.go
View File

@ -127,26 +127,26 @@ func NewGameControls(renderer d2interface.Renderer, hero *d2mapentity.Player, ma
func (g *GameControls) OnKeyRepeat(event d2interface.KeyEvent) bool { func (g *GameControls) OnKeyRepeat(event d2interface.KeyEvent) bool {
if g.FreeCam { if g.FreeCam {
var moveSpeed float64 = 8 var moveSpeed float64 = 8
if event.KeyMod() == d2interface.KeyModShift { if event.KeyMod() == d2enum.KeyModShift {
moveSpeed *= 2 moveSpeed *= 2
} }
if event.Key() == d2interface.KeyDown { if event.Key() == d2enum.KeyDown {
g.mapRenderer.MoveCameraBy(0, moveSpeed) g.mapRenderer.MoveCameraBy(0, moveSpeed)
return true return true
} }
if event.Key() == d2interface.KeyUp { if event.Key() == d2enum.KeyUp {
g.mapRenderer.MoveCameraBy(0, -moveSpeed) g.mapRenderer.MoveCameraBy(0, -moveSpeed)
return true return true
} }
if event.Key() == d2interface.KeyRight { if event.Key() == d2enum.KeyRight {
g.mapRenderer.MoveCameraBy(moveSpeed, 0) g.mapRenderer.MoveCameraBy(moveSpeed, 0)
return true return true
} }
if event.Key() == d2interface.KeyLeft { if event.Key() == d2enum.KeyLeft {
g.mapRenderer.MoveCameraBy(-moveSpeed, 0) g.mapRenderer.MoveCameraBy(-moveSpeed, 0)
return true return true
} }
@ -157,20 +157,20 @@ func (g *GameControls) OnKeyRepeat(event d2interface.KeyEvent) bool {
func (g *GameControls) OnKeyDown(event d2interface.KeyEvent) bool { func (g *GameControls) OnKeyDown(event d2interface.KeyEvent) bool {
switch event.Key() { switch event.Key() {
case d2interface.KeyEscape: case d2enum.KeyEscape:
if g.inventory.IsOpen() || g.heroStatsPanel.IsOpen() { if g.inventory.IsOpen() || g.heroStatsPanel.IsOpen() {
g.inventory.Close() g.inventory.Close()
g.heroStatsPanel.Close() g.heroStatsPanel.Close()
g.updateLayout() g.updateLayout()
break break
} }
case d2interface.KeyI: case d2enum.KeyI:
g.inventory.Toggle() g.inventory.Toggle()
g.updateLayout() g.updateLayout()
case d2interface.KeyC: case d2enum.KeyC:
g.heroStatsPanel.Toggle() g.heroStatsPanel.Toggle()
g.updateLayout() g.updateLayout()
case d2interface.KeyR: case d2enum.KeyR:
g.onToggleRunButton() g.onToggleRunButton()
default: default:
return false return false
@ -189,8 +189,8 @@ func (g *GameControls) OnMouseButtonRepeat(event d2interface.MouseEvent) bool {
now := d2common.Now() now := d2common.Now()
button := event.Button() button := event.Button()
isLeft := button == d2interface.MouseButtonLeft isLeft := button == d2enum.MouseButtonLeft
isRight := button == d2interface.MouseButtonRight isRight := button == d2enum.MouseButtonRight
lastLeft:= now-lastLeftBtnActionTime lastLeft:= now-lastLeftBtnActionTime
lastRight:= now-lastRightBtnActionTime lastRight:= now-lastRightBtnActionTime
inRect := !g.isInActiveMenusRect(event.X(), event.Y()) inRect := !g.isInActiveMenusRect(event.X(), event.Y())
@ -241,13 +241,13 @@ func (g *GameControls) OnMouseButtonDown(event d2interface.MouseEvent) bool {
px = float64(int(px*10)) / 10.0 px = float64(int(px*10)) / 10.0
py = float64(int(py*10)) / 10.0 py = float64(int(py*10)) / 10.0
if event.Button() == d2interface.MouseButtonLeft && !g.isInActiveMenusRect(mx, my) { if event.Button() == d2enum.MouseButtonLeft && !g.isInActiveMenusRect(mx, my) {
lastLeftBtnActionTime = d2common.Now() lastLeftBtnActionTime = d2common.Now()
g.inputListener.OnPlayerMove(px, py) g.inputListener.OnPlayerMove(px, py)
return true return true
} }
if event.Button() == d2interface.MouseButtonRight && !g.isInActiveMenusRect(mx, my) { if event.Button() == d2enum.MouseButtonRight && !g.isInActiveMenusRect(mx, my) {
lastRightBtnActionTime = d2common.Now() lastRightBtnActionTime = d2common.Now()
g.inputListener.OnPlayerCast(missileID, px, py) g.inputListener.OnPlayerCast(missileID, px, py)
return true return true

2
d2game/d2player/hero_stats_panel.go
View File

@ -130,7 +130,7 @@ func (s *HeroStatsPanel) Render(target d2interface.Surface) {
if s.staticMenuImageCache == nil { if s.staticMenuImageCache == nil {
frameWidth, frameHeight := s.frame.GetFrameBounds() frameWidth, frameHeight := s.frame.GetFrameBounds()
framesCount := s.frame.GetFrameCount() framesCount := s.frame.GetFrameCount()
surface, err := s.renderer.NewSurface(frameWidth*framesCount, frameHeight*framesCount, d2interface.FilterNearest) surface, err := s.renderer.NewSurface(frameWidth*framesCount, frameHeight*framesCount, d2enum.FilterNearest)
if err != nil { if err != nil {
return return