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

More package cleanup. (#130)

This commit is contained in:
Tim Sarbin 2019-11-10 08:51:02 -05:00 committed by GitHub
parent 7370e12b53
commit f2b1bdfba4
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
48 changed files with 335 additions and 301 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
d2audio/SoundEffect.go
View File

@ -5,7 +5,7 @@ import (
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2interface"
"github.com/OpenDiablo2/OpenDiablo2/d2data/datadict"
"github.com/OpenDiablo2/OpenDiablo2/d2data/d2datadict"
"github.com/hajimehoshi/ebiten/audio/wav"
@ -19,8 +19,8 @@ type SoundEffect struct {
func CreateSoundEffect(sfx string, fileProvider d2interface.FileProvider, context *audio.Context, volume float64) *SoundEffect {
result := &SoundEffect{}
var soundFile string
if _, exists := datadict.Sounds[sfx]; exists {
soundEntry := datadict.Sounds[sfx]
if _, exists := d2datadict.Sounds[sfx]; exists {
soundEntry := d2datadict.Sounds[sfx]
soundFile = soundEntry.FileName
} else {
soundFile = sfx

6
d2common/BitMuncher.go
View File

@ -65,7 +65,8 @@ func (v *BitMuncher) MakeSigned(value uint32, bits int) int32 {
if bits == 0 {
return 0
}
if bits == 1 { // If its a single bit, a value of 1 is -1 automagically
// If its a single bit, a value of 1 is -1 automagically
if bits == 1 {
return -int32(value)
}
// If there is no sign bit, return the value as is
@ -79,5 +80,6 @@ func (v *BitMuncher) MakeSigned(value uint32, bits int) int32 {
result -= uint32(1 << uint(i))
}
}
return int32(result) // Force casting to a signed value
// Force casting to a signed value
return int32(result)
}

5
d2common/BuildInfo.go
View File

@ -1,12 +1,17 @@
package d2common
// BuildInfoRecord is the structure used to hold information about the current build
type BuildInfoRecord struct {
// Branch is the branch this build is based on (or 'Local' if built locally)
Branch string
// Commit is the commit hash of the build (or blank if built locally)
Commit string
}
// BuildInfo contains information about the build currently being ran
var BuildInfo BuildInfoRecord
// SetBuildInfo is called at the start of the application to generate the global BuildInfo value
func SetBuildInfo(branch, commit string) {
BuildInfo = BuildInfoRecord{
Branch: branch,

21
d2common/TextDictionary.go
View File

@ -4,6 +4,8 @@ import (
"log"
"strconv"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2resource"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2interface"
)
@ -28,20 +30,25 @@ func TranslateString(key string) string {
func LoadTextDictionary(fileProvider d2interface.FileProvider) {
lookupTable = make(map[string]string)
loadDictionary(fileProvider, PatchStringTable)
loadDictionary(fileProvider, ExpansionStringTable)
loadDictionary(fileProvider, StringTable)
loadDictionary(fileProvider, d2resource.PatchStringTable)
loadDictionary(fileProvider, d2resource.ExpansionStringTable)
loadDictionary(fileProvider, d2resource.StringTable)
log.Printf("Loaded %d entries from the string table", len(lookupTable))
}
func loadDictionary(fileProvider d2interface.FileProvider, dictionaryName string) {
dictionaryData := fileProvider.LoadFile(dictionaryName)
br := CreateStreamReader(dictionaryData)
br.ReadBytes(2) // CRC
// CRC
if _, err := br.ReadBytes(2); err != nil {
log.Fatal("Error reading CRC")
}
numberOfElements := br.GetUInt16()
hashTableSize := br.GetUInt32()
br.ReadByte() // Version (always 0)
// Version (always 0)
if _, err := br.ReadByte(); err != nil {
log.Fatal("Error reading Version record")
}
br.GetUInt32() // StringOffset
br.GetUInt32() // When the number of times you have missed a match with a hash key equals this value, you give up because it is not there.
br.GetUInt32() // FileSize
@ -72,7 +79,7 @@ func loadDictionary(fileProvider d2interface.FileProvider, dictionaryName string
value := string(nameVal)
br.SetPosition(uint64(hashEntry.IndexString))
key := ""
for true {
for {
b := br.GetByte()
if b == 0 {
break

2
d2common/ResourcePaths.go → d2common/d2resource/ResourcePaths.go
View File

@ -1,4 +1,4 @@
package d2common
package d2resource
var LanguageCode string

48
d2core/Engine.go
View File

@ -10,6 +10,8 @@ import (
"sync"
"time"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2resource"
"github.com/OpenDiablo2/OpenDiablo2/d2helper"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2interface"
@ -20,14 +22,14 @@ import (
"github.com/OpenDiablo2/OpenDiablo2/d2data"
"github.com/OpenDiablo2/OpenDiablo2/d2data/datadict"
"github.com/OpenDiablo2/OpenDiablo2/d2data/d2datadict"
"github.com/OpenDiablo2/OpenDiablo2/d2data/mpq"
"github.com/OpenDiablo2/OpenDiablo2/d2data/d2mpq"
"github.com/OpenDiablo2/OpenDiablo2/d2audio"
"github.com/OpenDiablo2/OpenDiablo2/d2common"
"github.com/OpenDiablo2/OpenDiablo2/d2render/ui"
"github.com/OpenDiablo2/OpenDiablo2/d2render/d2ui"
"github.com/hajimehoshi/ebiten"
"github.com/hajimehoshi/ebiten/ebitenutil"
@ -45,7 +47,7 @@ type Engine struct {
thingsToLoad []func() // The load functions for the next scene
stepLoadingSize float64 // The size for each loading step
CurrentScene d2interface.Scene // The current scene being rendered
UIManager *ui.Manager // The UI manager
UIManager *d2ui.Manager // The UI manager
SoundManager *d2audio.Manager // The sound manager
nextScene d2interface.Scene // The next scene to be loaded at the end of the game loop
fullscreenKey bool // When true, the fullscreen toggle is still being pressed
@ -60,26 +62,26 @@ func CreateEngine() *Engine {
nextScene: nil,
}
result.loadConfigurationFile()
d2common.LanguageCode = result.Settings.Language
d2resource.LanguageCode = result.Settings.Language
result.mapMpqFiles()
datadict.LoadPalettes(result.Files, result)
d2datadict.LoadPalettes(result.Files, result)
d2common.LoadTextDictionary(result)
datadict.LoadLevelTypes(result)
datadict.LoadLevelPresets(result)
datadict.LoadLevelWarps(result)
datadict.LoadObjectTypes(result)
datadict.LoadObjects(result)
datadict.LoadWeapons(result)
datadict.LoadArmors(result)
datadict.LoadUniqueItems(result)
datadict.LoadMissiles(result)
datadict.LoadSounds(result)
d2datadict.LoadLevelTypes(result)
d2datadict.LoadLevelPresets(result)
d2datadict.LoadLevelWarps(result)
d2datadict.LoadObjectTypes(result)
d2datadict.LoadObjects(result)
d2datadict.LoadWeapons(result)
d2datadict.LoadArmors(result)
d2datadict.LoadUniqueItems(result)
d2datadict.LoadMissiles(result)
d2datadict.LoadSounds(result)
d2data.LoadAnimationData(result)
datadict.LoadMonStats(result)
d2datadict.LoadMonStats(result)
result.SoundManager = d2audio.CreateManager(result)
result.SoundManager.SetVolumes(result.Settings.BgmVolume, result.Settings.SfxVolume)
result.UIManager = ui.CreateManager(result, *result.SoundManager)
result.LoadingSprite = result.LoadSprite(d2common.LoadingScreen, d2enum.Loading)
result.UIManager = d2ui.CreateManager(result, *result.SoundManager)
result.LoadingSprite = result.LoadSprite(d2resource.LoadingScreen, d2enum.Loading)
loadingSpriteSizeX, loadingSpriteSizeY := result.LoadingSprite.GetSize()
result.LoadingSprite.MoveTo(int(400-(loadingSpriteSizeX/2)), int(300+(loadingSpriteSizeY/2)))
//result.SetNextScene(Scenes.CreateBlizzardIntro(result, result))
@ -98,7 +100,7 @@ func (v *Engine) mapMpqFiles() {
var mutex sync.Mutex
func (v *Engine) LoadFile(fileName string) []byte {
fileName = strings.ReplaceAll(fileName, "{LANG}", d2common.LanguageCode)
fileName = strings.ReplaceAll(fileName, "{LANG}", d2resource.LanguageCode)
fileName = strings.ToLower(fileName)
fileName = strings.ReplaceAll(fileName, `/`, "\\")
if fileName[0] == '\\' {
@ -109,12 +111,12 @@ func (v *Engine) LoadFile(fileName string) []byte {
// TODO: May want to cache some things if performance becomes an issue
cachedMpqFile, cacheExists := v.Files[fileName]
if cacheExists {
archive, _ := mpq.Load(cachedMpqFile)
archive, _ := d2mpq.Load(cachedMpqFile)
result, _ := archive.ReadFile(fileName)
return result
}
for _, mpqFile := range v.Settings.MpqLoadOrder {
archive, _ := mpq.Load(path.Join(v.Settings.MpqPath, mpqFile))
archive, _ := d2mpq.Load(path.Join(v.Settings.MpqPath, mpqFile))
if archive == nil {
log.Fatalf("Failed to load specified MPQ file: %s", mpqFile)
}
@ -140,7 +142,7 @@ func (v *Engine) IsLoading() bool {
// LoadSprite loads a sprite from the game's data files
func (v *Engine) LoadSprite(fileName string, palette d2enum.PaletteType) *d2render.Sprite {
data := v.LoadFile(fileName)
sprite := d2render.CreateSprite(data, datadict.Palettes[palette])
sprite := d2render.CreateSprite(data, d2datadict.Palettes[palette])
return sprite
}

7
d2render/NPC.go → d2core/NPC.go
View File

@ -1,21 +1,22 @@
package d2render
package d2core
import (
"github.com/OpenDiablo2/OpenDiablo2/d2common"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2enum"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2interface"
"github.com/OpenDiablo2/OpenDiablo2/d2data"
"github.com/OpenDiablo2/OpenDiablo2/d2render"
"github.com/hajimehoshi/ebiten"
)
type NPC struct {
AnimatedEntity *AnimatedEntity
AnimatedEntity *d2render.AnimatedEntity
Paths []d2common.Path
}
func CreateNPC(object d2data.Object, fileProvider d2interface.FileProvider) *NPC {
result := &NPC{
AnimatedEntity: CreateAnimatedEntity(object, fileProvider, d2enum.Units),
AnimatedEntity: d2render.CreateAnimatedEntity(object, fileProvider, d2enum.Units),
Paths: object.Paths,
}
result.AnimatedEntity.SetMode(object.Lookup.Mode, object.Lookup.Class, 1, fileProvider)

8
d2core/scenes/BlizzardIntro.go → d2core/d2scene/BlizzardIntro.go
View File

@ -1,15 +1,15 @@
package scenes
package d2scene
import (
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2interface"
"github.com/OpenDiablo2/OpenDiablo2/d2data/video"
"github.com/OpenDiablo2/OpenDiablo2/d2data/d2video"
"github.com/hajimehoshi/ebiten"
)
type BlizzardIntro struct {
fileProvider d2interface.FileProvider
sceneProvider d2interface.SceneProvider
videoDecoder *video.BinkDecoder
videoDecoder *d2video.BinkDecoder
}
func CreateBlizzardIntro(fileProvider d2interface.FileProvider, sceneProvider d2interface.SceneProvider) *BlizzardIntro {
@ -25,7 +25,7 @@ func (v *BlizzardIntro) Load() []func() {
return []func(){
func() {
videoBytes := v.fileProvider.LoadFile("/data/local/video/BlizNorth640x480.bik")
v.videoDecoder = video.CreateBinkDecoder(videoBytes)
v.videoDecoder = d2video.CreateBinkDecoder(videoBytes)
},
}
}

35
d2core/scenes/CharacterSelect.go → d2core/d2scene/CharacterSelect.go
View File

@ -1,34 +1,35 @@
package scenes
package d2scene
import (
"github.com/OpenDiablo2/OpenDiablo2/d2audio"
"github.com/OpenDiablo2/OpenDiablo2/d2common"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2enum"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2interface"
"github.com/OpenDiablo2/OpenDiablo2/d2data/datadict"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2resource"
"github.com/OpenDiablo2/OpenDiablo2/d2data/d2datadict"
dh "github.com/OpenDiablo2/OpenDiablo2/d2helper"
"github.com/OpenDiablo2/OpenDiablo2/d2render"
"github.com/OpenDiablo2/OpenDiablo2/d2render/ui"
"github.com/OpenDiablo2/OpenDiablo2/d2render/d2ui"
"github.com/hajimehoshi/ebiten"
)
type CharacterSelect struct {
uiManager *ui.Manager
uiManager *d2ui.Manager
soundManager *d2audio.Manager
fileProvider d2interface.FileProvider
sceneProvider d2interface.SceneProvider
background *d2render.Sprite
newCharButton *ui.Button
convertCharButton *ui.Button
deleteCharButton *ui.Button
exitButton *ui.Button
okButton *ui.Button
newCharButton *d2ui.Button
convertCharButton *d2ui.Button
deleteCharButton *d2ui.Button
exitButton *d2ui.Button
okButton *d2ui.Button
}
func CreateCharacterSelect(
fileProvider d2interface.FileProvider,
sceneProvider d2interface.SceneProvider,
uiManager *ui.Manager,
uiManager *d2ui.Manager,
soundManager *d2audio.Manager,
) *CharacterSelect {
result := &CharacterSelect{
@ -41,38 +42,38 @@ func CreateCharacterSelect(
}
func (v *CharacterSelect) Load() []func() {
v.soundManager.PlayBGM(d2common.BGMTitle)
v.soundManager.PlayBGM(d2resource.BGMTitle)
return []func(){
func() {
v.background = d2render.CreateSprite(v.fileProvider.LoadFile(d2common.CharacterSelectionBackground), datadict.Palettes[d2enum.Sky])
v.background = d2render.CreateSprite(v.fileProvider.LoadFile(d2resource.CharacterSelectionBackground), d2datadict.Palettes[d2enum.Sky])
v.background.MoveTo(0, 0)
},
func() {
v.newCharButton = ui.CreateButton(ui.ButtonTypeTall, v.fileProvider, dh.CombineStrings(dh.SplitIntoLinesWithMaxWidth(d2common.TranslateString("#831"), 15)))
v.newCharButton = d2ui.CreateButton(d2ui.ButtonTypeTall, v.fileProvider, dh.CombineStrings(dh.SplitIntoLinesWithMaxWidth(d2common.TranslateString("#831"), 15)))
v.newCharButton.MoveTo(33, 468)
v.newCharButton.OnActivated(func() { v.onNewCharButtonClicked() })
v.uiManager.AddWidget(v.newCharButton)
},
func() {
v.convertCharButton = ui.CreateButton(ui.ButtonTypeTall, v.fileProvider, dh.CombineStrings(dh.SplitIntoLinesWithMaxWidth(d2common.TranslateString("#825"), 15)))
v.convertCharButton = d2ui.CreateButton(d2ui.ButtonTypeTall, v.fileProvider, dh.CombineStrings(dh.SplitIntoLinesWithMaxWidth(d2common.TranslateString("#825"), 15)))
v.convertCharButton.MoveTo(233, 468)
v.convertCharButton.SetEnabled(false)
v.uiManager.AddWidget(v.convertCharButton)
},
func() {
v.deleteCharButton = ui.CreateButton(ui.ButtonTypeTall, v.fileProvider, dh.CombineStrings(dh.SplitIntoLinesWithMaxWidth(d2common.TranslateString("#832"), 15)))
v.deleteCharButton = d2ui.CreateButton(d2ui.ButtonTypeTall, v.fileProvider, dh.CombineStrings(dh.SplitIntoLinesWithMaxWidth(d2common.TranslateString("#832"), 15)))
v.deleteCharButton.MoveTo(433, 468)
v.deleteCharButton.SetEnabled(false)
v.uiManager.AddWidget(v.deleteCharButton)
},
func() {
v.exitButton = ui.CreateButton(ui.ButtonTypeMedium, v.fileProvider, d2common.TranslateString("#970"))
v.exitButton = d2ui.CreateButton(d2ui.ButtonTypeMedium, v.fileProvider, d2common.TranslateString("#970"))
v.exitButton.MoveTo(33, 537)
v.exitButton.OnActivated(func() { v.onExitButtonClicked() })
v.uiManager.AddWidget(v.exitButton)
},
func() {
v.okButton = ui.CreateButton(ui.ButtonTypeMedium, v.fileProvider, d2common.TranslateString("#971"))
v.okButton = d2ui.CreateButton(d2ui.ButtonTypeMedium, v.fileProvider, d2common.TranslateString("#971"))
v.okButton.MoveTo(625, 537)
v.okButton.SetEnabled(false)
v.uiManager.AddWidget(v.okButton)

26
d2core/scenes/Credits.go → d2core/d2scene/Credits.go
View File

@ -1,10 +1,12 @@
package scenes
package d2scene
import (
"image/color"
"strings"
"github.com/OpenDiablo2/OpenDiablo2/d2data/datadict"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2resource"
"github.com/OpenDiablo2/OpenDiablo2/d2data/d2datadict"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2enum"
@ -15,24 +17,24 @@ import (
"github.com/OpenDiablo2/OpenDiablo2/d2audio"
"github.com/OpenDiablo2/OpenDiablo2/d2common"
dh "github.com/OpenDiablo2/OpenDiablo2/d2helper"
"github.com/OpenDiablo2/OpenDiablo2/d2render/ui"
"github.com/OpenDiablo2/OpenDiablo2/d2render/d2ui"
"github.com/hajimehoshi/ebiten"
)
type labelItem struct {
Label *ui.Label
Label *d2ui.Label
IsHeading bool
Available bool
}
// Credits represents the credits scene
type Credits struct {
uiManager *ui.Manager
uiManager *d2ui.Manager
soundManager *d2audio.Manager
fileProvider d2interface.FileProvider
sceneProvider d2interface.SceneProvider
creditsBackground *d2render.Sprite
exitButton *ui.Button
exitButton *d2ui.Button
creditsText []string
labels []*labelItem
cycleTime float64
@ -41,7 +43,7 @@ type Credits struct {
}
// CreateCredits creates an instance of the credits scene
func CreateCredits(fileProvider d2interface.FileProvider, sceneProvider d2interface.SceneProvider, uiManager *ui.Manager, soundManager *d2audio.Manager) *Credits {
func CreateCredits(fileProvider d2interface.FileProvider, sceneProvider d2interface.SceneProvider, uiManager *d2ui.Manager, soundManager *d2audio.Manager) *Credits {
result := &Credits{
fileProvider: fileProvider,
uiManager: uiManager,
@ -59,17 +61,17 @@ func CreateCredits(fileProvider d2interface.FileProvider, sceneProvider d2interf
func (v *Credits) Load() []func() {
return []func(){
func() {
v.creditsBackground = d2render.CreateSprite(v.fileProvider.LoadFile(d2common.CreditsBackground), datadict.Palettes[d2enum.Sky])
v.creditsBackground = d2render.CreateSprite(v.fileProvider.LoadFile(d2resource.CreditsBackground), d2datadict.Palettes[d2enum.Sky])
v.creditsBackground.MoveTo(0, 0)
},
func() {
v.exitButton = ui.CreateButton(ui.ButtonTypeMedium, v.fileProvider, d2common.TranslateString("#970"))
v.exitButton = d2ui.CreateButton(d2ui.ButtonTypeMedium, v.fileProvider, d2common.TranslateString("#970"))
v.exitButton.MoveTo(30, 550)
v.exitButton.OnActivated(func() { v.onExitButtonClicked() })
v.uiManager.AddWidget(v.exitButton)
},
func() {
fileData, _ := dh.Utf16BytesToString(v.fileProvider.LoadFile(d2common.CreditsText)[2:])
fileData, _ := dh.Utf16BytesToString(v.fileProvider.LoadFile(d2resource.CreditsText)[2:])
v.creditsText = strings.Split(fileData, "\r\n")
for i := range v.creditsText {
v.creditsText[i] = strings.Trim(v.creditsText[i], " ")
@ -181,7 +183,7 @@ func (v *Credits) addNextItem() {
}
}
func (v *Credits) getNewFontLabel(isHeading bool) *ui.Label {
func (v *Credits) getNewFontLabel(isHeading bool) *d2ui.Label {
for _, label := range v.labels {
if label.Available {
label.Available = false
@ -197,7 +199,7 @@ func (v *Credits) getNewFontLabel(isHeading bool) *ui.Label {
newLabelItem := &labelItem{
Available: false,
IsHeading: isHeading,
Label: ui.CreateLabel(v.fileProvider, d2common.FontFormal10, d2enum.Sky),
Label: d2ui.CreateLabel(v.fileProvider, d2resource.FontFormal10, d2enum.Sky),
}
if isHeading {

82
d2core/scenes/MainMenu.go → d2core/d2scene/MainMenu.go
View File

@ -1,4 +1,4 @@
package scenes
package d2scene
import (
"fmt"
@ -8,7 +8,9 @@ import (
"os/exec"
"runtime"
"github.com/OpenDiablo2/OpenDiablo2/d2data/datadict"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2resource"
"github.com/OpenDiablo2/OpenDiablo2/d2data/d2datadict"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2enum"
@ -18,14 +20,14 @@ import (
"github.com/OpenDiablo2/OpenDiablo2/d2audio"
"github.com/OpenDiablo2/OpenDiablo2/d2common"
"github.com/OpenDiablo2/OpenDiablo2/d2render/ui"
"github.com/OpenDiablo2/OpenDiablo2/d2render/d2ui"
"github.com/hajimehoshi/ebiten"
)
// MainMenu represents the main menu
type MainMenu struct {
uiManager *ui.Manager
uiManager *d2ui.Manager
soundManager *d2audio.Manager
fileProvider d2interface.FileProvider
sceneProvider d2interface.SceneProvider
@ -35,24 +37,24 @@ type MainMenu struct {
diabloLogoRight *d2render.Sprite
diabloLogoLeftBack *d2render.Sprite
diabloLogoRightBack *d2render.Sprite
singlePlayerButton *ui.Button
githubButton *ui.Button
exitDiabloButton *ui.Button
creditsButton *ui.Button
cinematicsButton *ui.Button
mapTestButton *ui.Button
copyrightLabel *ui.Label
copyrightLabel2 *ui.Label
openDiabloLabel *ui.Label
versionLabel *ui.Label
commitLabel *ui.Label
singlePlayerButton *d2ui.Button
githubButton *d2ui.Button
exitDiabloButton *d2ui.Button
creditsButton *d2ui.Button
cinematicsButton *d2ui.Button
mapTestButton *d2ui.Button
copyrightLabel *d2ui.Label
copyrightLabel2 *d2ui.Label
openDiabloLabel *d2ui.Label
versionLabel *d2ui.Label
commitLabel *d2ui.Label
ShowTrademarkScreen bool
leftButtonHeld bool
}
// CreateMainMenu creates an instance of MainMenu
func CreateMainMenu(fileProvider d2interface.FileProvider, sceneProvider d2interface.SceneProvider, uiManager *ui.Manager, soundManager *d2audio.Manager) *MainMenu {
func CreateMainMenu(fileProvider d2interface.FileProvider, sceneProvider d2interface.SceneProvider, uiManager *d2ui.Manager, soundManager *d2audio.Manager) *MainMenu {
result := &MainMenu{
fileProvider: fileProvider,
uiManager: uiManager,
@ -66,107 +68,107 @@ func CreateMainMenu(fileProvider d2interface.FileProvider, sceneProvider d2inter
// Load is called to load the resources for the main menu
func (v *MainMenu) Load() []func() {
v.soundManager.PlayBGM(d2common.BGMTitle)
v.soundManager.PlayBGM(d2resource.BGMTitle)
return []func(){
func() {
v.versionLabel = ui.CreateLabel(v.fileProvider, d2common.FontFormal12, d2enum.Static)
v.versionLabel.Alignment = ui.LabelAlignRight
v.versionLabel = d2ui.CreateLabel(v.fileProvider, d2resource.FontFormal12, d2enum.Static)
v.versionLabel.Alignment = d2ui.LabelAlignRight
v.versionLabel.SetText("OpenDiablo2 - " + d2common.BuildInfo.Branch)
v.versionLabel.Color = color.RGBA{255, 255, 255, 255}
v.versionLabel.MoveTo(795, -10)
},
func() {
v.commitLabel = ui.CreateLabel(v.fileProvider, d2common.FontFormal10, d2enum.Static)
v.commitLabel.Alignment = ui.LabelAlignLeft
v.commitLabel = d2ui.CreateLabel(v.fileProvider, d2resource.FontFormal10, d2enum.Static)
v.commitLabel.Alignment = d2ui.LabelAlignLeft
v.commitLabel.SetText(d2common.BuildInfo.Commit)
v.commitLabel.Color = color.RGBA{255, 255, 255, 255}
v.commitLabel.MoveTo(2, 2)
},
func() {
v.copyrightLabel = ui.CreateLabel(v.fileProvider, d2common.FontFormal12, d2enum.Static)
v.copyrightLabel.Alignment = ui.LabelAlignCenter
v.copyrightLabel = d2ui.CreateLabel(v.fileProvider, d2resource.FontFormal12, d2enum.Static)
v.copyrightLabel.Alignment = d2ui.LabelAlignCenter
v.copyrightLabel.SetText("Diablo 2 is © Copyright 2000-2016 Blizzard Entertainment")
v.copyrightLabel.Color = color.RGBA{188, 168, 140, 255}
v.copyrightLabel.MoveTo(400, 500)
},
func() {
v.copyrightLabel2 = ui.CreateLabel(v.fileProvider, d2common.FontFormal12, d2enum.Static)
v.copyrightLabel2.Alignment = ui.LabelAlignCenter
v.copyrightLabel2 = d2ui.CreateLabel(v.fileProvider, d2resource.FontFormal12, d2enum.Static)
v.copyrightLabel2.Alignment = d2ui.LabelAlignCenter
v.copyrightLabel2.SetText(d2common.TranslateString("#1614"))
v.copyrightLabel2.Color = color.RGBA{188, 168, 140, 255}
v.copyrightLabel2.MoveTo(400, 525)
},
func() {
v.openDiabloLabel = ui.CreateLabel(v.fileProvider, d2common.FontFormal10, d2enum.Static)
v.openDiabloLabel.Alignment = ui.LabelAlignCenter
v.openDiabloLabel = d2ui.CreateLabel(v.fileProvider, d2resource.FontFormal10, d2enum.Static)
v.openDiabloLabel.Alignment = d2ui.LabelAlignCenter
v.openDiabloLabel.SetText("OpenDiablo2 is neither developed by, nor endorsed by Blizzard or its parent company Activision")
v.openDiabloLabel.Color = color.RGBA{255, 255, 140, 255}
v.openDiabloLabel.MoveTo(400, 580)
},
func() {
v.background = d2render.CreateSprite(v.fileProvider.LoadFile(d2common.GameSelectScreen), datadict.Palettes[d2enum.Sky])
v.background = d2render.CreateSprite(v.fileProvider.LoadFile(d2resource.GameSelectScreen), d2datadict.Palettes[d2enum.Sky])
v.background.MoveTo(0, 0)
},
func() {
v.trademarkBackground = d2render.CreateSprite(v.fileProvider.LoadFile(d2common.TrademarkScreen), datadict.Palettes[d2enum.Sky])
v.trademarkBackground = d2render.CreateSprite(v.fileProvider.LoadFile(d2resource.TrademarkScreen), d2datadict.Palettes[d2enum.Sky])
v.trademarkBackground.MoveTo(0, 0)
},
func() {
v.diabloLogoLeft = d2render.CreateSprite(v.fileProvider.LoadFile(d2common.Diablo2LogoFireLeft), datadict.Palettes[d2enum.Units])
v.diabloLogoLeft = d2render.CreateSprite(v.fileProvider.LoadFile(d2resource.Diablo2LogoFireLeft), d2datadict.Palettes[d2enum.Units])
v.diabloLogoLeft.Blend = true
v.diabloLogoLeft.Animate = true
v.diabloLogoLeft.MoveTo(400, 120)
},
func() {
v.diabloLogoRight = d2render.CreateSprite(v.fileProvider.LoadFile(d2common.Diablo2LogoFireRight), datadict.Palettes[d2enum.Units])
v.diabloLogoRight = d2render.CreateSprite(v.fileProvider.LoadFile(d2resource.Diablo2LogoFireRight), d2datadict.Palettes[d2enum.Units])
v.diabloLogoRight.Blend = true
v.diabloLogoRight.Animate = true
v.diabloLogoRight.MoveTo(400, 120)
},
func() {
v.diabloLogoLeftBack = d2render.CreateSprite(v.fileProvider.LoadFile(d2common.Diablo2LogoBlackLeft), datadict.Palettes[d2enum.Units])
v.diabloLogoLeftBack = d2render.CreateSprite(v.fileProvider.LoadFile(d2resource.Diablo2LogoBlackLeft), d2datadict.Palettes[d2enum.Units])
v.diabloLogoLeftBack.MoveTo(400, 120)
},
func() {
v.diabloLogoRightBack = d2render.CreateSprite(v.fileProvider.LoadFile(d2common.Diablo2LogoBlackRight), datadict.Palettes[d2enum.Units])
v.diabloLogoRightBack = d2render.CreateSprite(v.fileProvider.LoadFile(d2resource.Diablo2LogoBlackRight), d2datadict.Palettes[d2enum.Units])
v.diabloLogoRightBack.MoveTo(400, 120)
},
func() {
v.exitDiabloButton = ui.CreateButton(ui.ButtonTypeWide, v.fileProvider, d2common.TranslateString("#1625"))
v.exitDiabloButton = d2ui.CreateButton(d2ui.ButtonTypeWide, v.fileProvider, d2common.TranslateString("#1625"))
v.exitDiabloButton.MoveTo(264, 535)
v.exitDiabloButton.SetVisible(!v.ShowTrademarkScreen)
v.exitDiabloButton.OnActivated(func() { v.onExitButtonClicked() })
v.uiManager.AddWidget(v.exitDiabloButton)
},
func() {
v.creditsButton = ui.CreateButton(ui.ButtonTypeShort, v.fileProvider, d2common.TranslateString("#1627"))
v.creditsButton = d2ui.CreateButton(d2ui.ButtonTypeShort, v.fileProvider, d2common.TranslateString("#1627"))
v.creditsButton.MoveTo(264, 505)
v.creditsButton.SetVisible(!v.ShowTrademarkScreen)
v.creditsButton.OnActivated(func() { v.onCreditsButtonClicked() })
v.uiManager.AddWidget(v.creditsButton)
},
func() {
v.cinematicsButton = ui.CreateButton(ui.ButtonTypeShort, v.fileProvider, d2common.TranslateString("#1639"))
v.cinematicsButton = d2ui.CreateButton(d2ui.ButtonTypeShort, v.fileProvider, d2common.TranslateString("#1639"))
v.cinematicsButton.MoveTo(401, 505)
v.cinematicsButton.SetVisible(!v.ShowTrademarkScreen)
v.uiManager.AddWidget(v.cinematicsButton)
},
func() {
v.singlePlayerButton = ui.CreateButton(ui.ButtonTypeWide, v.fileProvider, d2common.TranslateString("#1620"))
v.singlePlayerButton = d2ui.CreateButton(d2ui.ButtonTypeWide, v.fileProvider, d2common.TranslateString("#1620"))
v.singlePlayerButton.MoveTo(264, 290)
v.singlePlayerButton.SetVisible(!v.ShowTrademarkScreen)
v.singlePlayerButton.OnActivated(func() { v.onSinglePlayerClicked() })
v.uiManager.AddWidget(v.singlePlayerButton)
},
func() {
v.githubButton = ui.CreateButton(ui.ButtonTypeWide, v.fileProvider, "PROJECT WEBSITE")
v.githubButton = d2ui.CreateButton(d2ui.ButtonTypeWide, v.fileProvider, "PROJECT WEBSITE")
v.githubButton.MoveTo(264, 330)
v.githubButton.SetVisible(!v.ShowTrademarkScreen)
v.githubButton.OnActivated(func() { v.onGithubButtonClicked() })
v.uiManager.AddWidget(v.githubButton)
},
func() {
v.mapTestButton = ui.CreateButton(ui.ButtonTypeWide, v.fileProvider, "MAP ENGINE TEST")
v.mapTestButton = d2ui.CreateButton(d2ui.ButtonTypeWide, v.fileProvider, "MAP ENGINE TEST")
v.mapTestButton.MoveTo(264, 450)
v.mapTestButton.SetVisible(!v.ShowTrademarkScreen)
v.mapTestButton.OnActivated(func() { v.onMapTestClicked() })
@ -245,7 +247,7 @@ func (v *MainMenu) Render(screen *ebiten.Image) {
// Update runs the update logic on the main menu
func (v *MainMenu) Update(tickTime float64) {
if v.ShowTrademarkScreen {
if v.uiManager.CursorButtonPressed(ui.CursorButtonLeft) {
if v.uiManager.CursorButtonPressed(d2ui.CursorButtonLeft) {
if v.leftButtonHeld {
return
}

10
d2core/scenes/MapEngineTest.go → d2core/d2scene/MapEngineTest.go
View File

@ -1,4 +1,4 @@
package scenes
package d2scene
import (
"fmt"
@ -11,14 +11,14 @@ import (
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2interface"
"github.com/OpenDiablo2/OpenDiablo2/d2audio"
_map "github.com/OpenDiablo2/OpenDiablo2/d2render/mapengine"
"github.com/OpenDiablo2/OpenDiablo2/d2render/ui"
_map "github.com/OpenDiablo2/OpenDiablo2/d2render/d2mapengine"
"github.com/OpenDiablo2/OpenDiablo2/d2render/d2ui"
"github.com/hajimehoshi/ebiten"
"github.com/hajimehoshi/ebiten/ebitenutil"
)
type MapEngineTest struct {
uiManager *ui.Manager
uiManager *d2ui.Manager
soundManager *d2audio.Manager
fileProvider d2interface.FileProvider
sceneProvider d2interface.SceneProvider
@ -29,7 +29,7 @@ type MapEngineTest struct {
func CreateMapEngineTest(
fileProvider d2interface.FileProvider,
sceneProvider d2interface.SceneProvider,
uiManager *ui.Manager,
uiManager *d2ui.Manager,
soundManager *d2audio.Manager) *MapEngineTest {
result := &MapEngineTest{
fileProvider: fileProvider,

170
d2core/scenes/SelectHeroClass.go → d2core/d2scene/SelectHeroClass.go
View File

@ -1,9 +1,11 @@
package scenes
package d2scene
import (
"image"
"github.com/OpenDiablo2/OpenDiablo2/d2data/datadict"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2resource"
"github.com/OpenDiablo2/OpenDiablo2/d2data/d2datadict"
"github.com/OpenDiablo2/OpenDiablo2/d2render"
@ -13,7 +15,7 @@ import (
"github.com/OpenDiablo2/OpenDiablo2/d2audio"
"github.com/OpenDiablo2/OpenDiablo2/d2common"
dh "github.com/OpenDiablo2/OpenDiablo2/d2helper"
"github.com/OpenDiablo2/OpenDiablo2/d2render/ui"
"github.com/OpenDiablo2/OpenDiablo2/d2render/d2ui"
"github.com/hajimehoshi/ebiten"
)
@ -33,26 +35,26 @@ type HeroRenderInfo struct {
}
type SelectHeroClass struct {
uiManager *ui.Manager
uiManager *d2ui.Manager
soundManager *d2audio.Manager
fileProvider d2interface.FileProvider
sceneProvider d2interface.SceneProvider
bgImage *d2render.Sprite
campfire *d2render.Sprite
headingLabel *ui.Label
heroClassLabel *ui.Label
heroDesc1Label *ui.Label
heroDesc2Label *ui.Label
heroDesc3Label *ui.Label
headingLabel *d2ui.Label
heroClassLabel *d2ui.Label
heroDesc1Label *d2ui.Label
heroDesc2Label *d2ui.Label
heroDesc3Label *d2ui.Label
heroRenderInfo map[d2enum.Hero]*HeroRenderInfo
selectedHero d2enum.Hero
exitButton *ui.Button
exitButton *d2ui.Button
}
func CreateSelectHeroClass(
fileProvider d2interface.FileProvider,
sceneProvider d2interface.SceneProvider,
uiManager *ui.Manager, soundManager *d2audio.Manager,
uiManager *d2ui.Manager, soundManager *d2audio.Manager,
) *SelectHeroClass {
result := &SelectHeroClass{
uiManager: uiManager,
@ -66,51 +68,51 @@ func CreateSelectHeroClass(
}
func (v *SelectHeroClass) loadSprite(path string, palette d2enum.PaletteType) *d2render.Sprite {
return d2render.CreateSprite(v.fileProvider.LoadFile(path), datadict.Palettes[palette])
return d2render.CreateSprite(v.fileProvider.LoadFile(path), d2datadict.Palettes[palette])
}
func (v *SelectHeroClass) Load() []func() {
v.soundManager.PlayBGM(d2common.BGMTitle)
v.soundManager.PlayBGM(d2resource.BGMTitle)
return []func(){
func() {
v.bgImage = v.loadSprite(d2common.CharacterSelectBackground, d2enum.Fechar)
v.bgImage = v.loadSprite(d2resource.CharacterSelectBackground, d2enum.Fechar)
v.bgImage.MoveTo(0, 0)
},
func() {
v.headingLabel = ui.CreateLabel(v.fileProvider, d2common.Font30, d2enum.Units)
v.headingLabel = d2ui.CreateLabel(v.fileProvider, d2resource.Font30, d2enum.Units)
fontWidth, _ := v.headingLabel.GetSize()
v.headingLabel.MoveTo(400-int(fontWidth/2), 17)
v.headingLabel.SetText("Select Hero Class")
v.headingLabel.Alignment = ui.LabelAlignCenter
v.headingLabel.Alignment = d2ui.LabelAlignCenter
},
func() {
v.heroClassLabel = ui.CreateLabel(v.fileProvider, d2common.Font30, d2enum.Units)
v.heroClassLabel.Alignment = ui.LabelAlignCenter
v.heroClassLabel = d2ui.CreateLabel(v.fileProvider, d2resource.Font30, d2enum.Units)
v.heroClassLabel.Alignment = d2ui.LabelAlignCenter
v.heroClassLabel.MoveTo(400, 65)
},
func() {
v.heroDesc1Label = ui.CreateLabel(v.fileProvider, d2common.Font16, d2enum.Units)
v.heroDesc1Label.Alignment = ui.LabelAlignCenter
v.heroDesc1Label = d2ui.CreateLabel(v.fileProvider, d2resource.Font16, d2enum.Units)
v.heroDesc1Label.Alignment = d2ui.LabelAlignCenter
v.heroDesc1Label.MoveTo(400, 100)
},
func() {
v.heroDesc2Label = ui.CreateLabel(v.fileProvider, d2common.Font16, d2enum.Units)
v.heroDesc2Label.Alignment = ui.LabelAlignCenter
v.heroDesc2Label = d2ui.CreateLabel(v.fileProvider, d2resource.Font16, d2enum.Units)
v.heroDesc2Label.Alignment = d2ui.LabelAlignCenter
v.heroDesc2Label.MoveTo(400, 115)
},
func() {
v.heroDesc3Label = ui.CreateLabel(v.fileProvider, d2common.Font16, d2enum.Units)
v.heroDesc3Label.Alignment = ui.LabelAlignCenter
v.heroDesc3Label = d2ui.CreateLabel(v.fileProvider, d2resource.Font16, d2enum.Units)
v.heroDesc3Label.Alignment = d2ui.LabelAlignCenter
v.heroDesc3Label.MoveTo(400, 130)
},
func() {
v.campfire = v.loadSprite(d2common.CharacterSelectCampfire, d2enum.Fechar)
v.campfire = v.loadSprite(d2resource.CharacterSelectCampfire, d2enum.Fechar)
v.campfire.MoveTo(380, 335)
v.campfire.Animate = true
v.campfire.Blend = true
},
func() {
v.exitButton = ui.CreateButton(ui.ButtonTypeMedium, v.fileProvider, d2common.TranslateString("#970"))
v.exitButton = d2ui.CreateButton(d2ui.ButtonTypeMedium, v.fileProvider, d2common.TranslateString("#970"))
v.exitButton.MoveTo(33, 537)
v.exitButton.OnActivated(func() { v.onExitButtonClicked() })
v.uiManager.AddWidget(v.exitButton)
@ -118,17 +120,17 @@ func (v *SelectHeroClass) Load() []func() {
func() {
v.heroRenderInfo[d2enum.HeroBarbarian] = &HeroRenderInfo{
d2enum.HeroStanceIdle,
v.loadSprite(d2common.CharacterSelectBarbarianUnselected, d2enum.Fechar),
v.loadSprite(d2common.CharacterSelectBarbarianUnselectedH, d2enum.Fechar),
v.loadSprite(d2common.CharacterSelectBarbarianForwardWalk, d2enum.Fechar),
v.loadSprite(d2common.CharacterSelectBarbarianForwardWalkOverlay, d2enum.Fechar),
v.loadSprite(d2common.CharacterSelectBarbarianSelected, d2enum.Fechar),
v.loadSprite(d2resource.CharacterSelectBarbarianUnselected, d2enum.Fechar),
v.loadSprite(d2resource.CharacterSelectBarbarianUnselectedH, d2enum.Fechar),
v.loadSprite(d2resource.CharacterSelectBarbarianForwardWalk, d2enum.Fechar),
v.loadSprite(d2resource.CharacterSelectBarbarianForwardWalkOverlay, d2enum.Fechar),
v.loadSprite(d2resource.CharacterSelectBarbarianSelected, d2enum.Fechar),
nil,
v.loadSprite(d2common.CharacterSelectBarbarianBackWalk, d2enum.Fechar),
v.loadSprite(d2resource.CharacterSelectBarbarianBackWalk, d2enum.Fechar),
nil,
image.Rectangle{Min: image.Point{364, 201}, Max: image.Point{90, 170}},
v.soundManager.LoadSoundEffect(d2common.SFXBarbarianSelect),
v.soundManager.LoadSoundEffect(d2common.SFXBarbarianDeselect),
v.soundManager.LoadSoundEffect(d2resource.SFXBarbarianSelect),
v.soundManager.LoadSoundEffect(d2resource.SFXBarbarianDeselect),
}
v.heroRenderInfo[d2enum.HeroBarbarian].IdleSprite.MoveTo(400, 330)
v.heroRenderInfo[d2enum.HeroBarbarian].IdleSprite.Animate = true
@ -152,17 +154,17 @@ func (v *SelectHeroClass) Load() []func() {
func() {
v.heroRenderInfo[d2enum.HeroSorceress] = &HeroRenderInfo{
d2enum.HeroStanceIdle,
v.loadSprite(d2common.CharacterSelecSorceressUnselected, d2enum.Fechar),
v.loadSprite(d2common.CharacterSelecSorceressUnselectedH, d2enum.Fechar),
v.loadSprite(d2common.CharacterSelecSorceressForwardWalk, d2enum.Fechar),
v.loadSprite(d2common.CharacterSelecSorceressForwardWalkOverlay, d2enum.Fechar),
v.loadSprite(d2common.CharacterSelecSorceressSelected, d2enum.Fechar),
v.loadSprite(d2common.CharacterSelecSorceressSelectedOverlay, d2enum.Fechar),
v.loadSprite(d2common.CharacterSelecSorceressBackWalk, d2enum.Fechar),
v.loadSprite(d2common.CharacterSelecSorceressBackWalkOverlay, d2enum.Fechar),
v.loadSprite(d2resource.CharacterSelecSorceressUnselected, d2enum.Fechar),
v.loadSprite(d2resource.CharacterSelecSorceressUnselectedH, d2enum.Fechar),
v.loadSprite(d2resource.CharacterSelecSorceressForwardWalk, d2enum.Fechar),
v.loadSprite(d2resource.CharacterSelecSorceressForwardWalkOverlay, d2enum.Fechar),
v.loadSprite(d2resource.CharacterSelecSorceressSelected, d2enum.Fechar),
v.loadSprite(d2resource.CharacterSelecSorceressSelectedOverlay, d2enum.Fechar),
v.loadSprite(d2resource.CharacterSelecSorceressBackWalk, d2enum.Fechar),
v.loadSprite(d2resource.CharacterSelecSorceressBackWalkOverlay, d2enum.Fechar),
image.Rectangle{Min: image.Point{580, 240}, Max: image.Point{65, 160}},
v.soundManager.LoadSoundEffect(d2common.SFXSorceressSelect),
v.soundManager.LoadSoundEffect(d2common.SFXSorceressDeselect),
v.soundManager.LoadSoundEffect(d2resource.SFXSorceressSelect),
v.soundManager.LoadSoundEffect(d2resource.SFXSorceressDeselect),
}
v.heroRenderInfo[d2enum.HeroSorceress].IdleSprite.MoveTo(626, 352)
v.heroRenderInfo[d2enum.HeroSorceress].IdleSprite.Animate = true
@ -195,17 +197,17 @@ func (v *SelectHeroClass) Load() []func() {
func() {
v.heroRenderInfo[d2enum.HeroNecromancer] = &HeroRenderInfo{
d2enum.HeroStanceIdle,
v.loadSprite(d2common.CharacterSelectNecromancerUnselected, d2enum.Fechar),
v.loadSprite(d2common.CharacterSelectNecromancerUnselectedH, d2enum.Fechar),
v.loadSprite(d2common.CharacterSelecNecromancerForwardWalk, d2enum.Fechar),
v.loadSprite(d2common.CharacterSelecNecromancerForwardWalkOverlay, d2enum.Fechar),
v.loadSprite(d2common.CharacterSelecNecromancerSelected, d2enum.Fechar),
v.loadSprite(d2common.CharacterSelecNecromancerSelectedOverlay, d2enum.Fechar),
v.loadSprite(d2common.CharacterSelecNecromancerBackWalk, d2enum.Fechar),
v.loadSprite(d2common.CharacterSelecNecromancerBackWalkOverlay, d2enum.Fechar),
v.loadSprite(d2resource.CharacterSelectNecromancerUnselected, d2enum.Fechar),
v.loadSprite(d2resource.CharacterSelectNecromancerUnselectedH, d2enum.Fechar),
v.loadSprite(d2resource.CharacterSelecNecromancerForwardWalk, d2enum.Fechar),
v.loadSprite(d2resource.CharacterSelecNecromancerForwardWalkOverlay, d2enum.Fechar),
v.loadSprite(d2resource.CharacterSelecNecromancerSelected, d2enum.Fechar),
v.loadSprite(d2resource.CharacterSelecNecromancerSelectedOverlay, d2enum.Fechar),
v.loadSprite(d2resource.CharacterSelecNecromancerBackWalk, d2enum.Fechar),
v.loadSprite(d2resource.CharacterSelecNecromancerBackWalkOverlay, d2enum.Fechar),
image.Rectangle{Min: image.Point{265, 220}, Max: image.Point{55, 175}},
v.soundManager.LoadSoundEffect(d2common.SFXNecromancerSelect),
v.soundManager.LoadSoundEffect(d2common.SFXNecromancerDeselect),
v.soundManager.LoadSoundEffect(d2resource.SFXNecromancerSelect),
v.soundManager.LoadSoundEffect(d2resource.SFXNecromancerDeselect),
}
v.heroRenderInfo[d2enum.HeroNecromancer].IdleSprite.MoveTo(300, 335)
v.heroRenderInfo[d2enum.HeroNecromancer].IdleSprite.Animate = true
@ -238,17 +240,17 @@ func (v *SelectHeroClass) Load() []func() {
func() {
v.heroRenderInfo[d2enum.HeroPaladin] = &HeroRenderInfo{
d2enum.HeroStanceIdle,
v.loadSprite(d2common.CharacterSelectPaladinUnselected, d2enum.Fechar),
v.loadSprite(d2common.CharacterSelectPaladinUnselectedH, d2enum.Fechar),
v.loadSprite(d2common.CharacterSelecPaladinForwardWalk, d2enum.Fechar),
v.loadSprite(d2common.CharacterSelecPaladinForwardWalkOverlay, d2enum.Fechar),
v.loadSprite(d2common.CharacterSelecPaladinSelected, d2enum.Fechar),
v.loadSprite(d2resource.CharacterSelectPaladinUnselected, d2enum.Fechar),
v.loadSprite(d2resource.CharacterSelectPaladinUnselectedH, d2enum.Fechar),
v.loadSprite(d2resource.CharacterSelecPaladinForwardWalk, d2enum.Fechar),
v.loadSprite(d2resource.CharacterSelecPaladinForwardWalkOverlay, d2enum.Fechar),
v.loadSprite(d2resource.CharacterSelecPaladinSelected, d2enum.Fechar),
nil,
v.loadSprite(d2common.CharacterSelecPaladinBackWalk, d2enum.Fechar),
v.loadSprite(d2resource.CharacterSelecPaladinBackWalk, d2enum.Fechar),
nil,
image.Rectangle{Min: image.Point{490, 210}, Max: image.Point{65, 180}},
v.soundManager.LoadSoundEffect(d2common.SFXPaladinSelect),
v.soundManager.LoadSoundEffect(d2common.SFXPaladinDeselect),
v.soundManager.LoadSoundEffect(d2resource.SFXPaladinSelect),
v.soundManager.LoadSoundEffect(d2resource.SFXPaladinDeselect),
}
v.heroRenderInfo[d2enum.HeroPaladin].IdleSprite.MoveTo(521, 338)
v.heroRenderInfo[d2enum.HeroPaladin].IdleSprite.Animate = true
@ -272,17 +274,17 @@ func (v *SelectHeroClass) Load() []func() {
func() {
v.heroRenderInfo[d2enum.HeroAmazon] = &HeroRenderInfo{
d2enum.HeroStanceIdle,
v.loadSprite(d2common.CharacterSelectAmazonUnselected, d2enum.Fechar),
v.loadSprite(d2common.CharacterSelectAmazonUnselectedH, d2enum.Fechar),
v.loadSprite(d2common.CharacterSelecAmazonForwardWalk, d2enum.Fechar),
v.loadSprite(d2resource.CharacterSelectAmazonUnselected, d2enum.Fechar),
v.loadSprite(d2resource.CharacterSelectAmazonUnselectedH, d2enum.Fechar),
v.loadSprite(d2resource.CharacterSelecAmazonForwardWalk, d2enum.Fechar),
nil,
v.loadSprite(d2common.CharacterSelecAmazonSelected, d2enum.Fechar),
v.loadSprite(d2resource.CharacterSelecAmazonSelected, d2enum.Fechar),
nil,
v.loadSprite(d2common.CharacterSelecAmazonBackWalk, d2enum.Fechar),
v.loadSprite(d2resource.CharacterSelecAmazonBackWalk, d2enum.Fechar),
nil,
image.Rectangle{Min: image.Point{70, 220}, Max: image.Point{55, 200}},
v.soundManager.LoadSoundEffect(d2common.SFXAmazonSelect),
v.soundManager.LoadSoundEffect(d2common.SFXAmazonDeselect),
v.soundManager.LoadSoundEffect(d2resource.SFXAmazonSelect),
v.soundManager.LoadSoundEffect(d2resource.SFXAmazonDeselect),
}
v.heroRenderInfo[d2enum.HeroAmazon].IdleSprite.MoveTo(100, 339)
v.heroRenderInfo[d2enum.HeroAmazon].IdleSprite.Animate = true
@ -302,17 +304,17 @@ func (v *SelectHeroClass) Load() []func() {
func() {
v.heroRenderInfo[d2enum.HeroAssassin] = &HeroRenderInfo{
d2enum.HeroStanceIdle,
v.loadSprite(d2common.CharacterSelectAssassinUnselected, d2enum.Fechar),
v.loadSprite(d2common.CharacterSelectAssassinUnselectedH, d2enum.Fechar),
v.loadSprite(d2common.CharacterSelectAssassinForwardWalk, d2enum.Fechar),
v.loadSprite(d2resource.CharacterSelectAssassinUnselected, d2enum.Fechar),
v.loadSprite(d2resource.CharacterSelectAssassinUnselectedH, d2enum.Fechar),
v.loadSprite(d2resource.CharacterSelectAssassinForwardWalk, d2enum.Fechar),
nil,
v.loadSprite(d2common.CharacterSelectAssassinSelected, d2enum.Fechar),
v.loadSprite(d2resource.CharacterSelectAssassinSelected, d2enum.Fechar),
nil,
v.loadSprite(d2common.CharacterSelectAssassinBackWalk, d2enum.Fechar),
v.loadSprite(d2resource.CharacterSelectAssassinBackWalk, d2enum.Fechar),
nil,
image.Rectangle{Min: image.Point{175, 235}, Max: image.Point{50, 180}},
v.soundManager.LoadSoundEffect(d2common.SFXAssassinSelect),
v.soundManager.LoadSoundEffect(d2common.SFXAssassinDeselect),
v.soundManager.LoadSoundEffect(d2resource.SFXAssassinSelect),
v.soundManager.LoadSoundEffect(d2resource.SFXAssassinDeselect),
}
v.heroRenderInfo[d2enum.HeroAssassin].IdleSprite.MoveTo(231, 365)
v.heroRenderInfo[d2enum.HeroAssassin].IdleSprite.Animate = true
@ -332,17 +334,17 @@ func (v *SelectHeroClass) Load() []func() {
func() {
v.heroRenderInfo[d2enum.HeroDruid] = &HeroRenderInfo{
d2enum.HeroStanceIdle,
v.loadSprite(d2common.CharacterSelectDruidUnselected, d2enum.Fechar),
v.loadSprite(d2common.CharacterSelectDruidUnselectedH, d2enum.Fechar),
v.loadSprite(d2common.CharacterSelectDruidForwardWalk, d2enum.Fechar),
v.loadSprite(d2resource.CharacterSelectDruidUnselected, d2enum.Fechar),
v.loadSprite(d2resource.CharacterSelectDruidUnselectedH, d2enum.Fechar),
v.loadSprite(d2resource.CharacterSelectDruidForwardWalk, d2enum.Fechar),
nil,
v.loadSprite(d2common.CharacterSelectDruidSelected, d2enum.Fechar),
v.loadSprite(d2resource.CharacterSelectDruidSelected, d2enum.Fechar),
nil,
v.loadSprite(d2common.CharacterSelectDruidBackWalk, d2enum.Fechar),
v.loadSprite(d2resource.CharacterSelectDruidBackWalk, d2enum.Fechar),
nil,
image.Rectangle{Min: image.Point{680, 220}, Max: image.Point{70, 195}},
v.soundManager.LoadSoundEffect(d2common.SFXDruidSelect),
v.soundManager.LoadSoundEffect(d2common.SFXDruidDeselect),
v.soundManager.LoadSoundEffect(d2resource.SFXDruidSelect),
v.soundManager.LoadSoundEffect(d2resource.SFXDruidDeselect),
}
v.heroRenderInfo[d2enum.HeroDruid].IdleSprite.MoveTo(720, 370)
v.heroRenderInfo[d2enum.HeroDruid].IdleSprite.Animate = true
@ -441,7 +443,7 @@ func (v *SelectHeroClass) updateHeroSelectionHover(hero d2enum.Hero, canSelect b
mouseY := v.uiManager.CursorY
b := renderInfo.SelectionBounds
mouseHover := (mouseX >= b.Min.X) && (mouseX <= b.Min.X+b.Max.X) && (mouseY >= b.Min.Y) && (mouseY <= b.Min.Y+b.Max.Y)
if mouseHover && v.uiManager.CursorButtonPressed(ui.CursorButtonLeft) {
if mouseHover && v.uiManager.CursorButtonPressed(d2ui.CursorButtonLeft) {
// showEntryUi = true;
renderInfo.Stance = d2enum.HeroStanceApproaching
renderInfo.ForwardWalkSprite.ResetAnimation()

4
d2data/AnimationData.go
View File

@ -4,6 +4,8 @@ import (
"log"
"strings"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2resource"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2interface"
"github.com/OpenDiablo2/OpenDiablo2/d2common"
@ -27,7 +29,7 @@ var AnimationData map[string][]*AnimationDataRecord
// LoadAnimationData loads the animation data table into the global AnimationData dictionary
func LoadAnimationData(fileProvider d2interface.FileProvider) {
AnimationData = make(map[string][]*AnimationDataRecord)
rawData := fileProvider.LoadFile(d2common.AnimationData)
rawData := fileProvider.LoadFile(d2resource.AnimationData)
streamReader := d2common.CreateStreamReader(rawData)
for !streamReader.Eof() {
dataCount := int(streamReader.GetInt32())

6
d2data/DS1.go
View File

@ -3,7 +3,7 @@ package d2data
import (
"github.com/OpenDiablo2/OpenDiablo2/d2common"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2interface"
"github.com/OpenDiablo2/OpenDiablo2/d2data/datadict"
"github.com/OpenDiablo2/OpenDiablo2/d2data/d2datadict"
"github.com/OpenDiablo2/OpenDiablo2/d2helper"
)
@ -237,9 +237,9 @@ func LoadDS1(path string, fileProvider d2interface.FileProvider) *DS1 {
newObject.X = br.GetInt32()
newObject.Y = br.GetInt32()
newObject.Flags = br.GetInt32()
newObject.Lookup = datadict.LookupObject(int(ds1.Act), int(newObject.Type), int(newObject.Id))
newObject.Lookup = d2datadict.LookupObject(int(ds1.Act), int(newObject.Type), int(newObject.Id))
if newObject.Lookup != nil && newObject.Lookup.ObjectsTxtId != -1 {
newObject.ObjectInfo = datadict.Objects[newObject.Lookup.ObjectsTxtId]
newObject.ObjectInfo = d2datadict.Objects[newObject.Lookup.ObjectsTxtId]
}
ds1.Objects = append(ds1.Objects, newObject)
}

6
d2data/Object.go
View File

@ -2,7 +2,7 @@ package d2data
import (
"github.com/OpenDiablo2/OpenDiablo2/d2common"
"github.com/OpenDiablo2/OpenDiablo2/d2data/datadict"
"github.com/OpenDiablo2/OpenDiablo2/d2data/d2datadict"
)
type Object struct {
@ -12,6 +12,6 @@ type Object struct {
Y int32
Flags int32
Paths []d2common.Path
Lookup *datadict.ObjectLookupRecord
ObjectInfo *datadict.ObjectRecord
Lookup *d2datadict.ObjectLookupRecord
ObjectInfo *d2datadict.ObjectRecord
}

2
d2data/compression/Huffman.go → d2data/d2compression/Huffman.go
View File

@ -27,7 +27,7 @@
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
package compression
package d2compression
import (
"log"

2
d2data/compression/Wav.go → d2data/d2compression/Wav.go
View File

@ -1,4 +1,4 @@
package compression
package d2compression
import (
"github.com/OpenDiablo2/OpenDiablo2/d2common"

6
d2data/datadict/Armor.go → d2data/d2datadict/Armor.go
View File

@ -1,10 +1,10 @@
package datadict
package d2datadict
import (
"log"
"strings"
"github.com/OpenDiablo2/OpenDiablo2/d2common"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2resource"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2interface"
@ -270,7 +270,7 @@ var Armors map[string]*ArmorRecord
func LoadArmors(fileProvider d2interface.FileProvider) {
Armors = make(map[string]*ArmorRecord)
data := strings.Split(string(fileProvider.LoadFile(d2common.Armor)), "\r\n")[1:]
data := strings.Split(string(fileProvider.LoadFile(d2resource.Armor)), "\r\n")[1:]
for _, line := range data {
if len(line) == 0 {
continue

6
d2data/datadict/LevelPresets.go → d2data/d2datadict/LevelPresets.go
View File

@ -1,10 +1,10 @@
package datadict
package d2datadict
import (
"log"
"strings"
"github.com/OpenDiablo2/OpenDiablo2/d2common"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2resource"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2interface"
@ -77,7 +77,7 @@ var LevelPresets map[int]*LevelPresetRecord
func LoadLevelPresets(fileProvider d2interface.FileProvider) {
LevelPresets = make(map[int]*LevelPresetRecord)
data := strings.Split(string(fileProvider.LoadFile(d2common.LevelPreset)), "\r\n")[1:]
data := strings.Split(string(fileProvider.LoadFile(d2resource.LevelPreset)), "\r\n")[1:]
for _, line := range data {
if len(line) == 0 {
continue

6
d2data/datadict/LevelTypes.go → d2data/d2datadict/LevelTypes.go
View File

@ -1,10 +1,10 @@
package datadict
package d2datadict
import (
"log"
"strings"
"github.com/OpenDiablo2/OpenDiablo2/d2common"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2resource"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2interface"
@ -23,7 +23,7 @@ type LevelTypeRecord struct {
var LevelTypes []LevelTypeRecord
func LoadLevelTypes(fileProvider d2interface.FileProvider) {
data := strings.Split(string(fileProvider.LoadFile(d2common.LevelType)), "\r\n")[1:]
data := strings.Split(string(fileProvider.LoadFile(d2resource.LevelType)), "\r\n")[1:]
LevelTypes = make([]LevelTypeRecord, len(data))
for i, line := range data {
idx := -1

6
d2data/datadict/LevelWarp.go → d2data/d2datadict/LevelWarp.go
View File

@ -1,8 +1,10 @@
package datadict
package d2datadict
import (
"log"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2resource"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2interface"
"github.com/OpenDiablo2/OpenDiablo2/d2common"
@ -27,7 +29,7 @@ var LevelWarps map[int]*LevelWarpRecord
func LoadLevelWarps(fileProvider d2interface.FileProvider) {
LevelWarps = make(map[int]*LevelWarpRecord)
levelWarpData := fileProvider.LoadFile(d2common.LevelWarp)
levelWarpData := fileProvider.LoadFile(d2resource.LevelWarp)
streamReader := d2common.CreateStreamReader(levelWarpData)
numRecords := int(streamReader.GetInt32())
for i := 0; i < numRecords; i++ {

6
d2data/datadict/Missiles.go → d2data/d2datadict/Missiles.go
View File

@ -1,10 +1,10 @@
package datadict
package d2datadict
import (
"log"
"strings"
"github.com/OpenDiablo2/OpenDiablo2/d2common"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2resource"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2interface"
@ -297,7 +297,7 @@ var Missiles map[int]*MissileRecord
func LoadMissiles(fileProvider d2interface.FileProvider) {
Missiles = make(map[int]*MissileRecord)
data := strings.Split(string(fileProvider.LoadFile(d2common.Missiles)), "\r\n")[1:]
data := strings.Split(string(fileProvider.LoadFile(d2resource.Missiles)), "\r\n")[1:]
for _, line := range data {
if len(line) == 0 {
continue

5
d2data/datadict/MonStats.go → d2data/d2datadict/MonStats.go
View File

@ -1,12 +1,13 @@
package datadict
package d2datadict
import (
"github.com/OpenDiablo2/OpenDiablo2/d2common"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2interface"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2resource"
)
var MonStatsDictionary *d2common.DataDictionary
func LoadMonStats(fileProvider d2interface.FileProvider) {
MonStatsDictionary = d2common.LoadDataDictionary(string(fileProvider.LoadFile(d2common.MonStats)))
MonStatsDictionary = d2common.LoadDataDictionary(string(fileProvider.LoadFile(d2resource.MonStats)))
}

2
d2data/datadict/ObjectLookup.go → d2data/d2datadict/ObjectLookup.go
View File

@ -1,4 +1,4 @@
package datadict
package d2datadict
import (
"log"

6
d2data/datadict/ObjectTypes.go → d2data/d2datadict/ObjectTypes.go
View File

@ -1,9 +1,11 @@
package datadict
package d2datadict
import (
"log"
"strings"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2resource"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2interface"
"github.com/OpenDiablo2/OpenDiablo2/d2common"
@ -17,7 +19,7 @@ type ObjectTypeRecord struct {
var ObjectTypes []ObjectTypeRecord
func LoadObjectTypes(fileProvider d2interface.FileProvider) {
objectTypeData := fileProvider.LoadFile(d2common.ObjectType)
objectTypeData := fileProvider.LoadFile(d2resource.ObjectType)
streamReader := d2common.CreateStreamReader(objectTypeData)
count := streamReader.GetInt32()
ObjectTypes = make([]ObjectTypeRecord, count)

6
d2data/datadict/Objects.go → d2data/d2datadict/Objects.go
View File

@ -1,10 +1,10 @@
package datadict
package d2datadict
import (
"log"
"strings"
"github.com/OpenDiablo2/OpenDiablo2/d2common"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2resource"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2interface"
@ -341,7 +341,7 @@ var Objects map[int]*ObjectRecord
func LoadObjects(fileProvider d2interface.FileProvider) {
Objects = make(map[int]*ObjectRecord)
data := strings.Split(string(fileProvider.LoadFile(d2common.ObjectDetails)), "\r\n")[1:]
data := strings.Split(string(fileProvider.LoadFile(d2resource.ObjectDetails)), "\r\n")[1:]
for _, line := range data {
if len(line) == 0 {
continue

2
d2data/datadict/Palette.go → d2data/d2datadict/Palette.go
View File

@ -1,4 +1,4 @@
package datadict
package d2datadict
import (
"log"

6
d2data/datadict/Sounds.go → d2data/d2datadict/Sounds.go
View File

@ -1,10 +1,10 @@
package datadict
package d2datadict
import (
"log"
"strings"
"github.com/OpenDiablo2/OpenDiablo2/d2common"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2resource"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2interface"
@ -82,7 +82,7 @@ var Sounds map[string]SoundEntry
func LoadSounds(fileProvider d2interface.FileProvider) {
Sounds = make(map[string]SoundEntry)
soundData := strings.Split(string(fileProvider.LoadFile(d2common.SoundSettings)), "\r\n")[1:]
soundData := strings.Split(string(fileProvider.LoadFile(d2resource.SoundSettings)), "\r\n")[1:]
for _, line := range soundData {
if len(line) == 0 {
continue

6
d2data/datadict/UniqueItems.go → d2data/d2datadict/UniqueItems.go
View File

@ -1,10 +1,10 @@
package datadict
package d2datadict
import (
"log"
"strings"
"github.com/OpenDiablo2/OpenDiablo2/d2common"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2resource"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2interface"
@ -120,7 +120,7 @@ var UniqueItems map[string]*UniqueItemRecord
func LoadUniqueItems(fileProvider d2interface.FileProvider) {
UniqueItems = make(map[string]*UniqueItemRecord)
data := strings.Split(string(fileProvider.LoadFile(d2common.UniqueItems)), "\r\n")[1:]
data := strings.Split(string(fileProvider.LoadFile(d2resource.UniqueItems)), "\r\n")[1:]
for _, line := range data {
if len(line) == 0 {
continue

6
d2data/datadict/Weapons.go → d2data/d2datadict/Weapons.go
View File

@ -1,10 +1,10 @@
package datadict
package d2datadict
import (
"log"
"strings"
"github.com/OpenDiablo2/OpenDiablo2/d2common"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2resource"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2interface"
@ -277,7 +277,7 @@ var Weapons map[string]*WeaponRecord
func LoadWeapons(fileProvider d2interface.FileProvider) {
Weapons = make(map[string]*WeaponRecord)
data := strings.Split(string(fileProvider.LoadFile(d2common.Weapons)), "\r\n")[1:]
data := strings.Split(string(fileProvider.LoadFile(d2resource.Weapons)), "\r\n")[1:]
for _, line := range data {
if len(line) == 0 {
continue

2
d2data/mpq/CryptoBuff.go → d2data/d2mpq/CryptoBuff.go
View File

@ -1,4 +1,4 @@
package mpq
package d2mpq
// CryptoBuffer contains the crypto bytes for filename hashing
var CryptoBuffer [0x500]uint32

6
d2data/mpq/MPQ.go → d2data/d2mpq/MPQ.go
View File

@ -1,4 +1,4 @@
package mpq
package d2mpq
import (
"bufio"
@ -10,7 +10,7 @@ import (
"strings"
"sync"
"github.com/OpenDiablo2/OpenDiablo2/d2common"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2resource"
)
// MPQ represents an MPQ archive
@ -260,7 +260,7 @@ func (v MPQ) FileExists(fileName string) bool {
// ReadFile reads a file from the MPQ and returns a memory stream
func (v MPQ) ReadFile(fileName string) ([]byte, error) {
fileName = strings.ReplaceAll(fileName, "{LANG}", d2common.LanguageCode)
fileName = strings.ReplaceAll(fileName, "{LANG}", d2resource.LanguageCode)
fileName = strings.ToLower(fileName)
fileName = strings.ReplaceAll(fileName, `/`, "\\")
cached := v.fileCache[fileName]

14
d2data/mpq/MPQStream.go → d2data/d2mpq/MPQStream.go
View File

@ -1,4 +1,4 @@
package mpq
package d2mpq
import (
"bufio"
@ -12,7 +12,7 @@ import (
"github.com/OpenDiablo2/OpenDiablo2/d2helper"
"github.com/JoshVarga/blast"
"github.com/OpenDiablo2/OpenDiablo2/d2data/compression"
"github.com/OpenDiablo2/OpenDiablo2/d2data/d2compression"
)
// Stream represents a stream of data in an MPQ archive
@ -191,7 +191,7 @@ func decompressMulti(data []byte, expectedLength uint32) []byte {
case 0x10: // BZip2
panic("bzip2 decompression not supported")
case 0x80: // IMA ADPCM Stereo
return compression.WavDecompress(data[1:], 2)
return d2compression.WavDecompress(data[1:], 2)
//return MpqWavCompression.Decompress(sinput, 2);
//panic("ima adpcm sterio decompression not supported")
case 0x40: // IMA ADPCM Mono
@ -207,8 +207,8 @@ func decompressMulti(data []byte, expectedLength uint32) []byte {
// TODO: sparse then bzip2
panic("sparse decompression + bzip2 decompression not supported")
case 0x41:
sinput := compression.HuffmanDecompress(data[1:])
sinput = compression.WavDecompress(sinput, 1)
sinput := d2compression.HuffmanDecompress(data[1:])
sinput = d2compression.WavDecompress(sinput, 1)
tmp := make([]byte, len(sinput))
copy(tmp, sinput)
return tmp
@ -217,8 +217,8 @@ func decompressMulti(data []byte, expectedLength uint32) []byte {
//return MpqWavCompression.Decompress(new MemoryStream(result), 1);
panic("pk + mpqwav decompression not supported")
case 0x81:
sinput := compression.HuffmanDecompress(data[1:])
sinput = compression.WavDecompress(sinput, 2)
sinput := d2compression.HuffmanDecompress(data[1:])
sinput = d2compression.WavDecompress(sinput, 2)
tmp := make([]byte, len(sinput))
copy(tmp, sinput)
return tmp

2
d2data/mpq/MpqFileRecord.go → d2data/d2mpq/MpqFileRecord.go
View File

@ -1,4 +1,4 @@
package mpq
package d2mpq
type MpqFileRecord struct {
MpqFile string

2
d2data/video/BinkDecoder.go → d2data/d2video/BinkDecoder.go
View File

@ -1,4 +1,4 @@
package video
package d2video
import (
"log"

4
d2render/AnimatedEntity.go
View File

@ -16,7 +16,7 @@ import (
"github.com/OpenDiablo2/OpenDiablo2/d2data"
"github.com/OpenDiablo2/OpenDiablo2/d2data/datadict"
"github.com/OpenDiablo2/OpenDiablo2/d2data/d2datadict"
"github.com/hajimehoshi/ebiten"
)
@ -195,7 +195,7 @@ func (v *AnimatedEntity) cacheFrames(layerName string) {
if paletteIndex == 0 {
continue
}
color := datadict.Palettes[v.palette].Colors[paletteIndex]
color := d2datadict.Palettes[v.palette].Colors[paletteIndex]
actualX := x + direction.Box.Left - int(minX)
actualY := y + direction.Box.Top - int(minY)
img.Pix[(actualX*4)+(actualY*int(frameW)*4)] = color.R

4
d2render/Sprite.go
View File

@ -9,7 +9,7 @@ import (
"github.com/OpenDiablo2/OpenDiablo2/d2helper"
"github.com/OpenDiablo2/OpenDiablo2/d2data/datadict"
"github.com/OpenDiablo2/OpenDiablo2/d2data/d2datadict"
"github.com/hajimehoshi/ebiten"
)
@ -49,7 +49,7 @@ type SpriteFrame struct {
}
// CreateSprite creates an instance of a sprite
func CreateSprite(data []byte, palette datadict.PaletteRec) *Sprite {
func CreateSprite(data []byte, palette d2datadict.PaletteRec) *Sprite {
result := &Sprite{
X: 50,
Y: 50,

2
d2render/mapengine/Engine.go → d2render/d2mapengine/Engine.go
View File

@ -1,4 +1,4 @@
package mapengine
package d2mapengine
import (
"math"

28
d2render/mapengine/Region.go → d2render/d2mapengine/Region.go
View File

@ -1,4 +1,4 @@
package mapengine
package d2mapengine
import (
"image/color"
@ -8,6 +8,8 @@ import (
"strconv"
"sync"
"github.com/OpenDiablo2/OpenDiablo2/d2core"
"github.com/OpenDiablo2/OpenDiablo2/d2helper"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2interface"
@ -18,7 +20,7 @@ import (
"github.com/OpenDiablo2/OpenDiablo2/d2data"
"github.com/OpenDiablo2/OpenDiablo2/d2data/datadict"
"github.com/OpenDiablo2/OpenDiablo2/d2data/d2datadict"
"github.com/hajimehoshi/ebiten"
)
@ -31,18 +33,18 @@ type TileCacheRecord struct {
type Region struct {
RegionPath string
LevelType datadict.LevelTypeRecord
levelPreset *datadict.LevelPresetRecord
LevelType d2datadict.LevelTypeRecord
levelPreset *d2datadict.LevelPresetRecord
TileWidth int32
TileHeight int32
Tiles []d2data.Tile
DS1 *d2data.DS1
Palette datadict.PaletteRec
Palette d2datadict.PaletteRec
FloorCache map[uint32]*TileCacheRecord
ShadowCache map[uint32]*TileCacheRecord
WallCache map[uint32]*TileCacheRecord
AnimationEntities []*d2render.AnimatedEntity
NPCs []*d2render.NPC
NPCs []*d2core.NPC
StartX float64
StartY float64
}
@ -97,14 +99,14 @@ const (
func LoadRegion(seed rand.Source, levelType RegionIdType, levelPreset int, fileProvider d2interface.FileProvider) *Region {
result := &Region{
LevelType: datadict.LevelTypes[levelType],
levelPreset: datadict.LevelPresets[levelPreset],
LevelType: d2datadict.LevelTypes[levelType],
levelPreset: d2datadict.LevelPresets[levelPreset],
Tiles: make([]d2data.Tile, 0),
FloorCache: make(map[uint32]*TileCacheRecord),
ShadowCache: make(map[uint32]*TileCacheRecord),
WallCache: make(map[uint32]*TileCacheRecord),
}
result.Palette = datadict.Palettes[d2enum.PaletteType("act"+strconv.Itoa(int(result.LevelType.Act)))]
result.Palette = d2datadict.Palettes[d2enum.PaletteType("act"+strconv.Itoa(int(result.LevelType.Act)))]
//\bm := result.levelPreset.Dt1Mask
for _, levelTypeDt1 := range result.LevelType.Files {
/*
@ -142,19 +144,19 @@ func (v *Region) loadObjects(fileProvider d2interface.FileProvider) {
var wg sync.WaitGroup
wg.Add(len(v.DS1.Objects))
v.AnimationEntities = make([]*d2render.AnimatedEntity, 0)
v.NPCs = make([]*d2render.NPC, 0)
v.NPCs = make([]*d2core.NPC, 0)
for _, object := range v.DS1.Objects {
go func(object d2data.Object) {
defer wg.Done()
switch object.Lookup.Type {
case datadict.ObjectTypeCharacter:
case d2datadict.ObjectTypeCharacter:
// Temp code, maybe..
if object.Lookup.Base == "" || object.Lookup.Token == "" || object.Lookup.TR == "" {
return
}
npc := d2render.CreateNPC(object, fileProvider)
npc := d2core.CreateNPC(object, fileProvider)
v.NPCs = append(v.NPCs, npc)
case datadict.ObjectTypeItem:
case d2datadict.ObjectTypeItem:
if object.ObjectInfo == nil || !object.ObjectInfo.Draw || object.Lookup.Base == "" || object.Lookup.Token == "" {
return
}

17
d2render/ui/Button.go → d2render/d2ui/Button.go
View File

@ -1,19 +1,20 @@
package ui
package d2ui
import (
"image"
"image/color"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2resource"
"github.com/OpenDiablo2/OpenDiablo2/d2helper"
"github.com/OpenDiablo2/OpenDiablo2/d2data/datadict"
"github.com/OpenDiablo2/OpenDiablo2/d2data/d2datadict"
"github.com/OpenDiablo2/OpenDiablo2/d2render"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2interface"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2enum"
"github.com/OpenDiablo2/OpenDiablo2/d2common"
"github.com/hajimehoshi/ebiten"
)
@ -62,10 +63,10 @@ type ButtonLayout struct {
// ButtonLayouts define the type of buttons you can have
var ButtonLayouts = map[ButtonType]ButtonLayout{
ButtonTypeWide: {2, 1, d2common.WideButtonBlank, d2enum.Units, false, 0, -1, d2common.FontExocet10, nil, true, 1},
ButtonTypeShort: {1, 1, d2common.ShortButtonBlank, d2enum.Units, false, 0, -1, d2common.FontRediculous, nil, true, -1},
ButtonTypeMedium: {1, 1, d2common.MediumButtonBlank, d2enum.Units, false, 0, 0, d2common.FontExocet10, nil, true, 0},
ButtonTypeTall: {1, 1, d2common.TallButtonBlank, d2enum.Units, false, 0, 0, d2common.FontExocet10, nil, true, 5},
ButtonTypeWide: {2, 1, d2resource.WideButtonBlank, d2enum.Units, false, 0, -1, d2resource.FontExocet10, nil, true, 1},
ButtonTypeShort: {1, 1, d2resource.ShortButtonBlank, d2enum.Units, false, 0, -1, d2resource.FontRediculous, nil, true, -1},
ButtonTypeMedium: {1, 1, d2resource.MediumButtonBlank, d2enum.Units, false, 0, 0, d2resource.FontExocet10, nil, true, 0},
ButtonTypeTall: {1, 1, d2resource.TallButtonBlank, d2enum.Units, false, 0, 0, d2resource.FontExocet10, nil, true, 5},
/*
{eButtonType.Wide, new ButtonLayout { XSegments = 2, ResourceName = ResourcePaths.WideButtonBlank, PaletteName = PaletteDefs.Units } },
{eButtonType.Narrow, new ButtonLayout { ResourceName = ResourcePaths.NarrowButtonBlank, PaletteName = PaletteDefs.Units } },
@ -120,7 +121,7 @@ func CreateButton(buttonType ButtonType, fileProvider d2interface.FileProvider,
result.buttonLayout = buttonLayout
font := GetFont(buttonLayout.FontPath, d2enum.Units, fileProvider)
buttonSprite := d2render.CreateSprite(fileProvider.LoadFile(buttonLayout.ResourceName), datadict.Palettes[buttonLayout.PaletteName])
buttonSprite := d2render.CreateSprite(fileProvider.LoadFile(buttonLayout.ResourceName), d2datadict.Palettes[buttonLayout.PaletteName])
totalButtonTypes := buttonSprite.GetTotalFrames() / (buttonLayout.XSegments * buttonLayout.YSegments)
for i := 0; i < buttonLayout.XSegments; i++ {
w, _ := buttonSprite.GetFrameSize(i)

6
d2render/ui/Font.go → d2render/d2ui/Font.go
View File

@ -1,4 +1,4 @@
package ui
package d2ui
import (
"image/color"
@ -6,7 +6,7 @@ import (
"github.com/OpenDiablo2/OpenDiablo2/d2helper"
"github.com/OpenDiablo2/OpenDiablo2/d2data/datadict"
"github.com/OpenDiablo2/OpenDiablo2/d2data/d2datadict"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2interface"
@ -47,7 +47,7 @@ func CreateFont(font string, palette d2enum.PaletteType, fileProvider d2interfac
result := &Font{
metrics: make(map[uint8]FontSize),
}
result.fontSprite = d2render.CreateSprite(fileProvider.LoadFile(font+".dc6"), datadict.Palettes[palette])
result.fontSprite = d2render.CreateSprite(fileProvider.LoadFile(font+".dc6"), d2datadict.Palettes[palette])
woo := "Woo!\x01"
fontData := fileProvider.LoadFile(font + ".tbl")
if string(fontData[0:5]) != woo {

2
d2render/ui/Label.go → d2render/d2ui/Label.go
View File

@ -1,4 +1,4 @@
package ui
package d2ui
import (
"image/color"

10
d2render/ui/Manager.go → d2render/d2ui/Manager.go
View File

@ -1,11 +1,11 @@
package ui
package d2ui
import (
"github.com/OpenDiablo2/OpenDiablo2/d2audio"
"github.com/OpenDiablo2/OpenDiablo2/d2common"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2enum"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2interface"
"github.com/OpenDiablo2/OpenDiablo2/d2data/datadict"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2resource"
"github.com/OpenDiablo2/OpenDiablo2/d2data/d2datadict"
"github.com/OpenDiablo2/OpenDiablo2/d2render"
"github.com/hajimehoshi/ebiten"
)
@ -37,8 +37,8 @@ func CreateManager(fileProvider d2interface.FileProvider, soundManager d2audio.M
result := &Manager{
pressedIndex: -1,
widgets: make([]Widget, 0),
cursorSprite: d2render.CreateSprite(fileProvider.LoadFile(d2common.CursorDefault), datadict.Palettes[d2enum.Units]),
clickSfx: soundManager.LoadSoundEffect(d2common.SFXButtonClick),
cursorSprite: d2render.CreateSprite(fileProvider.LoadFile(d2resource.CursorDefault), d2datadict.Palettes[d2enum.Units]),
clickSfx: soundManager.LoadSoundEffect(d2resource.SFXButtonClick),
waitForLeftMouseUp: false,
}
return result

2
d2render/ui/Widget.go → d2render/d2ui/Widget.go
View File

@ -1,4 +1,4 @@
package ui
package d2ui
import (
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2interface"

8
main.go
View File

@ -4,14 +4,14 @@ import (
"image"
"log"
"github.com/OpenDiablo2/OpenDiablo2/d2core/scenes"
"github.com/OpenDiablo2/OpenDiablo2/d2core/d2scene"
"github.com/hajimehoshi/ebiten/ebitenutil"
"github.com/OpenDiablo2/OpenDiablo2/d2common"
"github.com/OpenDiablo2/OpenDiablo2/d2core"
"github.com/OpenDiablo2/OpenDiablo2/d2data/mpq"
"github.com/OpenDiablo2/OpenDiablo2/d2data/d2mpq"
"github.com/hajimehoshi/ebiten"
)
@ -37,9 +37,9 @@ func main() {
if err == nil {
ebiten.SetWindowIcon([]image.Image{iconImage})
}
mpq.InitializeCryptoBuffer()
d2mpq.InitializeCryptoBuffer()
d2Engine = d2core.CreateEngine()
d2Engine.SetNextScene(scenes.CreateMainMenu(d2Engine, d2Engine, d2Engine.UIManager, d2Engine.SoundManager))
d2Engine.SetNextScene(d2scene.CreateMainMenu(d2Engine, d2Engine, d2Engine.UIManager, d2Engine.SoundManager))
ebiten.SetCursorVisible(false)
ebiten.SetFullscreen(d2Engine.Settings.FullScreen)
ebiten.SetRunnableInBackground(d2Engine.Settings.RunInBackground)

6
tests/MPQ_test.go
View File

@ -10,20 +10,20 @@ import (
"github.com/OpenDiablo2/OpenDiablo2/d2core"
"github.com/OpenDiablo2/OpenDiablo2/d2data/mpq"
"github.com/OpenDiablo2/OpenDiablo2/d2data/d2mpq"
"github.com/OpenDiablo2/OpenDiablo2/d2common"
)
func TestMPQScanPerformance(t *testing.T) {
log.SetFlags(log.Ldate | log.LUTC | log.Lmicroseconds | log.Llongfile)
mpq.InitializeCryptoBuffer()
d2mpq.InitializeCryptoBuffer()
d2common.ConfigBasePath = "../"
config := d2common.LoadConfiguration()
engine := d2core.CreateEngine()
for _, fileName := range config.MpqLoadOrder {
mpqFile := path.Join(config.MpqPath, fileName)
archive, _ := mpq.Load(mpqFile)
archive, _ := d2mpq.Load(mpqFile)
files, err := archive.GetFileList()
if err != nil {
continue

6
tests/MapLoad_test.go
View File

@ -5,15 +5,15 @@ import (
"github.com/hajimehoshi/ebiten"
_map "github.com/OpenDiablo2/OpenDiablo2/d2render/mapengine"
_map "github.com/OpenDiablo2/OpenDiablo2/d2render/d2mapengine"
"github.com/OpenDiablo2/OpenDiablo2/d2common"
"github.com/OpenDiablo2/OpenDiablo2/d2core"
"github.com/OpenDiablo2/OpenDiablo2/d2data/mpq"
"github.com/OpenDiablo2/OpenDiablo2/d2data/d2mpq"
)
func TestMapGenerationPerformance(t *testing.T) {
mpq.InitializeCryptoBuffer()
d2mpq.InitializeCryptoBuffer()
d2common.ConfigBasePath = "../"
engine := d2core.CreateEngine()