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

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>
This commit is contained in:
David Carrell 2020-07-14 12:11:23 -05:00 committed by GitHub
parent 06b80cf24f
commit 3bdbd5c358
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
9 changed files with 134 additions and 147 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
d2app/app.go
View File

@ -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))
}

3
d2core/d2screen/d2screen.go
View File

@ -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}

39
d2game/d2gamescreen/character_select.go
View File

@ -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
terminal d2interface.Terminal
scriptEngine *d2script.ScriptEngine
renderer d2interface.Renderer
inputManager d2interface.InputManager
audioProvider d2interface.AudioProvider
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,
scriptEngine: scriptEngine,
navigator: navigator,
}
}
@ -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.terminal, v.scriptEngine))
v.navigator.ToSelectHero(v.connectionType, v.connectionHost)
}
func (v *CharacterSelect) onExitButtonClicked() {
mainMenu := CreateMainMenu(v.renderer, v.inputManager, v.audioProvider, v.terminal, v.scriptEngine)
mainMenu.setScreenMode(screenModeMainMenu)
d2screen.SetNextScreen(mainMenu)
v.navigator.ToMainMenu()
}
// 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)
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))
v.navigator.ToCreateGame(v.gameStates[v.selectedCharacter].FilePath, v.connectionType, v.connectionHost)
}

19
d2game/d2gamescreen/credits.go
View File

@ -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
audioProvider d2interface.AudioProvider
terminal d2interface.Terminal
scriptEngine *d2script.ScriptEngine
renderer d2interface.Renderer
navigator Navigator
}
// 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,
audioProvider: audioProvider,
scriptEngine: scriptEngine,
navigator: navigator,
}
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)
mainMenu.setScreenMode(screenModeMainMenu)
d2screen.SetNextScreen(mainMenu)
v.navigator.ToMainMenu()
}
func (v *Credits) addNextItem() {

18
d2game/d2gamescreen/escape_menu.go
View File

@ -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
scriptEngine *d2script.ScriptEngine
navigator Navigator
}
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,
scriptEngine *d2script.ScriptEngine) *EscapeMenu {
func NewEscapeMenu(navigator Navigator, renderer d2interface.Renderer, audioProvider d2interface.AudioProvider) *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)
mainMenu.setScreenMode(screenModeMainMenu)
d2screen.SetNextScreen(mainMenu)
m.navigator.ToMainMenu()
return
}

6
d2game/d2gamescreen/game.go
View File

@ -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,
term d2interface.Terminal, scriptEngine *d2script.ScriptEngine) *Game {
func CreateGame(navigator Navigator, renderer d2interface.Renderer, inputManager d2interface.InputManager, audioProvider d2interface.AudioProvider, gameClient *d2client.GameClient, term d2interface.Terminal) *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,

106
d2game/d2gamescreen/main_menu.go
View File

@ -22,15 +22,15 @@ import (
"github.com/OpenDiablo2/OpenDiablo2/d2script"
)
type mainMenuScreenMode int
type MainMenuScreenMode int
const (
screenModeUnknown mainMenuScreenMode = iota
screenModeTrademark
screenModeMainMenu
screenModeMultiplayer
screenModeTCPIP
screenModeServerIP
ScreenModeUnknown MainMenuScreenMode = iota
ScreenModeTrademark
ScreenModeMainMenu
ScreenModeMultiplayer
ScreenModeTCPIP
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
audioProvider d2interface.AudioProvider
terminal d2interface.Terminal
scriptEngine *d2script.ScriptEngine
inputManager d2interface.InputManager
renderer d2interface.Renderer
audioProvider d2interface.AudioProvider
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,
scriptEngine *d2script.ScriptEngine) *MainMenu {
func CreateMainMenu(navigator Navigator, renderer d2interface.Renderer, inputManager d2interface.InputManager, audioProvider d2interface.AudioProvider) *MainMenu {
return &MainMenu{
screenMode: screenModeUnknown,
screenMode: ScreenModeUnknown,
leftButtonHeld: true,
renderer: renderer,
inputManager: inputManager,
audioProvider: audioProvider,
terminal: term,
scriptEngine: scriptEngine,
navigator: navigator,
}
}
@ -104,10 +103,10 @@ func (v *MainMenu) OnLoad(loading d2screen.LoadingState) {
d2ui.AddWidget(&v.tcpJoinGameEntry)
loading.Progress(0.9)
if v.screenMode == screenModeUnknown {
v.setScreenMode(screenModeTrademark)
if v.screenMode == ScreenModeUnknown {
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,
v.tcpJoinGameEntry.GetText(), v.terminal, v.scriptEngine))
return
// Go here only if existing characters are available to select
v.navigator.ToCharacterSelect(d2clientconnectiontype.Local, v.tcpJoinGameEntry.GetText())
} 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 {
v.setScreenMode(screenModeMainMenu)
if v.screenMode == ScreenModeTrademark && event.Button() == d2enum.MouseButtonLeft {
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
isMultiplayer := screenMode == screenModeMultiplayer
isTCPIP := screenMode == screenModeTCPIP
isServerIP := screenMode == screenModeServerIP
isMainMenu := screenMode == ScreenModeMainMenu
isMultiplayer := screenMode == ScreenModeMultiplayer
isTCPIP := screenMode == ScreenModeTCPIP
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,
d2clientconnectiontype.LANServer, "", v.terminal, v.scriptEngine))
v.navigator.ToCharacterSelect(d2clientconnectiontype.LANServer, "")
}
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,
d2clientconnectiontype.LANClient, v.tcpJoinGameEntry.GetText(), v.terminal, v.scriptEngine))
v.navigator.ToCharacterSelect(d2clientconnectiontype.LANClient, v.tcpJoinGameEntry.GetText())
}

14
d2game/d2gamescreen/navigate.go Normal file
View File

@ -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()
}

36
d2game/d2gamescreen/select_hero_class.go
View File

@ -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
terminal d2interface.Terminal
renderer d2interface.Renderer
scriptEngine *d2script.ScriptEngine
audioProvider d2interface.AudioProvider
renderer d2interface.Renderer
navigator Navigator
}
// CreateSelectHeroClass creates an instance of a SelectHeroClass
func CreateSelectHeroClass(
renderer d2interface.Renderer,
inputManager d2interface.InputManager,
audioProvider d2interface.AudioProvider,
connectionType d2clientconnectiontype.ClientConnectionType,
connectionHost string,
terminal d2interface.Terminal,
scriptEngine *d2script.ScriptEngine,
) *SelectHeroClass {
func CreateSelectHeroClass(navigator Navigator, renderer d2interface.Renderer, audioProvider d2interface.AudioProvider, connectionType d2clientconnectiontype.ClientConnectionType, connectionHost string) *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.connectionHost, v.terminal, v.scriptEngine))
v.navigator.ToCharacterSelect(v.connectionType, v.connectionHost)
}
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)
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))
v.navigator.ToCreateGame(gameState.FilePath, d2clientconnectiontype.Local, v.connectionHost)
}
// Render renders the Select Hero Class screen