gravestench
/
OpenDiablo2
mirror of https://github.com/OpenDiablo2/OpenDiablo2
1
1
Fork 0
Code Issues Releases Wiki Activity

removed gui manager singleton in d2gui (#735)

This commit is contained in:
Gürkan Kaymak 2020-09-18 23:10:52 +03:00 committed by GitHub
parent d0410001de
commit ef0fbc0581
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
14 changed files with 129 additions and 190 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
d2app/app.go
View File

@ -68,6 +68,7 @@ type App struct {
screen *d2screen.ScreenManager
ui *d2ui.UIManager
tAllocSamples *ring.Ring
guiManager *d2gui.GuiManager
}
type bindTerminalEntry struct {
@ -92,7 +93,6 @@ func Create(gitBranch, gitCommit string,
asset *d2asset.AssetManager,
) *App {
uiManager := d2ui.NewUIManager(asset, renderer, inputManager, audio)
screenManager := d2screen.NewScreenManager(uiManager)
result := &App{
gitBranch: gitBranch,
@ -103,7 +103,6 @@ func Create(gitBranch, gitCommit string,
audio: audio,
renderer: renderer,
ui: uiManager,
screen: screenManager,
asset: asset,
tAllocSamples: createZeroedRing(nSamplesTAlloc),
}
@ -176,10 +175,15 @@ func (a *App) initialize() error {
}
}
if err := d2gui.Initialize(a.asset, a.inputManager); err != nil {
var err error
a.guiManager, err = d2gui.CreateGuiManager(a.asset, a.inputManager)
if err != nil {
return err
}
a.screen = d2screen.NewScreenManager(a.ui, a.guiManager)
config := d2config.Config
a.audio.SetVolumes(config.BgmVolume, config.SfxVolume)
@ -378,7 +382,7 @@ func (a *App) render(target d2interface.Surface) error {
a.ui.Render(target)
if err := d2gui.Render(target); err != nil {
if err := a.guiManager.Render(target); err != nil {
return err
}
@ -412,7 +416,7 @@ func (a *App) advance(elapsed, elapsedUnscaled, current float64) error {
return err
}
if err := d2gui.Advance(elapsed); err != nil {
if err := a.guiManager.Advance(elapsed); err != nil {
return err
}
@ -609,7 +613,7 @@ func (a *App) quitGame() {
}
func (a *App) enterGuiPlayground() {
a.screen.SetNextScreen(d2gamescreen.CreateGuiTestMain(a.renderer))
a.screen.SetNextScreen(d2gamescreen.CreateGuiTestMain(a.renderer, a.guiManager, a.asset))
}
func createZeroedRing(n int) *ring.Ring {
@ -702,12 +706,11 @@ func (a *App) ToCreateGame(filePath string, connType d2clientconnectiontype.Clie
}
a.screen.SetNextScreen(d2gamescreen.CreateGame(a, a.asset, a.ui, a.renderer, a.inputManager,
a.audio, gameClient, a.terminal))
a.audio, gameClient, a.terminal, a.guiManager))
}
// ToCharacterSelect forces the game to transition to the Character Select (load character) screen
func (a *App) ToCharacterSelect(connType d2clientconnectiontype.ClientConnectionType, connHost string) {
characterSelect := d2gamescreen.CreateCharacterSelect(a, a.asset, a.renderer, a.inputManager,
a.audio, a.ui, connType, connHost)

13
d2core/d2gui/common.go
View File

@ -1,25 +1,12 @@
package d2gui
import (
"errors"
"image/color"
"github.com/OpenDiablo2/OpenDiablo2/d2core/d2asset"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2interface"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2math"
)
func loadFont(fontStyle FontStyle) (*d2asset.Font, error) {
config := getFontStyleConfig(fontStyle)
if config == nil {
return nil, errors.New("invalid font style")
}
return singleton.asset.LoadFont(config.fontBasePath+".tbl", config.fontBasePath+".dc6",
config.palettePath)
}
func renderSegmented(animation d2interface.Animation, segmentsX, segmentsY, frameOffset int,
target d2interface.Surface) error {
var currentY int

90
d2core/d2gui/d2gui.go
View File

@ -1,90 +0,0 @@
package d2gui
import (
"errors"
"github.com/OpenDiablo2/OpenDiablo2/d2core/d2asset"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2interface"
)
var (
errWasInit = errors.New("gui system is already initialized")
errNotInit = errors.New("gui system is not initialized")
)
var singleton *manager // nolint:gochecknoglobals // currently global by design
// Initialize creates a singleton gui manager
func Initialize(asset *d2asset.AssetManager, inputManager d2interface.InputManager) error {
verifyNotInit()
var err error
if singleton, err = createGuiManager(asset, inputManager); err != nil {
return err
}
return nil
}
// Render all of the gui elements
func Render(target d2interface.Surface) error {
verifyWasInit()
return singleton.render(target)
}
// Advance all of the gui elements
func Advance(elapsed float64) error {
verifyWasInit()
return singleton.advance(elapsed)
}
// CreateLayout creates a dynamic layout
func CreateLayout(renderer d2interface.Renderer, positionType PositionType) *Layout {
verifyWasInit()
return createLayout(renderer, positionType)
}
// SetLayout sets the gui manager's layout
func SetLayout(layout *Layout) {
verifyWasInit()
singleton.SetLayout(layout)
}
// ShowLoadScreen renders the loading progress screen.
// The provided progress argument defines the loading animation's state in the range `[0, 1]`,
// where `0` is initial frame and `1` is the final frame
func ShowLoadScreen(progress float64) {
verifyWasInit()
singleton.showLoadScreen(progress)
}
// HideLoadScreen hides the loading screen
func HideLoadScreen() {
verifyWasInit()
singleton.hideLoadScreen()
}
// ShowCursor shows the in-game mouse cursor
func ShowCursor() {
verifyWasInit()
singleton.showCursor()
}
// HideCursor hides the in-game mouse cursor
func HideCursor() {
verifyWasInit()
singleton.hideCursor()
}
func verifyWasInit() {
if singleton == nil {
panic(errNotInit)
}
}
func verifyNotInit() {
if singleton != nil {
panic(errWasInit)
}
}

45
d2core/d2gui/manager.go → d2core/d2gui/gui_manager.go
View File

@ -9,7 +9,7 @@ import (
"github.com/OpenDiablo2/OpenDiablo2/d2core/d2asset"
)
type manager struct {
type GuiManager struct {
asset *d2asset.AssetManager
layout *Layout
cursorAnim d2interface.Animation
@ -20,7 +20,8 @@ type manager struct {
loading bool
}
func createGuiManager(asset *d2asset.AssetManager, inputManager d2interface.InputManager) (*manager, error) {
// CreateGuiManager creates an instance of the GuiManager
func CreateGuiManager(asset *d2asset.AssetManager, inputManager d2interface.InputManager) (*GuiManager, error) {
cursorAnim, err := asset.LoadAnimation(d2resource.CursorDefault, d2resource.PaletteUnits)
if err != nil {
return nil, err
@ -31,7 +32,7 @@ func createGuiManager(asset *d2asset.AssetManager, inputManager d2interface.Inpu
return nil, err
}
manager := &manager{
manager := &GuiManager{
asset: asset,
cursorAnim: cursorAnim,
loadingAnim: loadingAnim,
@ -47,14 +48,16 @@ func createGuiManager(asset *d2asset.AssetManager, inputManager d2interface.Inpu
return manager, nil
}
func (m *manager) SetLayout(layout *Layout) {
// SetLayout sets the layout of the GuiManager
func (m *GuiManager) SetLayout(layout *Layout) {
m.layout = layout
if m.layout != nil {
m.layout.AdjustEntryPlacement()
}
}
func (m *manager) OnMouseButtonDown(event d2interface.MouseEvent) bool {
// OnMouseButtonDown handles mouse button click events
func (m *GuiManager) OnMouseButtonDown(event d2interface.MouseEvent) bool {
if m.layout == nil {
return false
}
@ -62,7 +65,8 @@ func (m *manager) OnMouseButtonDown(event d2interface.MouseEvent) bool {
return m.layout.onMouseButtonDown(event)
}
func (m *manager) OnMouseButtonUp(event d2interface.MouseEvent) bool {
// OnMouseButtonUp handles the mouse button release events
func (m *GuiManager) OnMouseButtonUp(event d2interface.MouseEvent) bool {
if m.layout == nil {
return false
}
@ -70,7 +74,8 @@ func (m *manager) OnMouseButtonUp(event d2interface.MouseEvent) bool {
return m.layout.onMouseButtonUp(event)
}
func (m *manager) OnMouseMove(event d2interface.MouseMoveEvent) bool {
// OnMouseMove handles mouse movement events
func (m *GuiManager) OnMouseMove(event d2interface.MouseMoveEvent) bool {
m.cursorX = event.X()
m.cursorY = event.Y()
@ -81,7 +86,8 @@ func (m *manager) OnMouseMove(event d2interface.MouseMoveEvent) bool {
return m.layout.onMouseMove(event)
}
func (m *manager) render(target d2interface.Surface) error {
// Render renders the GuiManager to the given surface
func (m *GuiManager) Render(target d2interface.Surface) error {
if m.loading {
if err := m.renderLoadScreen(target); err != nil {
return err
@ -102,7 +108,7 @@ func (m *manager) render(target d2interface.Surface) error {
return nil
}
func (m *manager) renderLoadScreen(target d2interface.Surface) error {
func (m *GuiManager) renderLoadScreen(target d2interface.Surface) error {
if clearErr := target.Clear(color.Black); clearErr != nil {
return clearErr
}
@ -123,7 +129,7 @@ func (m *manager) renderLoadScreen(target d2interface.Surface) error {
return m.loadingAnim.Render(target)
}
func (m *manager) renderCursor(target d2interface.Surface) error {
func (m *GuiManager) renderCursor(target d2interface.Surface) error {
_, height := m.cursorAnim.GetCurrentFrameSize()
pushCount := 0
@ -138,7 +144,8 @@ func (m *manager) renderCursor(target d2interface.Surface) error {
return m.cursorAnim.Render(target)
}
func (m *manager) advance(elapsed float64) error {
// Advance advances the GuiManager state
func (m *GuiManager) Advance(elapsed float64) error {
if !m.loading && m.layout != nil {
if err := m.layout.advance(elapsed); err != nil {
return err
@ -148,7 +155,8 @@ func (m *manager) advance(elapsed float64) error {
return nil
}
func (m *manager) showLoadScreen(progress float64) {
// ShowLoadScreen shows the loading screen with the given progress
func (m *GuiManager) ShowLoadScreen(progress float64) {
progress = math.Min(progress, 1.0)
progress = math.Max(progress, 0.0)
@ -160,19 +168,22 @@ func (m *manager) showLoadScreen(progress float64) {
m.loading = true
}
func (m *manager) hideLoadScreen() {
// HideLoadScreen hides the load screen
func (m *GuiManager) HideLoadScreen() {
m.loading = false
}
func (m *manager) showCursor() {
// ShowCursor makes the cursor visible
func (m *GuiManager) ShowCursor() {
m.cursorVisible = true
}
func (m *manager) hideCursor() {
// HideCursor hides the cursor
func (m *GuiManager) HideCursor() {
m.cursorVisible = false
}
func (m *manager) clear() {
func (m *GuiManager) clear() {
m.SetLayout(nil)
m.hideLoadScreen()
m.HideLoadScreen()
}

9
d2core/d2gui/label.go
View File

@ -16,12 +16,7 @@ type Label struct {
surface d2interface.Surface
}
func createLabel(renderer d2interface.Renderer, text string, fontStyle FontStyle) (*Label, error) {
font, err := loadFont(fontStyle)
if err != nil {
return nil, err
}
func createLabel(renderer d2interface.Renderer, text string, font *d2asset.Font) *Label {
label := &Label{
font: font,
renderer: renderer,
@ -30,7 +25,7 @@ func createLabel(renderer d2interface.Renderer, text string, fontStyle FontStyle
_ = label.setText(text)
label.SetVisible(true)
return label, nil
return label
}
func (l *Label) render(target d2interface.Surface) error {

30
d2core/d2gui/layout.go
View File

@ -6,6 +6,7 @@ import (
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2enum"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2interface"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2math"
"github.com/OpenDiablo2/OpenDiablo2/d2core/d2asset"
)
const layoutDebug = false // turns on debug rendering stuff for layouts
@ -53,7 +54,8 @@ const (
type Layout struct {
widgetBase
renderer d2interface.Renderer
renderer d2interface.Renderer
assetManager *d2asset.AssetManager
width int
height int
@ -63,10 +65,11 @@ type Layout struct {
entries []*layoutEntry
}
func createLayout(renderer d2interface.Renderer, positionType PositionType) *Layout {
func CreateLayout(renderer d2interface.Renderer, positionType PositionType, assetManager *d2asset.AssetManager) *Layout {
layout := &Layout{
renderer: renderer,
positionType: positionType,
assetManager: assetManager,
}
layout.SetVisible(true)
@ -93,7 +96,7 @@ func (l *Layout) SetHorizontalAlign(horizontalAlign HorizontalAlign) {
// AddLayout adds a nested layout to this layout, given a position type.
// Returns a pointer to the nested layout
func (l *Layout) AddLayout(positionType PositionType) *Layout {
layout := createLayout(l.renderer, positionType)
layout := CreateLayout(l.renderer, positionType, l.assetManager)
l.entries = append(l.entries, &layoutEntry{widget: layout})
return layout
@ -121,7 +124,7 @@ func (l *Layout) AddSpacerDynamic() *SpacerDynamic {
// AddSprite given a path and palette, adds a Sprite as a layout entry
func (l *Layout) AddSprite(imagePath, palettePath string) (*Sprite, error) {
sprite, err := createSprite(imagePath, palettePath)
sprite, err := createSprite(imagePath, palettePath, l.assetManager)
if err != nil {
return nil, err
}
@ -134,7 +137,7 @@ func (l *Layout) AddSprite(imagePath, palettePath string) (*Sprite, error) {
// AddAnimatedSprite given a path, palette, and direction will add an animated
// sprite as a layout entry
func (l *Layout) AddAnimatedSprite(imagePath, palettePath string, direction AnimationDirection) (*AnimatedSprite, error) {
sprite, err := createAnimatedSprite(imagePath, palettePath, direction)
sprite, err := createAnimatedSprite(imagePath, palettePath, direction, l.assetManager)
if err != nil {
return nil, err
}
@ -146,11 +149,13 @@ func (l *Layout) AddAnimatedSprite(imagePath, palettePath string, direction Anim
// AddLabel given a string and a FontStyle, adds a text label as a layout entry
func (l *Layout) AddLabel(text string, fontStyle FontStyle) (*Label, error) {
label, err := createLabel(l.renderer, text, fontStyle)
font, err := l.loadFont(fontStyle)
if err != nil {
return nil, err
}
label := createLabel(l.renderer, text, font)
l.entries = append(l.entries, &layoutEntry{widget: label})
return label, nil
@ -419,7 +424,7 @@ func (l *Layout) createButton(renderer d2interface.Renderer, text string,
return nil, errors.New("invalid button style")
}
animation, loadErr := singleton.asset.LoadAnimation(config.animationPath, config.palettePath)
animation, loadErr := l.assetManager.LoadAnimation(config.animationPath, config.palettePath)
if loadErr != nil {
return nil, loadErr
}
@ -446,7 +451,7 @@ func (l *Layout) createButton(renderer d2interface.Renderer, text string,
buttonHeight += h
}
font, loadErr := loadFont(config.fontStyle)
font, loadErr := l.loadFont(config.fontStyle)
if loadErr != nil {
return nil, loadErr
}
@ -496,3 +501,12 @@ func (l *Layout) createButton(renderer d2interface.Renderer, text string,
return button, nil
}
func (l *Layout) loadFont(fontStyle FontStyle) (*d2asset.Font, error) {
config := getFontStyleConfig(fontStyle)
if config == nil {
return nil, errors.New("invalid font style")
}
return l.assetManager.LoadFont(config.fontBasePath+".tbl", config.fontBasePath+".dc6", config.palettePath)
}

15
d2core/d2gui/sprite.go
View File

@ -3,6 +3,7 @@ package d2gui
import (
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2enum"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2interface"
"github.com/OpenDiablo2/OpenDiablo2/d2core/d2asset"
)
// AnimationDirection is a the animation play direction
@ -30,8 +31,8 @@ type AnimatedSprite struct {
*Sprite
}
func createSprite(imagePath, palettePath string) (*Sprite, error) {
animation, err := singleton.asset.LoadAnimation(imagePath, palettePath)
func createSprite(imagePath, palettePath string, assetManager *d2asset.AssetManager) (*Sprite, error) {
animation, err := assetManager.LoadAnimation(imagePath, palettePath)
if err != nil {
return nil, err
}
@ -43,17 +44,13 @@ func createSprite(imagePath, palettePath string) (*Sprite, error) {
return sprite, nil
}
func createAnimatedSprite(imagePath, palettePath string, direction AnimationDirection) (*AnimatedSprite, error) {
animation, err := singleton.asset.LoadAnimation(imagePath, palettePath)
func createAnimatedSprite(imagePath, palettePath string, direction AnimationDirection, assetManager *d2asset.AssetManager) (*AnimatedSprite, error) {
animation, err := assetManager.LoadAnimation(imagePath, palettePath)
if err != nil {
return nil, err
}
sprite := &AnimatedSprite{
&Sprite{},
}
sprite.animation = animation
sprite := &AnimatedSprite{Sprite: &Sprite{animation: animation}}
if direction == DirectionForward {
sprite.animation.PlayForward()

10
d2core/d2screen/d2screen.go
View File

@ -2,18 +2,8 @@ package d2screen
import (
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2interface"
"github.com/OpenDiablo2/OpenDiablo2/d2core/d2ui"
)
// NewScreenManager creates a screen manager
func NewScreenManager(ui *d2ui.UIManager) *ScreenManager {
sm := &ScreenManager{
uiManager: ui,
}
return sm
}
// Screen is an exported interface
type Screen interface{}

18
d2core/d2screen/screen_manager.go
View File

@ -15,6 +15,12 @@ type ScreenManager struct {
loadingScreen Screen
loadingState LoadingState
currentScreen Screen
guiManager *d2gui.GuiManager
}
// NewScreenManager creates a screen manager
func NewScreenManager(ui *d2ui.UIManager, guiManager *d2gui.GuiManager) *ScreenManager {
return &ScreenManager{uiManager: ui, guiManager: guiManager}
}
// SetNextScreen is about to set a given screen as next
@ -37,14 +43,14 @@ func (sm *ScreenManager) Advance(elapsed float64) error {
return load.err
}
d2gui.ShowLoadScreen(load.progress)
sm.guiManager.ShowLoadScreen(load.progress)
if load.done {
sm.currentScreen = sm.loadingScreen
sm.loadingScreen = nil
d2gui.ShowCursor()
d2gui.HideLoadScreen()
sm.guiManager.ShowCursor()
sm.guiManager.HideLoadScreen()
}
case sm.nextScreen != nil:
if handler, ok := sm.currentScreen.(ScreenUnloadHandler); ok {
@ -54,11 +60,11 @@ func (sm *ScreenManager) Advance(elapsed float64) error {
}
sm.uiManager.Reset()
d2gui.SetLayout(nil)
sm.guiManager.SetLayout(nil)
if handler, ok := sm.nextScreen.(ScreenLoadHandler); ok {
d2gui.ShowLoadScreen(0)
d2gui.HideCursor()
sm.guiManager.ShowLoadScreen(0)
sm.guiManager.HideCursor()
sm.loadingState = LoadingState{updates: make(chan loadingUpdate)}

18
d2game/d2gamescreen/escape_menu.go
View File

@ -6,6 +6,7 @@ import (
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2enum"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2interface"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2resource"
"github.com/OpenDiablo2/OpenDiablo2/d2core/d2asset"
"github.com/OpenDiablo2/OpenDiablo2/d2core/d2gui"
)
@ -70,6 +71,8 @@ type EscapeMenu struct {
renderer d2interface.Renderer
audioProvider d2interface.AudioProvider
navigator Navigator
guiManager *d2gui.GuiManager
assetManager *d2asset.AssetManager
}
type layout struct {
@ -123,11 +126,18 @@ type actionableElement interface {
}
// NewEscapeMenu creates a new escape menu
func NewEscapeMenu(navigator Navigator, renderer d2interface.Renderer, audioProvider d2interface.AudioProvider) *EscapeMenu {
func NewEscapeMenu(navigator Navigator,
renderer d2interface.Renderer,
audioProvider d2interface.AudioProvider,
guiManager *d2gui.GuiManager,
assetManager *d2asset.AssetManager,
) *EscapeMenu {
m := &EscapeMenu{
audioProvider: audioProvider,
renderer: renderer,
navigator: navigator,
guiManager: guiManager,
assetManager: assetManager,
}
m.layouts = []*layout{
@ -206,7 +216,7 @@ func (m *EscapeMenu) newConfigureControlsLayout() *layout {
}
func (m *EscapeMenu) wrapLayout(fn func(*layout)) *layout {
wrapper := d2gui.CreateLayout(m.renderer, d2gui.PositionTypeHorizontal)
wrapper := d2gui.CreateLayout(m.renderer, d2gui.PositionTypeHorizontal, m.assetManager)
wrapper.SetVerticalAlign(d2gui.VerticalAlignMiddle)
wrapper.AddSpacerDynamic()
@ -346,7 +356,7 @@ func (m *EscapeMenu) onEscKey() {
func (m *EscapeMenu) close() {
m.isOpen = false
d2gui.SetLayout(nil)
m.guiManager.SetLayout(nil)
}
func (m *EscapeMenu) open() {
@ -393,7 +403,7 @@ func (m *EscapeMenu) setLayout(id layoutID) {
m.rightPent = m.layouts[id].rightPent
m.currentLayout = id
m.layouts[id].currentEl = 0
d2gui.SetLayout(m.layouts[id].Layout)
m.guiManager.SetLayout(m.layouts[id].Layout)
m.onHoverElement(0)
}

10
d2game/d2gamescreen/game.go
View File

@ -5,6 +5,7 @@ import (
"image/color"
"github.com/OpenDiablo2/OpenDiablo2/d2core/d2asset"
"github.com/OpenDiablo2/OpenDiablo2/d2core/d2gui"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2math/d2vector"
"github.com/OpenDiablo2/OpenDiablo2/d2core/d2ui"
@ -44,6 +45,7 @@ type Game struct {
escapeMenu *EscapeMenu
soundEngine *d2audio.SoundEngine
soundEnv d2audio.SoundEnvironment
guiManager *d2gui.GuiManager
renderer d2interface.Renderer
inputManager d2interface.InputManager
@ -61,6 +63,7 @@ func CreateGame(
audioProvider d2interface.AudioProvider,
gameClient *d2client.GameClient,
term d2interface.Terminal,
guiManager *d2gui.GuiManager,
) *Game {
// find the local player and its initial location
var startX, startY float64
@ -85,13 +88,14 @@ func CreateGame(
ticksSinceLevelCheck: 0,
mapRenderer: d2maprenderer.CreateMapRenderer(asset, renderer,
gameClient.MapEngine, term, startX, startY),
escapeMenu: NewEscapeMenu(navigator, renderer, audioProvider),
escapeMenu: NewEscapeMenu(navigator, renderer, audioProvider, guiManager, asset),
inputManager: inputManager,
audioProvider: audioProvider,
renderer: renderer,
terminal: term,
soundEngine: d2audio.NewSoundEngine(audioProvider, term),
uiManager: ui,
guiManager: guiManager,
}
result.soundEnv = d2audio.NewSoundEnvironment(result.soundEngine)
@ -275,8 +279,8 @@ func (v *Game) bindGameControls() error {
v.localPlayer = player
var err error
v.gameControls, err = d2player.NewGameControls(v.asset, v.renderer, player,
v.gameClient.MapEngine, v.mapRenderer, v, v.terminal, v.uiManager, v.gameClient.IsSinglePlayer())
v.gameControls, err = d2player.NewGameControls(v.asset, v.renderer, player, v.gameClient.MapEngine,
v.mapRenderer, v, v.terminal, v.uiManager, v.guiManager, v.gameClient.IsSinglePlayer())
if err != nil {
return err

15
d2game/d2gamescreen/gui_testing.go
View File

@ -4,25 +4,30 @@ import (
"fmt"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2interface"
"github.com/OpenDiablo2/OpenDiablo2/d2core/d2asset"
"github.com/OpenDiablo2/OpenDiablo2/d2core/d2gui"
"github.com/OpenDiablo2/OpenDiablo2/d2core/d2screen"
)
// GuiTestMain is a playground screen for the gui components
type GuiTestMain struct {
renderer d2interface.Renderer
renderer d2interface.Renderer
guiManager *d2gui.GuiManager
assetManager *d2asset.AssetManager
}
// CreateGuiTestMain creates a GuiTestMain screen
func CreateGuiTestMain(renderer d2interface.Renderer) *GuiTestMain {
func CreateGuiTestMain(renderer d2interface.Renderer, guiManager *d2gui.GuiManager, assetManager *d2asset.AssetManager) *GuiTestMain {
return &GuiTestMain{
renderer: renderer,
renderer: renderer,
guiManager: guiManager,
assetManager: assetManager,
}
}
// OnLoad loads the resources and creates the gui components
func (g *GuiTestMain) OnLoad(loading d2screen.LoadingState) {
layout := d2gui.CreateLayout(g.renderer, d2gui.PositionTypeHorizontal)
layout := d2gui.CreateLayout(g.renderer, d2gui.PositionTypeHorizontal, g.assetManager)
loading.Progress(thirtyPercent)
//
@ -85,7 +90,7 @@ func (g *GuiTestMain) OnLoad(loading d2screen.LoadingState) {
loading.Progress(ninetyPercent)
layout.SetVerticalAlign(d2gui.VerticalAlignMiddle)
d2gui.SetLayout(layout)
g.guiManager.SetLayout(layout)
}
// Render does nothing for the GuiTestMain screen

3
d2game/d2player/game_controls.go
View File

@ -112,6 +112,7 @@ func NewGameControls(
inputListener InputCallbackListener,
term d2interface.Terminal,
ui *d2ui.UIManager,
guiManager *d2gui.GuiManager,
isSinglePlayer bool,
) (*GameControls, error) {
missileID := initialMissileID
@ -172,7 +173,7 @@ func NewGameControls(
mapRenderer: mapRenderer,
inventory: NewInventory(asset, ui, inventoryRecord),
heroStatsPanel: NewHeroStatsPanel(asset, ui, hero.Name(), hero.Class, hero.Stats),
helpOverlay: help.NewHelpOverlay(asset, renderer, ui),
helpOverlay: help.NewHelpOverlay(asset, renderer, ui, guiManager),
miniPanel: newMiniPanel(asset, ui, isSinglePlayer),
missileID: missileID,
nameLabel: hoverLabel,

24
d2game/d2player/help/help.go
View File

@ -22,7 +22,7 @@ const (
rFrame
)
// HelpOverlay represents the in-game overlay that toggles visibility when the h key is pressed
// Overlay represents the in-game overlay that toggles visibility when the h key is pressed
type Overlay struct {
asset *d2asset.AssetManager
isOpen bool
@ -35,14 +35,20 @@ type Overlay struct {
originY int
layout *d2gui.Layout
closeButton *d2ui.Button
guiManager *d2gui.GuiManager
}
func NewHelpOverlay(asset *d2asset.AssetManager, renderer d2interface.Renderer,
ui *d2ui.UIManager) *Overlay {
func NewHelpOverlay(
asset *d2asset.AssetManager,
renderer d2interface.Renderer,
ui *d2ui.UIManager,
guiManager *d2gui.GuiManager,
) *Overlay {
h := &Overlay{
asset: asset,
renderer: renderer,
uiManager: ui,
asset: asset,
renderer: renderer,
uiManager: ui,
guiManager: guiManager,
}
return h
@ -65,19 +71,19 @@ func (h *Overlay) Toggle() {
func (h *Overlay) close() {
h.isOpen = false
h.closeButton.SetVisible(false)
d2gui.SetLayout(nil)
h.guiManager.SetLayout(nil)
}
func (h *Overlay) open() {
h.isOpen = true
if h.layout == nil {
h.layout = d2gui.CreateLayout(h.renderer, d2gui.PositionTypeHorizontal)
h.layout = d2gui.CreateLayout(h.renderer, d2gui.PositionTypeHorizontal, h.asset)
}
h.closeButton.SetVisible(true)
h.closeButton.SetPressed(false)
d2gui.SetLayout(h.layout)
h.guiManager.SetLayout(h.layout)
}
func (h *Overlay) IsOpen() bool {