rely on App to know how to navigate between screens using a callback interface with explicit methods (#592)

remove unused struct vars that were only stored in order to pass to the next screens

consolidate create game code to single method

export ScreenMode consts and SetScreenMode method to allow app to create the correct screens

Co-authored-by: carrelda <carrelda@git>

d2app/app.go

@@ -29,6 +29,8 @@ import (
 	"github.com/OpenDiablo2/OpenDiablo2/d2core/d2screen"
 	"github.com/OpenDiablo2/OpenDiablo2/d2core/d2ui"
 	"github.com/OpenDiablo2/OpenDiablo2/d2game/d2gamescreen"
+	"github.com/OpenDiablo2/OpenDiablo2/d2networking/d2client"
+	"github.com/OpenDiablo2/OpenDiablo2/d2networking/d2client/d2clientconnectiontype"
 	"github.com/OpenDiablo2/OpenDiablo2/d2script"
 	"github.com/pkg/profile"
 	"golang.org/x/image/colornames"
@@ -110,7 +112,7 @@ func (p *App) Run() error {
 		return err
 	}
 
-	d2screen.SetNextScreen(d2gamescreen.CreateMainMenu(p.renderer, p.inputManager, p.audio, p.terminal, p.scriptEngine))
+	p.ToMainMenu()
 
 	if p.gitBranch == "" {
 		p.gitBranch = "Local Build"
@@ -601,3 +603,39 @@ func updateInitError(target d2interface.Surface) error {
 
 	return nil
 }
+
+func (a *App) ToMainMenu() {
+	mainMenu := d2gamescreen.CreateMainMenu(a, a.renderer, a.inputManager, a.audio)
+	mainMenu.SetScreenMode(d2gamescreen.ScreenModeMainMenu)
+	d2screen.SetNextScreen(mainMenu)
+}
+
+func (a *App) ToSelectHero(connType d2clientconnectiontype.ClientConnectionType, host string) {
+	selectHero := d2gamescreen.CreateSelectHeroClass(a, a.renderer, a.audio, connType, host)
+	d2screen.SetNextScreen(selectHero)
+}
+
+func (a *App) ToCreateGame(filePath string, connType d2clientconnectiontype.ClientConnectionType, host string) {
+	gameClient, _ := d2client.Create(connType, a.scriptEngine)
+
+	if err := gameClient.Open(host, filePath); err != nil {
+		// TODO an error screen should be shown in this case
+		fmt.Printf("can not connect to the host: %s", host)
+	}
+
+	d2screen.SetNextScreen(d2gamescreen.CreateGame(a, a.renderer, a.inputManager, a.audio, gameClient, a.terminal))
+}
+
+func (a *App) ToCharacterSelect(connType d2clientconnectiontype.ClientConnectionType, connHost string) {
+	characterSelect := d2gamescreen.CreateCharacterSelect(a, a.renderer, a.inputManager, a.audio, connType, connHost)
+	d2screen.SetNextScreen(characterSelect)
+}
+
+func (a *App) ToMapEngineTest(region int, level int) {
+	met := d2gamescreen.CreateMapEngineTest(0, 1, a.terminal, a.renderer, a.inputManager)
+	d2screen.SetNextScreen(met)
+}
+
+func (a *App) ToCredits() {
+	d2screen.SetNextScreen(d2gamescreen.CreateCredits(a, a.renderer))
+}

d2core/d2screen/d2screen.go

@@ -126,19 +126,16 @@ type loadingUpdate struct {
 }
 
 // Error provides a way for callers to report an error during loading.
-// This is meant to be delivered via the progress channel in OnLoad implementations.
 func (l *LoadingState) Error(err error) {
 	l.updates <- loadingUpdate{err: err}
 }
 
 // Progress provides a way for callers to report the ratio between `0` and `1` of the progress made loading a screen.
-// This is meant to be delivered via the progress channel in OnLoad implementations.
 func (l *LoadingState) Progress(ratio float64) {
 	l.updates <- loadingUpdate{progress: ratio}
 }
 
 // Done provides a way for callers to report that screen loading has been completed.
-// This is meant to be delivered via the progress channel in OnLoad implementations.
 func (l *LoadingState) Done() {
 	l.updates <- loadingUpdate{progress: 1.0}
 	l.updates <- loadingUpdate{done: true}

d2game/d2gamescreen/character_select.go

@@ -16,9 +16,7 @@ import (
 	"github.com/OpenDiablo2/OpenDiablo2/d2core/d2screen"
 	"github.com/OpenDiablo2/OpenDiablo2/d2core/d2ui"
 	"github.com/OpenDiablo2/OpenDiablo2/d2game/d2player"
-	"github.com/OpenDiablo2/OpenDiablo2/d2networking/d2client"
 	"github.com/OpenDiablo2/OpenDiablo2/d2networking/d2client/d2clientconnectiontype"
-	"github.com/OpenDiablo2/OpenDiablo2/d2script"
 )
 
 // CharacterSelect represents the character select screen
@@ -45,20 +43,21 @@ type CharacterSelect struct {
 	showDeleteConfirmation bool
 	connectionType         d2clientconnectiontype.ClientConnectionType
 	connectionHost         string
-	inputManager           d2interface.InputManager
+
-	audioProvider          d2interface.AudioProvider
+	inputManager  d2interface.InputManager
-	terminal               d2interface.Terminal
+	audioProvider d2interface.AudioProvider
-	scriptEngine           *d2script.ScriptEngine
+	renderer      d2interface.Renderer
-	renderer               d2interface.Renderer
+	navigator     Navigator
 }
 
 // CreateCharacterSelect creates the character select screen and returns a pointer to it
 func CreateCharacterSelect(
+	navigator Navigator,
 	renderer d2interface.Renderer,
 	inputManager d2interface.InputManager,
 	audioProvider d2interface.AudioProvider,
 	connectionType d2clientconnectiontype.ClientConnectionType,
-	connectionHost string, term d2interface.Terminal, scriptEngine *d2script.ScriptEngine,
+	connectionHost string,
 ) *CharacterSelect {
 	return &CharacterSelect{
 		selectedCharacter: -1,
@@ -67,8 +66,7 @@ func CreateCharacterSelect(
 		connectionHost:    connectionHost,
 		inputManager:      inputManager,
 		audioProvider:     audioProvider,
-		terminal:          term,
+		navigator:         navigator,
-		scriptEngine:      scriptEngine,
 	}
 }
 
@@ -215,14 +213,11 @@ func (v *CharacterSelect) updateCharacterBoxes() {
 }
 
 func (v *CharacterSelect) onNewCharButtonClicked() {
-	d2screen.SetNextScreen(CreateSelectHeroClass(v.renderer, v.inputManager, v.audioProvider, v.connectionType, v.connectionHost,
+	v.navigator.ToSelectHero(v.connectionType, v.connectionHost)
-		v.terminal, v.scriptEngine))
 }
 
 func (v *CharacterSelect) onExitButtonClicked() {
-	mainMenu := CreateMainMenu(v.renderer, v.inputManager, v.audioProvider, v.terminal, v.scriptEngine)
+	v.navigator.ToMainMenu()
-	mainMenu.setScreenMode(screenModeMainMenu)
-	d2screen.SetNextScreen(mainMenu)
 }
 
 // Render renders the Character Select screen
@@ -366,17 +361,5 @@ func (v *CharacterSelect) refreshGameStates() {
 }
 
 func (v *CharacterSelect) onOkButtonClicked() {
-	gameClient, _ := d2client.Create(v.connectionType, v.scriptEngine)
+	v.navigator.ToCreateGame(v.gameStates[v.selectedCharacter].FilePath, v.connectionType, v.connectionHost)
-
-	host := ""
-	if v.connectionType == d2clientconnectiontype.LANClient {
-		host = v.connectionHost
-	}
-
-	if err := gameClient.Open(host, v.gameStates[v.selectedCharacter].FilePath); err != nil {
-		// TODO an error screen should be shown in this case
-		fmt.Printf("can not connect to the host: %s", host)
-	}
-
-	d2screen.SetNextScreen(CreateGame(v.renderer, v.inputManager, v.audioProvider, gameClient, v.terminal, v.scriptEngine))
 }

d2game/d2gamescreen/credits.go

@@ -15,7 +15,6 @@ import (
 	"github.com/OpenDiablo2/OpenDiablo2/d2core/d2asset"
 	"github.com/OpenDiablo2/OpenDiablo2/d2core/d2screen"
 	"github.com/OpenDiablo2/OpenDiablo2/d2core/d2ui"
-	"github.com/OpenDiablo2/OpenDiablo2/d2script"
 )
 
 type labelItem struct {
@@ -33,24 +32,20 @@ type Credits struct {
 	cycleTime          float64
 	cyclesTillNextLine int
 	doneWithCredits    bool
-	renderer           d2interface.Renderer
+
-	inputManager       d2interface.InputManager
+	renderer  d2interface.Renderer
-	audioProvider      d2interface.AudioProvider
+	navigator Navigator
-	terminal           d2interface.Terminal
-	scriptEngine       *d2script.ScriptEngine
 }
 
 // CreateCredits creates an instance of the credits screen
-func CreateCredits(renderer d2interface.Renderer, inputManager d2interface.InputManager, audioProvider d2interface.AudioProvider, scriptEngine *d2script.ScriptEngine) *Credits {
+func CreateCredits(navigator Navigator, renderer d2interface.Renderer) *Credits {
 	result := &Credits{
 		labels:             make([]*labelItem, 0),
 		cycleTime:          0,
 		doneWithCredits:    false,
 		cyclesTillNextLine: 0,
 		renderer:           renderer,
-		inputManager:       inputManager,
+		navigator:          navigator,
-		audioProvider:      audioProvider,
-		scriptEngine:       scriptEngine,
 	}
 
 	return result
@@ -162,9 +157,7 @@ func (v *Credits) Advance(tickTime float64) error {
 }
 
 func (v *Credits) onExitButtonClicked() {
-	mainMenu := CreateMainMenu(v.renderer, v.inputManager, v.audioProvider, v.terminal, v.scriptEngine)
+	v.navigator.ToMainMenu()
-	mainMenu.setScreenMode(screenModeMainMenu)
-	d2screen.SetNextScreen(mainMenu)
 }
 
 func (v *Credits) addNextItem() {

d2game/d2gamescreen/escape_menu.go

@@ -7,8 +7,6 @@ import (
 	"github.com/OpenDiablo2/OpenDiablo2/d2common/d2interface"
 	"github.com/OpenDiablo2/OpenDiablo2/d2common/d2resource"
 	"github.com/OpenDiablo2/OpenDiablo2/d2core/d2gui"
-	"github.com/OpenDiablo2/OpenDiablo2/d2core/d2screen"
-	"github.com/OpenDiablo2/OpenDiablo2/d2script"
 )
 
 // TODO: fix pentagram
@@ -69,10 +67,8 @@ type EscapeMenu struct {
 	layouts   []*layout
 
 	renderer      d2interface.Renderer
-	inputManager  d2interface.InputManager
 	audioProvider d2interface.AudioProvider
-	terminal      d2interface.Terminal
+	navigator     Navigator
-	scriptEngine  *d2script.ScriptEngine
 }
 
 type layout struct {
@@ -126,14 +122,11 @@ type actionableElement interface {
 }
 
 // NewEscapeMenu creates a new escape menu
-func NewEscapeMenu(renderer d2interface.Renderer, inputManager d2interface.InputManager, audioProvider d2interface.AudioProvider, term d2interface.Terminal,
+func NewEscapeMenu(navigator Navigator, renderer d2interface.Renderer, audioProvider d2interface.AudioProvider) *EscapeMenu {
-	scriptEngine *d2script.ScriptEngine) *EscapeMenu {
 	m := &EscapeMenu{
-		inputManager:  inputManager,
 		audioProvider: audioProvider,
-		terminal:      term,
 		renderer:      renderer,
-		scriptEngine:  scriptEngine,
+		navigator:     navigator,
 	}
 
 	m.layouts = []*layout{
@@ -373,10 +366,7 @@ func (m *EscapeMenu) showLayout(id layoutID) {
 	}
 
 	if id == saveLayoutID {
-		mainMenu := CreateMainMenu(m.renderer, m.inputManager, m.audioProvider, m.terminal, m.scriptEngine)
+		m.navigator.ToMainMenu()
-		mainMenu.setScreenMode(screenModeMainMenu)
-		d2screen.SetNextScreen(mainMenu)
-
 		return
 	}
 

d2game/d2gamescreen/game.go

@@ -14,7 +14,6 @@ import (
 	"github.com/OpenDiablo2/OpenDiablo2/d2game/d2player"
 	"github.com/OpenDiablo2/OpenDiablo2/d2networking/d2client"
 	"github.com/OpenDiablo2/OpenDiablo2/d2networking/d2netpacket"
-	"github.com/OpenDiablo2/OpenDiablo2/d2script"
 )
 
 const hideZoneTextAfterSeconds = 2.0
@@ -36,8 +35,7 @@ type Game struct {
 }
 
 // CreateGame creates the Gameplay screen and returns a pointer to it
-func CreateGame(renderer d2interface.Renderer, inputManager d2interface.InputManager, audioProvider d2interface.AudioProvider, gameClient *d2client.GameClient,
+func CreateGame(navigator Navigator, renderer d2interface.Renderer, inputManager d2interface.InputManager, audioProvider d2interface.AudioProvider, gameClient *d2client.GameClient, term d2interface.Terminal) *Game {
-	term d2interface.Terminal, scriptEngine *d2script.ScriptEngine) *Game {
 	result := &Game{
 		gameClient:           gameClient,
 		gameControls:         nil,
@@ -45,7 +43,7 @@ func CreateGame(renderer d2interface.Renderer, inputManager d2interface.InputMan
 		lastRegionType:       d2enum.RegionNone,
 		ticksSinceLevelCheck: 0,
 		mapRenderer:          d2maprenderer.CreateMapRenderer(renderer, gameClient.MapEngine, term),
-		escapeMenu:           NewEscapeMenu(renderer, inputManager, audioProvider, term, scriptEngine),
+		escapeMenu:           NewEscapeMenu(navigator, renderer, audioProvider),
 		inputManager:         inputManager,
 		audioProvider:        audioProvider,
 		renderer:             renderer,

d2game/d2gamescreen/main_menu.go

@@ -22,15 +22,15 @@ import (
 	"github.com/OpenDiablo2/OpenDiablo2/d2script"
 )
 
-type mainMenuScreenMode int
+type MainMenuScreenMode int
 
 const (
-	screenModeUnknown mainMenuScreenMode = iota
+	ScreenModeUnknown MainMenuScreenMode = iota
-	screenModeTrademark
+	ScreenModeTrademark
-	screenModeMainMenu
+	ScreenModeMainMenu
-	screenModeMultiplayer
+	ScreenModeMultiplayer
-	screenModeTCPIP
+	ScreenModeTCPIP
-	screenModeServerIP
+	ScreenModeServerIP
 )
 
 // MainMenu represents the main menu
@@ -65,26 +65,25 @@ type MainMenu struct {
 	tcpIPOptionsLabel   d2ui.Label
 	tcpJoinGameLabel    d2ui.Label
 	tcpJoinGameEntry    d2ui.TextBox
-	screenMode          mainMenuScreenMode
+	screenMode          MainMenuScreenMode
 	leftButtonHeld      bool
-	inputManager        d2interface.InputManager
+
-	renderer            d2interface.Renderer
+	inputManager  d2interface.InputManager
-	audioProvider       d2interface.AudioProvider
+	renderer      d2interface.Renderer
-	terminal            d2interface.Terminal
+	audioProvider d2interface.AudioProvider
-	scriptEngine        *d2script.ScriptEngine
+	scriptEngine  *d2script.ScriptEngine
+	navigator     Navigator
 }
 
 // CreateMainMenu creates an instance of MainMenu
-func CreateMainMenu(renderer d2interface.Renderer, inputManager d2interface.InputManager, audioProvider d2interface.AudioProvider, term d2interface.Terminal,
+func CreateMainMenu(navigator Navigator, renderer d2interface.Renderer, inputManager d2interface.InputManager, audioProvider d2interface.AudioProvider) *MainMenu {
-	scriptEngine *d2script.ScriptEngine) *MainMenu {
 	return &MainMenu{
-		screenMode:     screenModeUnknown,
+		screenMode:     ScreenModeUnknown,
 		leftButtonHeld: true,
 		renderer:       renderer,
 		inputManager:   inputManager,
 		audioProvider:  audioProvider,
-		terminal:       term,
+		navigator:      navigator,
-		scriptEngine:   scriptEngine,
 	}
 }
 
@@ -104,10 +103,10 @@ func (v *MainMenu) OnLoad(loading d2screen.LoadingState) {
 	d2ui.AddWidget(&v.tcpJoinGameEntry)
 	loading.Progress(0.9)
 
-	if v.screenMode == screenModeUnknown {
+	if v.screenMode == ScreenModeUnknown {
-		v.setScreenMode(screenModeTrademark)
+		v.SetScreenMode(ScreenModeTrademark)
 	} else {
-		v.setScreenMode(screenModeMainMenu)
+		v.SetScreenMode(ScreenModeMainMenu)
 	}
 
 	if err := v.inputManager.BindHandler(v); err != nil {
@@ -280,19 +279,16 @@ func (v *MainMenu) createMultiplayerMenuButtons() {
 }
 
 func (v *MainMenu) onMapTestClicked() {
-	d2screen.SetNextScreen(CreateMapEngineTest(0, 1, v.terminal, v.renderer, v.inputManager))
+	v.navigator.ToMapEngineTest(0, 1)
 }
 
 func (v *MainMenu) onSinglePlayerClicked() {
-	// Go here only if existing characters are available to select
 	if d2player.HasGameStates() {
-		d2screen.SetNextScreen(CreateCharacterSelect(v.renderer, v.inputManager, v.audioProvider, d2clientconnectiontype.Local,
+		// Go here only if existing characters are available to select
-			v.tcpJoinGameEntry.GetText(), v.terminal, v.scriptEngine))
+		v.navigator.ToCharacterSelect(d2clientconnectiontype.Local, v.tcpJoinGameEntry.GetText())
-		return
+	} else {
+		v.navigator.ToSelectHero(d2clientconnectiontype.Local, v.tcpJoinGameEntry.GetText())
 	}
-
-	d2screen.SetNextScreen(CreateSelectHeroClass(v.renderer, v.inputManager, v.audioProvider,
-		d2clientconnectiontype.Local, v.tcpJoinGameEntry.GetText(), v.terminal, v.scriptEngine))
 }
 
 func (v *MainMenu) onGithubButtonClicked() {
@@ -321,7 +317,7 @@ func (v *MainMenu) onExitButtonClicked() {
 }
 
 func (v *MainMenu) onCreditsButtonClicked() {
-	d2screen.SetNextScreen(CreateCredits(v.renderer, v.inputManager, v.audioProvider, v.scriptEngine))
+	v.navigator.ToCredits()
 }
 
 // Render renders the main menu
@@ -343,15 +339,15 @@ func (v *MainMenu) Render(screen d2interface.Surface) error {
 
 func (v *MainMenu) renderBackgrounds(screen d2interface.Surface) error {
 	switch v.screenMode {
-	case screenModeTrademark:
+	case ScreenModeTrademark:
 		if err := v.trademarkBackground.RenderSegmented(screen, 4, 3, 0); err != nil {
 			return err
 		}
-	case screenModeServerIP:
+	case ScreenModeServerIP:
 		if err := v.serverIPBackground.RenderSegmented(screen, 2, 1, 0); err != nil {
 			return err
 		}
-	case screenModeTCPIP:
+	case ScreenModeTCPIP:
 		if err := v.tcpIPBackground.RenderSegmented(screen, 4, 3, 0); err != nil {
 			return err
 		}
@@ -366,7 +362,7 @@ func (v *MainMenu) renderBackgrounds(screen d2interface.Surface) error {
 
 func (v *MainMenu) renderLogos(screen d2interface.Surface) error {
 	switch v.screenMode {
-	case screenModeTrademark, screenModeMainMenu, screenModeMultiplayer:
+	case ScreenModeTrademark, ScreenModeMainMenu, ScreenModeMultiplayer:
 		if err := v.diabloLogoLeftBack.Render(screen); err != nil {
 			return err
 		}
@@ -389,15 +385,15 @@ func (v *MainMenu) renderLogos(screen d2interface.Surface) error {
 
 func (v *MainMenu) renderLabels(screen d2interface.Surface) error {
 	switch v.screenMode {
-	case screenModeServerIP:
+	case ScreenModeServerIP:
 		v.tcpIPOptionsLabel.Render(screen)
 		v.tcpJoinGameLabel.Render(screen)
-	case screenModeTCPIP:
+	case ScreenModeTCPIP:
 		v.tcpIPOptionsLabel.Render(screen)
-	case screenModeTrademark:
+	case ScreenModeTrademark:
 		v.copyrightLabel.Render(screen)
 		v.copyrightLabel2.Render(screen)
-	case screenModeMainMenu:
+	case ScreenModeMainMenu:
 		v.openDiabloLabel.Render(screen)
 		v.versionLabel.Render(screen)
 		v.commitLabel.Render(screen)
@@ -409,7 +405,7 @@ func (v *MainMenu) renderLabels(screen d2interface.Surface) error {
 // Advance runs the update logic on the main menu
 func (v *MainMenu) Advance(tickTime float64) error {
 	switch v.screenMode {
-	case screenModeMainMenu, screenModeTrademark, screenModeMultiplayer:
+	case ScreenModeMainMenu, ScreenModeTrademark, ScreenModeMultiplayer:
 		if err := v.diabloLogoLeftBack.Advance(tickTime); err != nil {
 			return err
 		}
@@ -432,20 +428,20 @@ func (v *MainMenu) Advance(tickTime float64) error {
 
 // OnMouseButtonDown is called when a mouse button is clicked
 func (v *MainMenu) OnMouseButtonDown(event d2interface.MouseEvent) bool {
-	if v.screenMode == screenModeTrademark && event.Button() == d2enum.MouseButtonLeft {
+	if v.screenMode == ScreenModeTrademark && event.Button() == d2enum.MouseButtonLeft {
-		v.setScreenMode(screenModeMainMenu)
+		v.SetScreenMode(ScreenModeMainMenu)
 		return true
 	}
 
 	return false
 }
 
-func (v *MainMenu) setScreenMode(screenMode mainMenuScreenMode) {
+func (v *MainMenu) SetScreenMode(screenMode MainMenuScreenMode) {
 	v.screenMode = screenMode
-	isMainMenu := screenMode == screenModeMainMenu
+	isMainMenu := screenMode == ScreenModeMainMenu
-	isMultiplayer := screenMode == screenModeMultiplayer
+	isMultiplayer := screenMode == ScreenModeMultiplayer
-	isTCPIP := screenMode == screenModeTCPIP
+	isTCPIP := screenMode == ScreenModeTCPIP
-	isServerIP := screenMode == screenModeServerIP
+	isServerIP := screenMode == ScreenModeServerIP
 
 	v.exitDiabloButton.SetVisible(isMainMenu)
 	v.creditsButton.SetVisible(isMainMenu)
@@ -470,35 +466,33 @@ func (v *MainMenu) setScreenMode(screenMode mainMenuScreenMode) {
 }
 
 func (v *MainMenu) onNetworkCancelClicked() {
-	v.setScreenMode(screenModeMainMenu)
+	v.SetScreenMode(ScreenModeMainMenu)
 }
 
 func (v *MainMenu) onMultiplayerClicked() {
-	v.setScreenMode(screenModeMultiplayer)
+	v.SetScreenMode(ScreenModeMultiplayer)
 }
 
 func (v *MainMenu) onNetworkTCPIPClicked() {
-	v.setScreenMode(screenModeTCPIP)
+	v.SetScreenMode(ScreenModeTCPIP)
 }
 
 func (v *MainMenu) onTCPIPCancelClicked() {
-	v.setScreenMode(screenModeMultiplayer)
+	v.SetScreenMode(ScreenModeMultiplayer)
 }
 
 func (v *MainMenu) onTCPIPHostGameClicked() {
-	d2screen.SetNextScreen(CreateCharacterSelect(v.renderer, v.inputManager, v.audioProvider,
+	v.navigator.ToCharacterSelect(d2clientconnectiontype.LANServer, "")
-		d2clientconnectiontype.LANServer, "", v.terminal, v.scriptEngine))
 }
 
 func (v *MainMenu) onTCPIPJoinGameClicked() {
-	v.setScreenMode(screenModeServerIP)
+	v.SetScreenMode(ScreenModeServerIP)
 }
 
 func (v *MainMenu) onBtnTCPIPCancelClicked() {
-	v.setScreenMode(screenModeTCPIP)
+	v.SetScreenMode(ScreenModeTCPIP)
 }
 
 func (v *MainMenu) onBtnTCPIPOkClicked() {
-	d2screen.SetNextScreen(CreateCharacterSelect(v.renderer, v.inputManager, v.audioProvider,
+	v.navigator.ToCharacterSelect(d2clientconnectiontype.LANClient, v.tcpJoinGameEntry.GetText())
-		d2clientconnectiontype.LANClient, v.tcpJoinGameEntry.GetText(), v.terminal, v.scriptEngine))
 }

d2game/d2gamescreen/navigate.go

@@ -0,0 +1,14 @@
+package d2gamescreen
+
+import (
+	"github.com/OpenDiablo2/OpenDiablo2/d2networking/d2client/d2clientconnectiontype"
+)
+
+type Navigator interface {
+	ToMainMenu()
+	ToSelectHero(connType d2clientconnectiontype.ClientConnectionType, connHost string)
+	ToCreateGame(filePath string, connType d2clientconnectiontype.ClientConnectionType, connHost string)
+	ToCharacterSelect(connType d2clientconnectiontype.ClientConnectionType, connHost string)
+	ToMapEngineTest(region int, level int)
+	ToCredits()
+}

d2game/d2gamescreen/select_hero_class.go

@@ -15,9 +15,7 @@ import (
 	"github.com/OpenDiablo2/OpenDiablo2/d2core/d2screen"
 	"github.com/OpenDiablo2/OpenDiablo2/d2core/d2ui"
 	"github.com/OpenDiablo2/OpenDiablo2/d2game/d2player"
-	"github.com/OpenDiablo2/OpenDiablo2/d2networking/d2client"
 	"github.com/OpenDiablo2/OpenDiablo2/d2networking/d2client/d2clientconnectiontype"
-	"github.com/OpenDiablo2/OpenDiablo2/d2script"
 )
 
 type heroRenderConfig struct {
@@ -181,33 +179,22 @@ type SelectHeroClass struct {
 	hardcoreCharLabel  d2ui.Label
 	connectionType     d2clientconnectiontype.ClientConnectionType
 	connectionHost     string
-	inputManager       d2interface.InputManager
+
-	audioProvider      d2interface.AudioProvider
+	audioProvider d2interface.AudioProvider
-	terminal           d2interface.Terminal
+	renderer      d2interface.Renderer
-	renderer           d2interface.Renderer
+	navigator     Navigator
-	scriptEngine       *d2script.ScriptEngine
 }
 
 // CreateSelectHeroClass creates an instance of a SelectHeroClass
-func CreateSelectHeroClass(
+func CreateSelectHeroClass(navigator Navigator, renderer d2interface.Renderer, audioProvider d2interface.AudioProvider, connectionType d2clientconnectiontype.ClientConnectionType, connectionHost string) *SelectHeroClass {
-	renderer d2interface.Renderer,
-	inputManager d2interface.InputManager,
-	audioProvider d2interface.AudioProvider,
-	connectionType d2clientconnectiontype.ClientConnectionType,
-	connectionHost string,
-	terminal d2interface.Terminal,
-	scriptEngine *d2script.ScriptEngine,
-) *SelectHeroClass {
 	result := &SelectHeroClass{
 		heroRenderInfo: make(map[d2enum.Hero]*HeroRenderInfo),
 		selectedHero:   d2enum.HeroNone,
 		connectionType: connectionType,
 		connectionHost: connectionHost,
-		inputManager:   inputManager,
 		audioProvider:  audioProvider,
-		terminal:       terminal,
 		renderer:       renderer,
-		scriptEngine:   scriptEngine,
+		navigator:      navigator,
 	}
 
 	return result
@@ -343,8 +330,7 @@ func (v *SelectHeroClass) OnUnload() error {
 }
 
 func (v *SelectHeroClass) onExitButtonClicked() {
-	d2screen.SetNextScreen(CreateCharacterSelect(v.renderer, v.inputManager, v.audioProvider, v.connectionType,
+	v.navigator.ToCharacterSelect(v.connectionType, v.connectionHost)
-		v.connectionHost, v.terminal, v.scriptEngine))
 }
 
 func (v *SelectHeroClass) onOkButtonClicked() {
@@ -354,13 +340,7 @@ func (v *SelectHeroClass) onOkButtonClicked() {
 		d2datadict.CharStats[v.selectedHero],
 		v.hardcoreCheckbox.GetCheckState(),
 	)
-	gameClient, _ := d2client.Create(d2clientconnectiontype.Local, v.scriptEngine)
+	v.navigator.ToCreateGame(gameState.FilePath, d2clientconnectiontype.Local, v.connectionHost)
-
-	if err := gameClient.Open(v.connectionHost, gameState.FilePath); err != nil {
-		fmt.Printf("can not connect to the host: %s\n", v.connectionHost)
-	}
-
-	d2screen.SetNextScreen(CreateGame(v.renderer, v.inputManager, v.audioProvider, gameClient, v.terminal, v.scriptEngine))
 }
 
 // Render renders the Select Hero Class screen