2020-06-30 12:36:48 -04:00
|
|
|
// Package d2app contains the OpenDiablo2 application shell
|
|
|
|
package d2app
|
|
|
|
|
|
|
|
import (
|
|
|
|
"bytes"
|
2020-07-01 00:10:15 -04:00
|
|
|
"container/ring"
|
2020-11-07 23:08:25 -05:00
|
|
|
"encoding/json"
|
2020-06-30 12:36:48 -04:00
|
|
|
"errors"
|
|
|
|
"fmt"
|
|
|
|
"image"
|
|
|
|
"image/gif"
|
|
|
|
"image/png"
|
|
|
|
"log"
|
|
|
|
"os"
|
2020-11-01 19:05:50 -05:00
|
|
|
"os/signal"
|
2020-11-07 23:08:25 -05:00
|
|
|
"path/filepath"
|
2020-06-30 12:36:48 -04:00
|
|
|
"runtime"
|
|
|
|
"runtime/pprof"
|
|
|
|
"strconv"
|
|
|
|
"strings"
|
|
|
|
"sync"
|
2020-11-01 19:05:50 -05:00
|
|
|
"syscall"
|
2020-06-30 12:36:48 -04:00
|
|
|
|
2020-11-07 23:08:25 -05:00
|
|
|
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2data"
|
|
|
|
|
2020-07-23 12:56:50 -04:00
|
|
|
"github.com/pkg/profile"
|
|
|
|
"golang.org/x/image/colornames"
|
|
|
|
"gopkg.in/alecthomas/kingpin.v2"
|
|
|
|
|
2020-06-30 12:36:48 -04:00
|
|
|
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2interface"
|
2020-08-05 22:31:56 -04:00
|
|
|
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2math"
|
2020-06-30 12:36:48 -04:00
|
|
|
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2resource"
|
2020-09-14 14:47:11 -04:00
|
|
|
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2util"
|
2020-06-30 12:36:48 -04:00
|
|
|
"github.com/OpenDiablo2/OpenDiablo2/d2core/d2asset"
|
2020-11-01 19:05:50 -05:00
|
|
|
ebiten2 "github.com/OpenDiablo2/OpenDiablo2/d2core/d2audio/ebiten"
|
2020-06-30 12:36:48 -04:00
|
|
|
"github.com/OpenDiablo2/OpenDiablo2/d2core/d2config"
|
|
|
|
"github.com/OpenDiablo2/OpenDiablo2/d2core/d2gui"
|
2020-11-01 19:05:50 -05:00
|
|
|
"github.com/OpenDiablo2/OpenDiablo2/d2core/d2input"
|
|
|
|
"github.com/OpenDiablo2/OpenDiablo2/d2core/d2render/ebiten"
|
2020-06-30 12:36:48 -04:00
|
|
|
"github.com/OpenDiablo2/OpenDiablo2/d2core/d2screen"
|
2020-11-01 19:05:50 -05:00
|
|
|
"github.com/OpenDiablo2/OpenDiablo2/d2core/d2term"
|
2020-06-30 12:36:48 -04:00
|
|
|
"github.com/OpenDiablo2/OpenDiablo2/d2core/d2ui"
|
|
|
|
"github.com/OpenDiablo2/OpenDiablo2/d2game/d2gamescreen"
|
2020-11-01 19:05:50 -05:00
|
|
|
"github.com/OpenDiablo2/OpenDiablo2/d2networking"
|
2020-07-14 13:11:23 -04:00
|
|
|
"github.com/OpenDiablo2/OpenDiablo2/d2networking/d2client"
|
|
|
|
"github.com/OpenDiablo2/OpenDiablo2/d2networking/d2client/d2clientconnectiontype"
|
2020-06-30 12:36:48 -04:00
|
|
|
"github.com/OpenDiablo2/OpenDiablo2/d2script"
|
|
|
|
)
|
|
|
|
|
2020-08-04 11:16:06 -04:00
|
|
|
// these are used for debug print info
|
|
|
|
const (
|
|
|
|
fpsX, fpsY = 5, 565
|
|
|
|
memInfoX, memInfoY = 670, 5
|
|
|
|
debugLineHeight = 16
|
|
|
|
errMsgPadding = 20
|
|
|
|
)
|
|
|
|
|
2020-06-30 12:36:48 -04:00
|
|
|
// App represents the main application for the engine
|
|
|
|
type App struct {
|
|
|
|
lastTime float64
|
|
|
|
lastScreenAdvance float64
|
|
|
|
showFPS bool
|
|
|
|
timeScale float64
|
|
|
|
captureState captureState
|
|
|
|
capturePath string
|
|
|
|
captureFrames []*image.RGBA
|
|
|
|
gitBranch string
|
|
|
|
gitCommit string
|
2020-09-12 16:51:30 -04:00
|
|
|
asset *d2asset.AssetManager
|
2020-07-13 20:29:17 -04:00
|
|
|
inputManager d2interface.InputManager
|
2020-06-30 12:36:48 -04:00
|
|
|
terminal d2interface.Terminal
|
2020-07-11 11:24:04 -04:00
|
|
|
scriptEngine *d2script.ScriptEngine
|
2020-06-30 12:36:48 -04:00
|
|
|
audio d2interface.AudioProvider
|
2020-07-03 14:00:56 -04:00
|
|
|
renderer d2interface.Renderer
|
2020-08-05 22:31:56 -04:00
|
|
|
screen *d2screen.ScreenManager
|
2020-08-06 10:30:23 -04:00
|
|
|
ui *d2ui.UIManager
|
2020-07-01 00:10:15 -04:00
|
|
|
tAllocSamples *ring.Ring
|
2020-09-18 16:10:52 -04:00
|
|
|
guiManager *d2gui.GuiManager
|
2020-11-03 07:54:15 -05:00
|
|
|
config *d2config.Configuration
|
2020-11-07 23:08:25 -05:00
|
|
|
logger *d2util.Logger
|
2020-11-03 07:54:15 -05:00
|
|
|
errorMessage error
|
2020-11-01 19:05:50 -05:00
|
|
|
*Options
|
|
|
|
}
|
|
|
|
|
|
|
|
// Options is used to store all of the app options that can be set with arguments
|
|
|
|
type Options struct {
|
|
|
|
printVersion *bool
|
|
|
|
Debug *bool
|
|
|
|
profiler *string
|
|
|
|
Server *d2networking.ServerOptions
|
refactored logging in d2loader, d2record, and d2asset (#898)
* refactored logging in d2config, d2record, and d2asset
* asset manager, record manager, and file loader now utilitize d2util.Logger
* added colored logging to d2util.Logger (excluding windows platforms)
* removed mpq file verification from d2config; d2loader handles this
* record loaders now use the record manager's logger for printing info
* added command line argument for setting log level (`--loglevel 4`, `-l4`, or `-l 4`
* added `LogLevel` parameter to config file
* default log level will show errors, warnings, and info log messages
* specifying log level as an argument overrides setting from config file
* fixed log level tests
2020-11-02 21:23:07 -05:00
|
|
|
LogLevel *d2util.LogLevel
|
2020-06-30 12:36:48 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
type bindTerminalEntry struct {
|
|
|
|
name string
|
|
|
|
description string
|
|
|
|
action interface{}
|
|
|
|
}
|
|
|
|
|
2020-07-08 09:16:16 -04:00
|
|
|
const (
|
|
|
|
bytesToMegabyte = 1024 * 1024
|
|
|
|
nSamplesTAlloc = 100
|
|
|
|
debugPopN = 6
|
|
|
|
)
|
2020-06-30 12:36:48 -04:00
|
|
|
|
2020-11-07 23:08:25 -05:00
|
|
|
const (
|
|
|
|
appLoggerPrefix = "App"
|
|
|
|
)
|
|
|
|
|
2020-06-30 12:36:48 -04:00
|
|
|
// Create creates a new instance of the application
|
2020-11-01 19:05:50 -05:00
|
|
|
func Create(gitBranch, gitCommit string) *App {
|
2020-11-03 07:54:15 -05:00
|
|
|
assetManager, assetError := d2asset.NewAssetManager()
|
2020-11-07 23:08:25 -05:00
|
|
|
logger := d2util.NewLogger()
|
|
|
|
logger.SetPrefix(appLoggerPrefix)
|
|
|
|
logger.SetLevel(d2util.LogLevelNone)
|
2020-11-03 07:54:15 -05:00
|
|
|
|
2020-11-01 19:05:50 -05:00
|
|
|
return &App{
|
|
|
|
gitBranch: gitBranch,
|
|
|
|
gitCommit: gitCommit,
|
2020-11-03 07:54:15 -05:00
|
|
|
asset: assetManager,
|
2020-11-01 19:05:50 -05:00
|
|
|
Options: &Options{
|
|
|
|
Server: &d2networking.ServerOptions{},
|
|
|
|
},
|
2020-11-07 23:08:25 -05:00
|
|
|
logger: logger,
|
2020-11-03 07:54:15 -05:00
|
|
|
errorMessage: assetError,
|
2020-11-01 19:05:50 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func updateNOOP() error {
|
|
|
|
return nil
|
|
|
|
}
|
2020-11-01 14:16:15 -05:00
|
|
|
|
2020-11-01 19:05:50 -05:00
|
|
|
func (a *App) startDedicatedServer() error {
|
|
|
|
min, max := d2networking.ServerMinPlayers, d2networking.ServerMaxPlayersDefault
|
|
|
|
maxPlayers := d2math.ClampInt(*a.Options.Server.MaxPlayers, min, max)
|
|
|
|
|
|
|
|
srvChanIn := make(chan int)
|
|
|
|
srvChanLog := make(chan string)
|
|
|
|
|
|
|
|
srvErr := d2networking.StartDedicatedServer(a.asset, srvChanIn, srvChanLog, maxPlayers)
|
|
|
|
if srvErr != nil {
|
|
|
|
return srvErr
|
|
|
|
}
|
|
|
|
|
|
|
|
c := make(chan os.Signal)
|
|
|
|
signal.Notify(c, os.Interrupt, syscall.SIGTERM) // This traps Control-c to safely shut down the server
|
|
|
|
|
|
|
|
go func() {
|
|
|
|
<-c
|
|
|
|
srvChanIn <- d2networking.ServerEventStop
|
|
|
|
}()
|
|
|
|
|
|
|
|
for {
|
|
|
|
for data := range srvChanLog {
|
|
|
|
log.Println(data)
|
|
|
|
}
|
|
|
|
}
|
2020-06-30 12:36:48 -04:00
|
|
|
}
|
|
|
|
|
2020-11-01 19:05:50 -05:00
|
|
|
func (a *App) loadEngine() error {
|
|
|
|
// Create our renderer
|
2020-11-03 07:54:15 -05:00
|
|
|
renderer, err := ebiten.CreateRenderer(a.config)
|
2020-11-01 19:05:50 -05:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
refactored logging in d2loader, d2record, and d2asset (#898)
* refactored logging in d2config, d2record, and d2asset
* asset manager, record manager, and file loader now utilitize d2util.Logger
* added colored logging to d2util.Logger (excluding windows platforms)
* removed mpq file verification from d2config; d2loader handles this
* record loaders now use the record manager's logger for printing info
* added command line argument for setting log level (`--loglevel 4`, `-l4`, or `-l 4`
* added `LogLevel` parameter to config file
* default log level will show errors, warnings, and info log messages
* specifying log level as an argument overrides setting from config file
* fixed log level tests
2020-11-02 21:23:07 -05:00
|
|
|
a.renderer = renderer
|
|
|
|
|
2020-11-03 07:54:15 -05:00
|
|
|
if a.errorMessage != nil {
|
|
|
|
return a.renderer.Run(a.updateInitError, updateNOOP, 800, 600, "OpenDiablo2")
|
2020-11-01 19:05:50 -05:00
|
|
|
}
|
|
|
|
|
refactored logging in d2loader, d2record, and d2asset (#898)
* refactored logging in d2config, d2record, and d2asset
* asset manager, record manager, and file loader now utilitize d2util.Logger
* added colored logging to d2util.Logger (excluding windows platforms)
* removed mpq file verification from d2config; d2loader handles this
* record loaders now use the record manager's logger for printing info
* added command line argument for setting log level (`--loglevel 4`, `-l4`, or `-l 4`
* added `LogLevel` parameter to config file
* default log level will show errors, warnings, and info log messages
* specifying log level as an argument overrides setting from config file
* fixed log level tests
2020-11-02 21:23:07 -05:00
|
|
|
// if the log level was specified at the command line, use it
|
|
|
|
logLevel := *a.Options.LogLevel
|
|
|
|
if logLevel == d2util.LogLevelUnspecified {
|
2020-11-03 07:54:15 -05:00
|
|
|
logLevel = a.config.LogLevel
|
refactored logging in d2loader, d2record, and d2asset (#898)
* refactored logging in d2config, d2record, and d2asset
* asset manager, record manager, and file loader now utilitize d2util.Logger
* added colored logging to d2util.Logger (excluding windows platforms)
* removed mpq file verification from d2config; d2loader handles this
* record loaders now use the record manager's logger for printing info
* added command line argument for setting log level (`--loglevel 4`, `-l4`, or `-l 4`
* added `LogLevel` parameter to config file
* default log level will show errors, warnings, and info log messages
* specifying log level as an argument overrides setting from config file
* fixed log level tests
2020-11-02 21:23:07 -05:00
|
|
|
}
|
|
|
|
|
2020-11-03 07:54:15 -05:00
|
|
|
a.asset.SetLogLevel(logLevel)
|
2020-11-01 19:05:50 -05:00
|
|
|
|
2020-11-03 07:54:15 -05:00
|
|
|
audio := ebiten2.CreateAudio(a.asset)
|
2020-11-01 19:05:50 -05:00
|
|
|
|
|
|
|
inputManager := d2input.NewInputManager()
|
|
|
|
|
|
|
|
term, err := d2term.New(inputManager)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2020-11-03 07:54:15 -05:00
|
|
|
err = a.asset.BindTerminalCommands(term)
|
2020-11-01 19:05:50 -05:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
scriptEngine := d2script.CreateScriptEngine()
|
|
|
|
|
2020-11-03 07:54:15 -05:00
|
|
|
uiManager := d2ui.NewUIManager(a.asset, renderer, inputManager, audio)
|
2020-11-01 19:05:50 -05:00
|
|
|
|
|
|
|
a.inputManager = inputManager
|
|
|
|
a.terminal = term
|
|
|
|
a.scriptEngine = scriptEngine
|
|
|
|
a.audio = audio
|
|
|
|
a.ui = uiManager
|
|
|
|
a.tAllocSamples = createZeroedRing(nSamplesTAlloc)
|
|
|
|
|
|
|
|
if a.gitBranch == "" {
|
|
|
|
a.gitBranch = "Local Build"
|
|
|
|
}
|
|
|
|
|
2020-10-28 14:17:42 -04:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2020-11-01 19:05:50 -05:00
|
|
|
func (a *App) parseArguments() {
|
|
|
|
const (
|
|
|
|
versionArg = "version"
|
|
|
|
versionShort = 'v'
|
|
|
|
versionDesc = "Prints the version of the app"
|
|
|
|
|
|
|
|
profilerArg = "profile"
|
|
|
|
profilerDesc = "Profiles the program, one of (cpu, mem, block, goroutine, trace, thread, mutex)"
|
|
|
|
|
|
|
|
serverArg = "dedicated"
|
|
|
|
serverShort = 'd'
|
|
|
|
serverDesc = "Starts a dedicated server"
|
|
|
|
|
|
|
|
playersArg = "players"
|
|
|
|
playersDesc = "Sets the number of max players for the dedicated server"
|
refactored logging in d2loader, d2record, and d2asset (#898)
* refactored logging in d2config, d2record, and d2asset
* asset manager, record manager, and file loader now utilitize d2util.Logger
* added colored logging to d2util.Logger (excluding windows platforms)
* removed mpq file verification from d2config; d2loader handles this
* record loaders now use the record manager's logger for printing info
* added command line argument for setting log level (`--loglevel 4`, `-l4`, or `-l 4`
* added `LogLevel` parameter to config file
* default log level will show errors, warnings, and info log messages
* specifying log level as an argument overrides setting from config file
* fixed log level tests
2020-11-02 21:23:07 -05:00
|
|
|
|
|
|
|
loggingArg = "loglevel"
|
|
|
|
loggingShort = 'l'
|
|
|
|
loggingDesc = "Enables verbose logging. Log levels will include those below it. " +
|
|
|
|
"0 disables log messages, " +
|
|
|
|
"1 shows errors, " +
|
|
|
|
"2 shows warnings, " +
|
|
|
|
"3 shows info, " +
|
|
|
|
"4 shows debug" +
|
|
|
|
"5 uses value from config file (default)"
|
2020-11-01 19:05:50 -05:00
|
|
|
)
|
|
|
|
|
|
|
|
a.Options.profiler = kingpin.Flag(profilerArg, profilerDesc).String()
|
|
|
|
a.Options.Server.Dedicated = kingpin.Flag(serverArg, serverDesc).Short(serverShort).Bool()
|
|
|
|
a.Options.printVersion = kingpin.Flag(versionArg, versionDesc).Short(versionShort).Bool()
|
|
|
|
a.Options.Server.MaxPlayers = kingpin.Flag(playersArg, playersDesc).Int()
|
refactored logging in d2loader, d2record, and d2asset (#898)
* refactored logging in d2config, d2record, and d2asset
* asset manager, record manager, and file loader now utilitize d2util.Logger
* added colored logging to d2util.Logger (excluding windows platforms)
* removed mpq file verification from d2config; d2loader handles this
* record loaders now use the record manager's logger for printing info
* added command line argument for setting log level (`--loglevel 4`, `-l4`, or `-l 4`
* added `LogLevel` parameter to config file
* default log level will show errors, warnings, and info log messages
* specifying log level as an argument overrides setting from config file
* fixed log level tests
2020-11-02 21:23:07 -05:00
|
|
|
a.Options.LogLevel = kingpin.Flag(loggingArg, loggingDesc).
|
|
|
|
Short(loggingShort).
|
|
|
|
Default(strconv.Itoa(d2util.LogLevelUnspecified)).
|
|
|
|
Int()
|
2020-11-01 19:05:50 -05:00
|
|
|
|
|
|
|
kingpin.Parse()
|
|
|
|
}
|
|
|
|
|
2020-11-07 23:08:25 -05:00
|
|
|
// LoadConfig loads the OpenDiablo2 config file
|
|
|
|
func (a *App) LoadConfig() (*d2config.Configuration, error) {
|
|
|
|
// by now the, the loader has initialized and added our config dirs as sources...
|
|
|
|
configBaseName := filepath.Base(d2config.DefaultConfigPath())
|
|
|
|
|
|
|
|
configAsset, _ := a.asset.LoadAsset(configBaseName)
|
|
|
|
|
|
|
|
config := &d2config.Configuration{}
|
|
|
|
|
|
|
|
// create the default if not found
|
|
|
|
if configAsset == nil {
|
|
|
|
config = d2config.DefaultConfig()
|
|
|
|
|
|
|
|
fullPath := filepath.Join(config.Dir(), config.Base())
|
|
|
|
config.SetPath(fullPath)
|
|
|
|
|
|
|
|
a.logger.Infof("creating default configuration file at %s...", fullPath)
|
|
|
|
|
|
|
|
saveErr := config.Save()
|
|
|
|
|
|
|
|
return config, saveErr
|
|
|
|
}
|
|
|
|
|
|
|
|
if err := json.NewDecoder(configAsset).Decode(config); err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
config.SetPath(filepath.Join(configAsset.Source().Path(), configAsset.Path()))
|
|
|
|
|
|
|
|
a.logger.Infof("loaded configuration file from %s", config.Path())
|
|
|
|
|
|
|
|
return config, nil
|
|
|
|
}
|
|
|
|
|
2020-06-30 12:36:48 -04:00
|
|
|
// Run executes the application and kicks off the entire game process
|
2020-07-23 12:56:50 -04:00
|
|
|
func (a *App) Run() error {
|
2020-11-01 19:05:50 -05:00
|
|
|
a.parseArguments()
|
|
|
|
|
2020-11-08 04:24:35 -05:00
|
|
|
// add our possible config directories
|
|
|
|
_, _ = a.asset.AddSource(filepath.Dir(d2config.LocalConfigPath()))
|
|
|
|
_, _ = a.asset.AddSource(filepath.Dir(d2config.DefaultConfigPath()))
|
|
|
|
|
2020-11-07 23:08:25 -05:00
|
|
|
config, err := a.LoadConfig()
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
a.config = config
|
|
|
|
|
|
|
|
a.asset.SetLogLevel(config.LogLevel)
|
|
|
|
|
2020-11-01 19:05:50 -05:00
|
|
|
// print version and exit if `--version` was supplied
|
|
|
|
if *a.Options.printVersion {
|
|
|
|
fmtVersion := "OpenDiablo2 (%s %s)"
|
|
|
|
|
|
|
|
if a.gitBranch == "" {
|
|
|
|
a.gitBranch = "local"
|
|
|
|
}
|
|
|
|
|
|
|
|
if a.gitCommit == "" {
|
|
|
|
a.gitCommit = "build"
|
|
|
|
}
|
2020-06-30 12:36:48 -04:00
|
|
|
|
2020-11-07 23:08:25 -05:00
|
|
|
fmt.Printf(fmtVersion, a.gitBranch, a.gitCommit)
|
|
|
|
os.Exit(0)
|
2020-11-01 19:05:50 -05:00
|
|
|
}
|
|
|
|
|
2020-11-03 07:54:15 -05:00
|
|
|
logLevel := *a.Options.LogLevel
|
|
|
|
if logLevel == d2util.LogLevelUnspecified {
|
|
|
|
logLevel = a.config.LogLevel
|
|
|
|
}
|
|
|
|
|
|
|
|
a.asset.SetLogLevel(logLevel)
|
|
|
|
|
2020-11-01 19:05:50 -05:00
|
|
|
// start profiler if argument was supplied
|
|
|
|
if len(*a.Options.profiler) > 0 {
|
|
|
|
profiler := enableProfiler(*a.Options.profiler)
|
2020-07-01 19:24:09 -04:00
|
|
|
if profiler != nil {
|
|
|
|
defer profiler.Stop()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-11-01 19:05:50 -05:00
|
|
|
// start the server if `--listen` option was supplied
|
|
|
|
if *a.Options.Server.Dedicated {
|
|
|
|
if err := a.startDedicatedServer(); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if err := a.loadEngine(); err != nil {
|
|
|
|
a.renderer.ShowPanicScreen(err.Error())
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2020-07-23 12:56:50 -04:00
|
|
|
windowTitle := fmt.Sprintf("OpenDiablo2 (%s)", a.gitBranch)
|
2020-11-07 23:08:25 -05:00
|
|
|
|
2020-06-30 12:36:48 -04:00
|
|
|
// If we fail to initialize, we will show the error screen
|
2020-07-23 12:56:50 -04:00
|
|
|
if err := a.initialize(); err != nil {
|
2020-11-03 07:54:15 -05:00
|
|
|
if a.errorMessage == nil {
|
|
|
|
a.errorMessage = err // if there was an error during init, don't clobber it
|
|
|
|
}
|
|
|
|
|
2020-11-07 23:08:25 -05:00
|
|
|
gameErr := a.renderer.Run(a.updateInitError, updateNOOP, 800, 600, windowTitle)
|
|
|
|
if gameErr != nil {
|
2020-07-08 09:16:16 -04:00
|
|
|
return gameErr
|
2020-06-30 12:36:48 -04:00
|
|
|
}
|
|
|
|
|
2020-07-08 09:16:16 -04:00
|
|
|
return err
|
2020-06-30 12:36:48 -04:00
|
|
|
}
|
|
|
|
|
2020-07-23 12:56:50 -04:00
|
|
|
a.ToMainMenu()
|
2020-06-30 12:36:48 -04:00
|
|
|
|
2020-10-28 14:17:42 -04:00
|
|
|
if err := a.renderer.Run(a.update, a.advance, 800, 600, windowTitle); err != nil {
|
2020-07-08 09:16:16 -04:00
|
|
|
return err
|
2020-06-30 12:36:48 -04:00
|
|
|
}
|
2020-07-08 09:16:16 -04:00
|
|
|
|
|
|
|
return nil
|
2020-06-30 12:36:48 -04:00
|
|
|
}
|
|
|
|
|
2020-07-23 12:56:50 -04:00
|
|
|
func (a *App) initialize() error {
|
2020-11-07 23:08:25 -05:00
|
|
|
if err := a.initConfig(a.config); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
if err := a.initDataDictionaries(); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2020-07-23 12:56:50 -04:00
|
|
|
a.timeScale = 1.0
|
2020-09-08 15:58:35 -04:00
|
|
|
a.lastTime = d2util.Now()
|
2020-07-23 12:56:50 -04:00
|
|
|
a.lastScreenAdvance = a.lastTime
|
2020-06-30 12:36:48 -04:00
|
|
|
|
2020-07-23 12:56:50 -04:00
|
|
|
a.renderer.SetWindowIcon("d2logo.png")
|
|
|
|
a.terminal.BindLogger()
|
2020-06-30 12:36:48 -04:00
|
|
|
|
|
|
|
terminalActions := [...]bindTerminalEntry{
|
2020-07-23 12:56:50 -04:00
|
|
|
{"dumpheap", "dumps the heap to pprof/heap.pprof", a.dumpHeap},
|
|
|
|
{"fullscreen", "toggles fullscreen", a.toggleFullScreen},
|
2020-08-04 11:16:06 -04:00
|
|
|
{"capframe", "captures a still frame", a.setupCaptureFrame},
|
2020-07-23 12:56:50 -04:00
|
|
|
{"capgifstart", "captures an animation (start)", a.startAnimationCapture},
|
|
|
|
{"capgifstop", "captures an animation (stop)", a.stopAnimationCapture},
|
|
|
|
{"vsync", "toggles vsync", a.toggleVsync},
|
|
|
|
{"fps", "toggle fps counter", a.toggleFpsCounter},
|
|
|
|
{"timescale", "set scalar for elapsed time", a.setTimeScale},
|
|
|
|
{"quit", "exits the game", a.quitGame},
|
|
|
|
{"screen-gui", "enters the gui playground screen", a.enterGuiPlayground},
|
|
|
|
{"js", "eval JS scripts", a.evalJS},
|
2020-06-30 12:36:48 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
for idx := range terminalActions {
|
|
|
|
action := &terminalActions[idx]
|
|
|
|
|
2020-07-23 12:56:50 -04:00
|
|
|
if err := a.terminal.BindAction(action.name, action.description, action.action); err != nil {
|
2020-06-30 12:36:48 -04:00
|
|
|
log.Fatal(err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-11-07 23:08:25 -05:00
|
|
|
gui, err := d2gui.CreateGuiManager(a.asset, a.inputManager)
|
2020-09-18 16:10:52 -04:00
|
|
|
if err != nil {
|
2020-06-30 12:36:48 -04:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2020-11-07 23:08:25 -05:00
|
|
|
a.guiManager = gui
|
|
|
|
|
2020-09-18 16:10:52 -04:00
|
|
|
a.screen = d2screen.NewScreenManager(a.ui, a.guiManager)
|
|
|
|
|
2020-11-03 07:54:15 -05:00
|
|
|
a.audio.SetVolumes(a.config.BgmVolume, a.config.SfxVolume)
|
2020-06-30 12:36:48 -04:00
|
|
|
|
2020-07-23 12:56:50 -04:00
|
|
|
if err := a.loadStrings(); err != nil {
|
2020-06-30 12:36:48 -04:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2020-08-06 10:30:23 -04:00
|
|
|
a.ui.Initialize()
|
2020-06-30 12:36:48 -04:00
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2020-11-07 23:08:25 -05:00
|
|
|
const (
|
|
|
|
fmtErrSourceNotFound = `file not found: %s
|
|
|
|
|
|
|
|
Please check your config file at %s
|
|
|
|
|
|
|
|
Also, verify that the MPQ files exist at %s
|
|
|
|
|
|
|
|
Capitalization in the file name matters.
|
|
|
|
`
|
|
|
|
)
|
|
|
|
|
|
|
|
func (a *App) initConfig(config *d2config.Configuration) error {
|
|
|
|
a.config = config
|
|
|
|
|
|
|
|
for _, mpqName := range a.config.MpqLoadOrder {
|
|
|
|
cleanDir := filepath.Clean(a.config.MpqPath)
|
|
|
|
srcPath := filepath.Join(cleanDir, mpqName)
|
|
|
|
|
|
|
|
_, err := a.asset.AddSource(srcPath)
|
|
|
|
if err != nil {
|
|
|
|
// nolint:stylecheck // we want a multiline error message here..
|
|
|
|
return fmt.Errorf(fmtErrSourceNotFound, srcPath, a.config.Path(), a.config.MpqPath)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (a *App) initDataDictionaries() error {
|
|
|
|
dictPaths := []string{
|
|
|
|
d2resource.LevelType, d2resource.LevelPreset, d2resource.LevelWarp,
|
|
|
|
d2resource.ObjectType, d2resource.ObjectDetails, d2resource.Weapons,
|
|
|
|
d2resource.Armor, d2resource.Misc, d2resource.Books, d2resource.ItemTypes,
|
|
|
|
d2resource.UniqueItems, d2resource.Missiles, d2resource.SoundSettings,
|
|
|
|
d2resource.MonStats, d2resource.MonStats2, d2resource.MonPreset,
|
|
|
|
d2resource.MonProp, d2resource.MonType, d2resource.MonMode,
|
|
|
|
d2resource.MagicPrefix, d2resource.MagicSuffix, d2resource.ItemStatCost,
|
|
|
|
d2resource.ItemRatio, d2resource.StorePage, d2resource.Overlays,
|
|
|
|
d2resource.CharStats, d2resource.Hireling, d2resource.Experience,
|
|
|
|
d2resource.Gems, d2resource.QualityItems, d2resource.Runes,
|
|
|
|
d2resource.DifficultyLevels, d2resource.AutoMap, d2resource.LevelDetails,
|
|
|
|
d2resource.LevelMaze, d2resource.LevelSubstitutions, d2resource.CubeRecipes,
|
|
|
|
d2resource.SuperUniques, d2resource.Inventory, d2resource.Skills,
|
|
|
|
d2resource.SkillCalc, d2resource.MissileCalc, d2resource.Properties,
|
|
|
|
d2resource.SkillDesc, d2resource.BodyLocations, d2resource.Sets,
|
|
|
|
d2resource.SetItems, d2resource.AutoMagic, d2resource.TreasureClass,
|
|
|
|
d2resource.TreasureClassEx, d2resource.States, d2resource.SoundEnvirons,
|
|
|
|
d2resource.Shrines, d2resource.ElemType, d2resource.PlrMode,
|
|
|
|
d2resource.PetType, d2resource.NPC, d2resource.MonsterUniqueModifier,
|
|
|
|
d2resource.MonsterEquipment, d2resource.UniqueAppellation, d2resource.MonsterLevel,
|
|
|
|
d2resource.MonsterSound, d2resource.MonsterSequence, d2resource.PlayerClass,
|
|
|
|
d2resource.MonsterPlacement, d2resource.ObjectGroup, d2resource.CompCode,
|
|
|
|
d2resource.MonsterAI, d2resource.RarePrefix, d2resource.RareSuffix,
|
|
|
|
d2resource.Events, d2resource.Colors, d2resource.ArmorType,
|
|
|
|
d2resource.WeaponClass, d2resource.PlayerType, d2resource.Composite,
|
|
|
|
d2resource.HitClass, d2resource.UniquePrefix, d2resource.UniqueSuffix,
|
|
|
|
d2resource.CubeModifier, d2resource.CubeType, d2resource.HirelingDescription,
|
|
|
|
d2resource.LowQualityItems,
|
|
|
|
}
|
|
|
|
|
|
|
|
a.logger.Info("Initializing asset manager")
|
|
|
|
|
|
|
|
for _, path := range dictPaths {
|
|
|
|
err := a.asset.LoadRecords(path)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
err := a.initAnimationData(d2resource.AnimationData)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
const (
|
|
|
|
fmtLoadAnimData = "loading animation data from: %s"
|
|
|
|
)
|
|
|
|
|
|
|
|
func (a *App) initAnimationData(path string) error {
|
|
|
|
animDataBytes, err := a.asset.LoadFile(path)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
a.logger.Debug(fmt.Sprintf(fmtLoadAnimData, path))
|
|
|
|
|
|
|
|
animData := d2data.LoadAnimationData(animDataBytes)
|
|
|
|
|
|
|
|
a.logger.Infof("Loaded %d animation data records", len(animData))
|
|
|
|
|
|
|
|
a.asset.Records.Animation.Data = animData
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2020-07-23 12:56:50 -04:00
|
|
|
func (a *App) loadStrings() error {
|
2020-06-30 12:36:48 -04:00
|
|
|
tablePaths := []string{
|
|
|
|
d2resource.PatchStringTable,
|
|
|
|
d2resource.ExpansionStringTable,
|
|
|
|
d2resource.StringTable,
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, tablePath := range tablePaths {
|
2020-11-03 14:10:11 -05:00
|
|
|
_, err := a.asset.LoadStringTable(tablePath)
|
2020-06-30 12:36:48 -04:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2020-10-28 14:17:42 -04:00
|
|
|
func (a *App) renderDebug(target d2interface.Surface) {
|
2020-07-23 12:56:50 -04:00
|
|
|
if !a.showFPS {
|
2020-10-28 14:17:42 -04:00
|
|
|
return
|
2020-06-30 12:36:48 -04:00
|
|
|
}
|
|
|
|
|
2020-07-23 12:56:50 -04:00
|
|
|
vsyncEnabled := a.renderer.GetVSyncEnabled()
|
|
|
|
fps := a.renderer.CurrentFPS()
|
|
|
|
cx, cy := a.renderer.GetCursorPos()
|
2020-06-30 12:36:48 -04:00
|
|
|
|
2020-08-04 11:16:06 -04:00
|
|
|
target.PushTranslation(fpsX, fpsY)
|
2020-07-17 18:51:44 -04:00
|
|
|
target.DrawTextf("vsync:" + strconv.FormatBool(vsyncEnabled) + "\nFPS:" + strconv.Itoa(int(fps)))
|
2020-06-30 12:36:48 -04:00
|
|
|
target.Pop()
|
|
|
|
|
|
|
|
var m runtime.MemStats
|
|
|
|
|
|
|
|
runtime.ReadMemStats(&m)
|
2020-08-04 11:16:06 -04:00
|
|
|
target.PushTranslation(memInfoX, memInfoY)
|
2020-07-17 18:51:44 -04:00
|
|
|
target.DrawTextf("Alloc " + strconv.FormatInt(int64(m.Alloc)/bytesToMegabyte, 10))
|
2020-08-04 11:16:06 -04:00
|
|
|
target.PushTranslation(0, debugLineHeight)
|
2020-07-23 12:56:50 -04:00
|
|
|
target.DrawTextf("TAlloc/s " + strconv.FormatFloat(a.allocRate(m.TotalAlloc, fps), 'f', 2, 64))
|
2020-08-04 11:16:06 -04:00
|
|
|
target.PushTranslation(0, debugLineHeight)
|
2020-07-17 18:51:44 -04:00
|
|
|
target.DrawTextf("Pause " + strconv.FormatInt(int64(m.PauseTotalNs/bytesToMegabyte), 10))
|
2020-08-04 11:16:06 -04:00
|
|
|
target.PushTranslation(0, debugLineHeight)
|
2020-07-17 18:51:44 -04:00
|
|
|
target.DrawTextf("HeapSys " + strconv.FormatInt(int64(m.HeapSys/bytesToMegabyte), 10))
|
2020-08-04 11:16:06 -04:00
|
|
|
target.PushTranslation(0, debugLineHeight)
|
2020-07-17 18:51:44 -04:00
|
|
|
target.DrawTextf("NumGC " + strconv.FormatInt(int64(m.NumGC), 10))
|
2020-08-04 11:16:06 -04:00
|
|
|
target.PushTranslation(0, debugLineHeight)
|
2020-07-17 18:51:44 -04:00
|
|
|
target.DrawTextf("Coords " + strconv.FormatInt(int64(cx), 10) + "," + strconv.FormatInt(int64(cy), 10))
|
2020-07-08 09:16:16 -04:00
|
|
|
target.PopN(debugPopN)
|
2020-06-30 12:36:48 -04:00
|
|
|
}
|
|
|
|
|
2020-07-23 12:56:50 -04:00
|
|
|
func (a *App) renderCapture(target d2interface.Surface) error {
|
2020-06-30 12:36:48 -04:00
|
|
|
cleanupCapture := func() {
|
2020-07-23 12:56:50 -04:00
|
|
|
a.captureState = captureStateNone
|
|
|
|
a.capturePath = ""
|
|
|
|
a.captureFrames = nil
|
2020-06-30 12:36:48 -04:00
|
|
|
}
|
|
|
|
|
2020-07-23 12:56:50 -04:00
|
|
|
switch a.captureState {
|
2020-06-30 12:36:48 -04:00
|
|
|
case captureStateFrame:
|
|
|
|
defer cleanupCapture()
|
|
|
|
|
2020-08-04 11:16:06 -04:00
|
|
|
if err := a.doCaptureFrame(target); err != nil {
|
2020-06-30 12:36:48 -04:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
case captureStateGif:
|
2020-08-04 11:16:06 -04:00
|
|
|
a.doCaptureGif(target)
|
2020-06-30 12:36:48 -04:00
|
|
|
case captureStateNone:
|
2020-07-23 12:56:50 -04:00
|
|
|
if len(a.captureFrames) > 0 {
|
2020-06-30 12:36:48 -04:00
|
|
|
defer cleanupCapture()
|
|
|
|
|
2020-08-04 11:16:06 -04:00
|
|
|
if err := a.convertFramesToGif(); err != nil {
|
2020-06-30 12:36:48 -04:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2020-10-28 14:17:42 -04:00
|
|
|
func (a *App) render(target d2interface.Surface) {
|
|
|
|
a.screen.Render(target)
|
2020-08-06 10:30:23 -04:00
|
|
|
a.ui.Render(target)
|
2020-06-30 12:36:48 -04:00
|
|
|
|
2020-09-18 16:10:52 -04:00
|
|
|
if err := a.guiManager.Render(target); err != nil {
|
2020-10-28 14:17:42 -04:00
|
|
|
return
|
2020-06-30 12:36:48 -04:00
|
|
|
}
|
|
|
|
|
2020-10-28 14:17:42 -04:00
|
|
|
a.renderDebug(target)
|
2020-06-30 12:36:48 -04:00
|
|
|
|
2020-07-23 12:56:50 -04:00
|
|
|
if err := a.renderCapture(target); err != nil {
|
2020-10-28 14:17:42 -04:00
|
|
|
return
|
2020-06-30 12:36:48 -04:00
|
|
|
}
|
|
|
|
|
2020-07-23 12:56:50 -04:00
|
|
|
if err := a.terminal.Render(target); err != nil {
|
2020-10-28 14:17:42 -04:00
|
|
|
return
|
2020-06-30 12:36:48 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-10-28 14:17:42 -04:00
|
|
|
func (a *App) advance() error {
|
|
|
|
current := d2util.Now()
|
|
|
|
elapsedUnscaled := current - a.lastTime
|
|
|
|
elapsed := elapsedUnscaled * a.timeScale
|
2020-06-30 12:36:48 -04:00
|
|
|
|
2020-10-28 14:17:42 -04:00
|
|
|
a.lastTime = current
|
|
|
|
|
|
|
|
elapsedLastScreenAdvance := (current - a.lastScreenAdvance) * a.timeScale
|
2020-07-27 15:00:50 -04:00
|
|
|
a.lastScreenAdvance = current
|
2020-06-30 12:36:48 -04:00
|
|
|
|
2020-08-05 22:31:56 -04:00
|
|
|
if err := a.screen.Advance(elapsedLastScreenAdvance); err != nil {
|
2020-07-27 15:00:50 -04:00
|
|
|
return err
|
2020-06-30 12:36:48 -04:00
|
|
|
}
|
|
|
|
|
2020-08-06 10:30:23 -04:00
|
|
|
a.ui.Advance(elapsed)
|
2020-06-30 12:36:48 -04:00
|
|
|
|
2020-07-23 12:56:50 -04:00
|
|
|
if err := a.inputManager.Advance(elapsed, current); err != nil {
|
2020-06-30 12:36:48 -04:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2020-09-18 16:10:52 -04:00
|
|
|
if err := a.guiManager.Advance(elapsed); err != nil {
|
2020-06-30 12:36:48 -04:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2020-07-30 12:59:17 -04:00
|
|
|
if err := a.terminal.Advance(elapsedUnscaled); err != nil {
|
2020-06-30 12:36:48 -04:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2020-07-23 12:56:50 -04:00
|
|
|
func (a *App) update(target d2interface.Surface) error {
|
2020-10-28 14:17:42 -04:00
|
|
|
a.render(target)
|
2020-06-30 12:36:48 -04:00
|
|
|
|
|
|
|
if target.GetDepth() > 0 {
|
|
|
|
return errors.New("detected surface stack leak")
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2020-07-23 12:56:50 -04:00
|
|
|
func (a *App) allocRate(totalAlloc uint64, fps float64) float64 {
|
|
|
|
a.tAllocSamples.Value = totalAlloc
|
|
|
|
a.tAllocSamples = a.tAllocSamples.Next()
|
|
|
|
deltaAllocPerFrame := float64(totalAlloc-a.tAllocSamples.Value.(uint64)) / nSamplesTAlloc
|
2020-07-01 00:10:15 -04:00
|
|
|
|
|
|
|
return deltaAllocPerFrame * fps / bytesToMegabyte
|
|
|
|
}
|
|
|
|
|
2020-07-23 12:56:50 -04:00
|
|
|
func (a *App) dumpHeap() {
|
2020-09-14 14:49:31 -04:00
|
|
|
if _, err := os.Stat("./pprof/"); os.IsNotExist(err) {
|
|
|
|
if err := os.Mkdir("./pprof/", 0750); err != nil {
|
|
|
|
log.Fatal(err)
|
|
|
|
}
|
2020-06-30 12:36:48 -04:00
|
|
|
}
|
|
|
|
|
2020-09-23 13:30:54 -04:00
|
|
|
fileOut, err := os.Create("./pprof/heap.pprof")
|
|
|
|
if err != nil {
|
|
|
|
log.Print(err)
|
|
|
|
}
|
2020-06-30 12:36:48 -04:00
|
|
|
|
|
|
|
if err := pprof.WriteHeapProfile(fileOut); err != nil {
|
|
|
|
log.Fatal(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
if err := fileOut.Close(); err != nil {
|
|
|
|
log.Fatal(err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-07-23 12:56:50 -04:00
|
|
|
func (a *App) evalJS(code string) {
|
|
|
|
val, err := a.scriptEngine.Eval(code)
|
2020-07-11 11:24:04 -04:00
|
|
|
if err != nil {
|
2020-07-23 12:56:50 -04:00
|
|
|
a.terminal.OutputErrorf("%s", err)
|
2020-07-11 11:24:04 -04:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2020-07-13 20:29:17 -04:00
|
|
|
log.Printf("%s", val)
|
2020-07-11 11:24:04 -04:00
|
|
|
}
|
|
|
|
|
2020-07-23 12:56:50 -04:00
|
|
|
func (a *App) toggleFullScreen() {
|
|
|
|
fullscreen := !a.renderer.IsFullScreen()
|
|
|
|
a.renderer.SetFullScreen(fullscreen)
|
|
|
|
a.terminal.OutputInfof("fullscreen is now: %v", fullscreen)
|
2020-06-30 12:36:48 -04:00
|
|
|
}
|
|
|
|
|
2020-08-04 11:16:06 -04:00
|
|
|
func (a *App) setupCaptureFrame(path string) {
|
2020-07-23 12:56:50 -04:00
|
|
|
a.captureState = captureStateFrame
|
|
|
|
a.capturePath = path
|
|
|
|
a.captureFrames = nil
|
2020-06-30 12:36:48 -04:00
|
|
|
}
|
|
|
|
|
2020-08-04 11:16:06 -04:00
|
|
|
func (a *App) doCaptureFrame(target d2interface.Surface) error {
|
|
|
|
fp, err := os.Create(a.capturePath)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
defer func() {
|
|
|
|
if err := fp.Close(); err != nil {
|
|
|
|
log.Fatal(err)
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
|
|
|
|
screenshot := target.Screenshot()
|
|
|
|
if err := png.Encode(fp, screenshot); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
log.Printf("saved frame to %s", a.capturePath)
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (a *App) doCaptureGif(target d2interface.Surface) {
|
|
|
|
screenshot := target.Screenshot()
|
|
|
|
a.captureFrames = append(a.captureFrames, screenshot)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (a *App) convertFramesToGif() error {
|
|
|
|
fp, err := os.Create(a.capturePath)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
defer func() {
|
|
|
|
if err := fp.Close(); err != nil {
|
|
|
|
log.Fatal(err)
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
|
|
|
|
var (
|
|
|
|
framesTotal = len(a.captureFrames)
|
|
|
|
framesPal = make([]*image.Paletted, framesTotal)
|
|
|
|
frameDelays = make([]int, framesTotal)
|
|
|
|
framesPerCPU = framesTotal / runtime.NumCPU()
|
|
|
|
)
|
|
|
|
|
|
|
|
var waitGroup sync.WaitGroup
|
|
|
|
|
|
|
|
for i := 0; i < framesTotal; i += framesPerCPU {
|
|
|
|
waitGroup.Add(1)
|
|
|
|
|
|
|
|
go func(start, end int) {
|
|
|
|
defer waitGroup.Done()
|
|
|
|
|
|
|
|
for j := start; j < end; j++ {
|
|
|
|
var buffer bytes.Buffer
|
|
|
|
if err := gif.Encode(&buffer, a.captureFrames[j], nil); err != nil {
|
|
|
|
panic(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
framePal, err := gif.Decode(&buffer)
|
|
|
|
if err != nil {
|
|
|
|
panic(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
framesPal[j] = framePal.(*image.Paletted)
|
|
|
|
frameDelays[j] = 5
|
|
|
|
}
|
2020-08-05 00:03:33 -04:00
|
|
|
}(i, d2math.MinInt(i+framesPerCPU, framesTotal))
|
2020-08-04 11:16:06 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
waitGroup.Wait()
|
|
|
|
|
|
|
|
if err := gif.EncodeAll(fp, &gif.GIF{Image: framesPal, Delay: frameDelays}); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
log.Printf("saved animation to %s", a.capturePath)
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2020-07-23 12:56:50 -04:00
|
|
|
func (a *App) startAnimationCapture(path string) {
|
|
|
|
a.captureState = captureStateGif
|
|
|
|
a.capturePath = path
|
|
|
|
a.captureFrames = nil
|
2020-06-30 12:36:48 -04:00
|
|
|
}
|
|
|
|
|
2020-07-23 12:56:50 -04:00
|
|
|
func (a *App) stopAnimationCapture() {
|
|
|
|
a.captureState = captureStateNone
|
2020-06-30 12:36:48 -04:00
|
|
|
}
|
|
|
|
|
2020-07-23 12:56:50 -04:00
|
|
|
func (a *App) toggleVsync() {
|
|
|
|
vsync := !a.renderer.GetVSyncEnabled()
|
|
|
|
a.renderer.SetVSyncEnabled(vsync)
|
|
|
|
a.terminal.OutputInfof("vsync is now: %v", vsync)
|
2020-06-30 12:36:48 -04:00
|
|
|
}
|
|
|
|
|
2020-07-23 12:56:50 -04:00
|
|
|
func (a *App) toggleFpsCounter() {
|
|
|
|
a.showFPS = !a.showFPS
|
|
|
|
a.terminal.OutputInfof("fps counter is now: %v", a.showFPS)
|
2020-06-30 12:36:48 -04:00
|
|
|
}
|
|
|
|
|
2020-07-23 12:56:50 -04:00
|
|
|
func (a *App) setTimeScale(timeScale float64) {
|
2020-06-30 12:36:48 -04:00
|
|
|
if timeScale <= 0 {
|
2020-07-23 12:56:50 -04:00
|
|
|
a.terminal.OutputErrorf("invalid time scale value")
|
2020-06-30 12:36:48 -04:00
|
|
|
} else {
|
2020-07-23 12:56:50 -04:00
|
|
|
a.terminal.OutputInfof("timescale changed from %f to %f", a.timeScale, timeScale)
|
|
|
|
a.timeScale = timeScale
|
2020-06-30 12:36:48 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-07-23 12:56:50 -04:00
|
|
|
func (a *App) quitGame() {
|
2020-06-30 12:36:48 -04:00
|
|
|
os.Exit(0)
|
|
|
|
}
|
|
|
|
|
2020-07-23 12:56:50 -04:00
|
|
|
func (a *App) enterGuiPlayground() {
|
2020-09-18 16:10:52 -04:00
|
|
|
a.screen.SetNextScreen(d2gamescreen.CreateGuiTestMain(a.renderer, a.guiManager, a.asset))
|
2020-06-30 12:36:48 -04:00
|
|
|
}
|
|
|
|
|
2020-07-01 00:10:15 -04:00
|
|
|
func createZeroedRing(n int) *ring.Ring {
|
|
|
|
r := ring.New(n)
|
|
|
|
for i := 0; i < n; i++ {
|
|
|
|
r.Value = uint64(0)
|
|
|
|
r = r.Next()
|
|
|
|
}
|
|
|
|
|
|
|
|
return r
|
|
|
|
}
|
|
|
|
|
2020-06-30 12:36:48 -04:00
|
|
|
func enableProfiler(profileOption string) interface{ Stop() } {
|
|
|
|
var options []func(*profile.Profile)
|
|
|
|
|
|
|
|
switch strings.ToLower(strings.Trim(profileOption, " ")) {
|
|
|
|
case "cpu":
|
|
|
|
log.Printf("CPU profiling is enabled.")
|
|
|
|
|
|
|
|
options = append(options, profile.CPUProfile)
|
|
|
|
case "mem":
|
|
|
|
log.Printf("Memory profiling is enabled.")
|
|
|
|
|
|
|
|
options = append(options, profile.MemProfile)
|
|
|
|
case "block":
|
|
|
|
log.Printf("Block profiling is enabled.")
|
|
|
|
|
|
|
|
options = append(options, profile.BlockProfile)
|
|
|
|
case "goroutine":
|
|
|
|
log.Printf("Goroutine profiling is enabled.")
|
|
|
|
|
|
|
|
options = append(options, profile.GoroutineProfile)
|
|
|
|
case "trace":
|
|
|
|
log.Printf("Trace profiling is enabled.")
|
|
|
|
|
|
|
|
options = append(options, profile.TraceProfile)
|
|
|
|
case "thread":
|
|
|
|
log.Printf("Thread creation profiling is enabled.")
|
|
|
|
|
|
|
|
options = append(options, profile.ThreadcreationProfile)
|
|
|
|
case "mutex":
|
|
|
|
log.Printf("Mutex profiling is enabled.")
|
|
|
|
|
|
|
|
options = append(options, profile.MutexProfile)
|
|
|
|
}
|
|
|
|
|
|
|
|
options = append(options, profile.ProfilePath("./pprof/"))
|
|
|
|
|
|
|
|
if len(options) > 1 {
|
|
|
|
return profile.Start(options...)
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2020-11-03 07:54:15 -05:00
|
|
|
func (a *App) updateInitError(target d2interface.Surface) error {
|
2020-10-28 14:17:42 -04:00
|
|
|
target.Clear(colornames.Darkred)
|
2020-08-04 11:16:06 -04:00
|
|
|
target.PushTranslation(errMsgPadding, errMsgPadding)
|
2020-11-03 07:54:15 -05:00
|
|
|
target.DrawTextf(a.errorMessage.Error())
|
2020-06-30 12:36:48 -04:00
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
2020-07-14 13:11:23 -04:00
|
|
|
|
2020-08-04 11:16:06 -04:00
|
|
|
// ToMainMenu forces the game to transition to the Main Menu
|
2020-11-08 14:03:51 -05:00
|
|
|
func (a *App) ToMainMenu(errorMessageOptional ...string) {
|
2020-08-04 11:16:06 -04:00
|
|
|
buildInfo := d2gamescreen.BuildInfo{Branch: a.gitBranch, Commit: a.gitCommit}
|
2020-09-12 16:51:30 -04:00
|
|
|
|
2020-11-08 14:03:51 -05:00
|
|
|
mainMenu, err := d2gamescreen.CreateMainMenu(a, a.asset, a.renderer, a.inputManager, a.audio, a.ui, buildInfo, errorMessageOptional...)
|
2020-09-20 17:52:01 -04:00
|
|
|
if err != nil {
|
|
|
|
log.Print(err)
|
|
|
|
return
|
|
|
|
}
|
2020-09-12 16:51:30 -04:00
|
|
|
|
2020-08-05 22:31:56 -04:00
|
|
|
a.screen.SetNextScreen(mainMenu)
|
2020-07-14 13:11:23 -04:00
|
|
|
}
|
|
|
|
|
2020-08-04 11:16:06 -04:00
|
|
|
// ToSelectHero forces the game to transition to the Select Hero (create character) screen
|
2020-07-14 13:11:23 -04:00
|
|
|
func (a *App) ToSelectHero(connType d2clientconnectiontype.ClientConnectionType, host string) {
|
2020-09-20 17:52:01 -04:00
|
|
|
selectHero, err := d2gamescreen.CreateSelectHeroClass(a, a.asset, a.renderer, a.audio, a.ui, connType, host)
|
|
|
|
if err != nil {
|
|
|
|
log.Print(err)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2020-08-05 22:31:56 -04:00
|
|
|
a.screen.SetNextScreen(selectHero)
|
2020-07-14 13:11:23 -04:00
|
|
|
}
|
|
|
|
|
2020-08-04 11:16:06 -04:00
|
|
|
// ToCreateGame forces the game to transition to the Create Game screen
|
2020-07-14 13:11:23 -04:00
|
|
|
func (a *App) ToCreateGame(filePath string, connType d2clientconnectiontype.ClientConnectionType, host string) {
|
2020-09-23 13:30:54 -04:00
|
|
|
gameClient, err := d2client.Create(connType, a.asset, a.scriptEngine)
|
|
|
|
if err != nil {
|
|
|
|
log.Print(err)
|
|
|
|
}
|
2020-07-14 13:11:23 -04:00
|
|
|
|
2020-09-23 13:30:54 -04:00
|
|
|
if err = gameClient.Open(host, filePath); err != nil {
|
2020-11-08 14:03:51 -05:00
|
|
|
errorMessage := fmt.Sprintf("can not connect to the host: %s", host)
|
|
|
|
fmt.Println(errorMessage)
|
|
|
|
a.ToMainMenu(errorMessage)
|
|
|
|
} else {
|
|
|
|
a.screen.SetNextScreen(d2gamescreen.CreateGame(
|
|
|
|
a, a.asset, a.ui, a.renderer, a.inputManager, a.audio, gameClient, a.terminal, a.guiManager,
|
|
|
|
))
|
2020-07-14 13:11:23 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-08-04 11:16:06 -04:00
|
|
|
// ToCharacterSelect forces the game to transition to the Character Select (load character) screen
|
2020-07-14 13:11:23 -04:00
|
|
|
func (a *App) ToCharacterSelect(connType d2clientconnectiontype.ClientConnectionType, connHost string) {
|
2020-10-30 20:19:06 -04:00
|
|
|
characterSelect, err := d2gamescreen.CreateCharacterSelect(a, a.asset, a.renderer, a.inputManager,
|
2020-09-12 16:51:30 -04:00
|
|
|
a.audio, a.ui, connType, connHost)
|
2020-10-30 20:19:06 -04:00
|
|
|
if err != nil {
|
|
|
|
fmt.Printf("unable to create character select screen: %s", err)
|
|
|
|
}
|
2020-09-12 16:51:30 -04:00
|
|
|
|
2020-08-05 22:31:56 -04:00
|
|
|
a.screen.SetNextScreen(characterSelect)
|
2020-07-14 13:11:23 -04:00
|
|
|
}
|
|
|
|
|
2020-08-04 11:16:06 -04:00
|
|
|
// ToMapEngineTest forces the game to transition to the map engine test screen
|
|
|
|
func (a *App) ToMapEngineTest(region, level int) {
|
2020-09-20 17:52:01 -04:00
|
|
|
met, err := d2gamescreen.CreateMapEngineTest(region, level, a.asset, a.terminal, a.renderer, a.inputManager, a.audio, a.screen)
|
|
|
|
if err != nil {
|
|
|
|
log.Print(err)
|
2020-10-22 01:12:06 -04:00
|
|
|
return
|
2020-09-20 17:52:01 -04:00
|
|
|
}
|
|
|
|
|
2020-08-05 22:31:56 -04:00
|
|
|
a.screen.SetNextScreen(met)
|
2020-07-14 13:11:23 -04:00
|
|
|
}
|
|
|
|
|
2020-08-04 11:16:06 -04:00
|
|
|
// ToCredits forces the game to transition to the credits screen
|
2020-07-14 13:11:23 -04:00
|
|
|
func (a *App) ToCredits() {
|
2020-09-12 16:51:30 -04:00
|
|
|
a.screen.SetNextScreen(d2gamescreen.CreateCredits(a, a.asset, a.renderer, a.ui))
|
2020-07-14 13:11:23 -04:00
|
|
|
}
|
2020-11-09 12:51:38 -05:00
|
|
|
|
2020-11-10 01:59:17 -05:00
|
|
|
// ToCinematics forces the game to transition to the cinematics menu
|
2020-11-09 12:51:38 -05:00
|
|
|
func (a *App) ToCinematics() {
|
|
|
|
a.screen.SetNextScreen(d2gamescreen.CreateCinematics(a, a.asset, a.renderer, a.ui))
|
|
|
|
}
|