Updates (OpenDiablo2#340)

d2core/d2audio/d2audio.go

@@ -32,7 +32,9 @@ func Initialize(audioProvider AudioProvider) error {
 // PlayBGM plays an infinitely looping background track
 func PlayBGM(song string) error {
 	verifyWasInit()
-	singleton.PlayBGM(song)
+	go func() {
+		singleton.PlayBGM(song)
+	}()
 	return nil
 }
 

d2core/d2config/config.go

@@ -13,7 +13,6 @@ func getDefaultConfig() *Configuration {
 	config := &Configuration{
 		Language:        "ENG",
 		FullScreen:      false,
-		Scale:           1,
 		TicksPerSecond:  -1,
 		RunInBackground: true,
 		VsyncEnabled:    true,

d2core/d2config/d2config.go

@@ -8,7 +8,6 @@ import (
 type Configuration struct {
 	Language        string
 	FullScreen      bool
-	Scale           float64
 	RunInBackground bool
 	TicksPerSecond  int
 	FpsCap          int

d2core/d2map/act1_overworld.go

@@ -0,0 +1,45 @@
+package d2map
+
+import (
+	"math/rand"
+	"strings"
+
+	"github.com/OpenDiablo2/OpenDiablo2/d2core/d2map/d2wilderness"
+
+	"github.com/OpenDiablo2/OpenDiablo2/d2common/d2enum"
+)
+
+func (m *MapEngine) GenerateAct1Overworld(cacheTiles bool) {
+	rand.Seed(m.seed)
+	region, entities := loadRegion(m.seed, 0, 0, d2enum.RegionAct1Town, 1, -1, cacheTiles)
+	m.regions = append(m.regions, region)
+	m.entities.Add(entities...)
+	if strings.Contains(region.regionPath, "E1") {
+		region, entities := loadRegion(m.seed, region.tileRect.Width, 0, d2enum.RegionAct1Town, 2, -1, cacheTiles)
+		m.AppendRegion(region)
+		m.entities.Add(entities...)
+	} else if strings.Contains(region.regionPath, "S1") {
+		yOffset := region.tileRect.Height
+		waterXOffset := region.tileRect.Width - 16
+		region, entities := loadRegion(m.seed, 0, yOffset, d2enum.RegionAct1Town, 3, -1, cacheTiles)
+		m.AppendRegion(region)
+		m.entities.Add(entities...)
+		yOffset += region.tileRect.Height
+
+		for i := 0; i < 8; i++ {
+			// West Border
+			region, entities = loadRegion(m.seed, 0, yOffset, d2enum.RegionAct1Wilderness, d2wilderness.TreeBorderWest, 0, cacheTiles)
+			m.AppendRegion(region)
+			m.entities.Add(entities...)
+
+			// East Border
+			region, entities = loadRegion(m.seed, waterXOffset, yOffset, d2enum.RegionAct1Wilderness, d2wilderness.WaterBorderEast, 0, cacheTiles)
+			m.AppendRegion(region)
+			m.entities.Add(entities...)
+
+			yOffset += region.tileRect.Height
+		}
+
+	}
+
+}

d2core/d2map/d2wilderness/wilderness_tile_types.go

@@ -0,0 +1,53 @@
+package d2wilderness
+
+const (
+	TreeBorderSouth int = iota + 4
+	TreeBorderWest
+	TreeBorderNorth
+	TreeBorderEast
+	TreeBorderSouthWest
+	TreeBorderNorthWest
+	TreeBorderNorthEast
+	TreeBorderSouthEast
+	TreeBoxNorthEast
+	TreeBoxSouthEast
+	TreeBoxSouthWest
+	TreeBoxNorthWest
+	WallBorderWest
+	WallBorderEast
+	WallBorderWestFenceNorth
+	WallBorderNorthWest
+	WallBorderWestFenceSouth
+	WallBorderNorthFenceEast
+	WallBorderNorthFenceWest
+	WallBoxSouthEast
+	WallBorderNorthUndergroundPassageEntrance
+	WallBorderWestUndergroundPassageEntrance
+	WaterBorderEast
+	WaterBorderWest
+	WaterBridgeEast
+	DirtSquareWithRocks
+	FourDirtSquaresWithRocks
+	FenceMaze
+	RandomTreesAndWallBoxLarge
+	TreeBoxNorthSouth
+	ShrineWithFenceAndTrees
+	RandomTreesAndWallBoxSmall
+	TreeBoxWestEastWithNorthSouthPath
+	TreeBoxNorthSouthWithEastWestPath
+	GrassPatch1
+	GrassPatch2
+	EnemyFeature1
+	EnemyFeature2
+	EnemyFeature3
+	EnemyFeature4
+	EnemyFeature5
+	EnemyFeature6
+	Pond
+	House1
+	House2
+	BurnedHouse
+	NotTheCowLevel
+	UndergroundCavern
+	DenOfEvil
+)

d2core/d2map/engine.go

@@ -3,7 +3,6 @@ package d2map
 import (
 	"log"
 	"math"
-	"strings"
 
 	"github.com/beefsack/go-astar"
 
@@ -26,22 +25,25 @@ type MapEngine struct {
 }
 
 // Creates a new instance of the map engine
-func CreateMapEngine() *MapEngine {
+func CreateMapEngine(seed int64) *MapEngine {
 	engine := &MapEngine{
-		seed:     0,
+		seed:     seed,
 		entities: NewRangeSearcher(),
 	}
 
 	return engine
 }
 
+// Sets the seed of the map for generation
 func (m *MapEngine) SetSeed(seed int64) {
 	log.Printf("Setting map engine seed to %d", seed)
 	m.seed = seed
 }
 
 func (m *MapEngine) GetStartPosition() (float64, float64) {
 	var startX, startY float64
+
+	// TODO: Temporary code, only works for starting map
 	if len(m.regions) > 0 {
 		region := m.regions[0]
 		startX, startY = region.getStartTilePosition()
@@ -68,29 +70,48 @@ func (m *MapEngine) GenerateMap(regionType d2enum.RegionIdType, levelPreset int,
 	m.entities.Add(entities...)
 }
 
-func (m *MapEngine) GenerateAct1Overworld(cacheTiles bool) {
-	//d2audio.PlayBGM("/data/global/music/Act1/town1.wav") // TODO: Temp stuff here
-
-	region, entities := loadRegion(m.seed, 0, 0, d2enum.RegionAct1Town, 1, -1, cacheTiles)
+// Appends a region to the map
+func (m *MapEngine) AppendRegion(region *MapRegion) {
 	m.regions = append(m.regions, region)
-	m.entities.Add(entities...)
+	// Stitch together the walk map
+	for x := 0; x < region.tileRect.Width*5; x++ {
+		otherRegion := m.GetRegionAtTile(region.tileRect.Left+(x/5), region.tileRect.Top-1)
+		if otherRegion == nil {
+			continue
+		}
+		xDiff := region.tileRect.Left - otherRegion.tileRect.Left
 
-	if strings.Contains(region.regionPath, "E1") {
-		region, entities := loadRegion(m.seed, region.tileRect.Width-1, 0, d2enum.RegionAct1Town, 2, -1, cacheTiles)
-		m.AppendRegion(region)
-		m.entities.Add(entities...)
-	} else if strings.Contains(region.regionPath, "S1") {
-		region, entities := loadRegion(m.seed, 0, region.tileRect.Height-1, d2enum.RegionAct1Town, 3, -1, cacheTiles)
-		m.AppendRegion(region)
-		m.entities.Add(entities...)
+		sourceSubtile := &region.walkableArea[0][x]
+		if !sourceSubtile.Walkable {
+			continue
+		}
+
+		// North West
+		otherX := x + xDiff - 1
+		otherY := (otherRegion.tileRect.Height * 5) - 1
+		if otherX < 0 || otherX >= len(otherRegion.walkableArea[otherY]) {
+			continue
+		}
+		otherRegion.walkableArea[otherY][x+xDiff].DownRight = sourceSubtile
+		sourceSubtile.UpLeft = &otherRegion.walkableArea[otherY][x+xDiff]
+
+		// North
+		otherX++
+		if otherX < 0 || otherX >= len(otherRegion.walkableArea[otherY]) {
+			continue
+		}
+		otherRegion.walkableArea[otherY][x+xDiff].Down = sourceSubtile
+		sourceSubtile.Up = &otherRegion.walkableArea[otherY][x+xDiff]
+
+		// NorthEast
+		otherX++
+		if otherX < 0 || otherX >= len(otherRegion.walkableArea[otherY]) {
+			continue
+		}
+		otherRegion.walkableArea[otherY][x+xDiff].DownLeft = sourceSubtile
+		sourceSubtile.UpRight = &otherRegion.walkableArea[otherY][x+xDiff]
 	}
-}
 
-// Appends a region to the map
-func (m *MapEngine) AppendRegion(region *MapRegion) {
-	// TODO: Stitch together region.walkableArea
-	log.Printf("Warning: Walkable areas are not currently implemented")
-	m.regions = append(m.regions, region)
 }
 
 // Returns the region located at the specified tile location
@@ -104,10 +125,12 @@ func (m *MapEngine) GetRegionAtTile(x, y int) *MapRegion {
 	return nil
 }
 
+// Adds an entity to the map engine
 func (m *MapEngine) AddEntity(entity MapEntity) {
 	m.entities.Add(entity)
 }
 
+// Removes an entity from the map engine
 func (m *MapEngine) RemoveEntity(entity MapEntity) {
 	if entity == nil {
 		return
@@ -116,6 +139,7 @@ func (m *MapEngine) RemoveEntity(entity MapEntity) {
 	m.entities.Remove(entity)
 }
 
+// Advances time on the map engine
 func (m *MapEngine) Advance(tickTime float64) {
 	for _, region := range m.regions {
 		//if region.isVisbile(m.viewport) {
@@ -130,20 +154,35 @@ func (m *MapEngine) Advance(tickTime float64) {
 	m.entities.Update()
 }
 
+// Finds a walkable path between two points
 func (m *MapEngine) PathFind(startX, startY, endX, endY float64) (path []astar.Pather, distance float64, found bool) {
 	startTileX := int(math.Floor(startX))
 	startTileY := int(math.Floor(startY))
 	startSubtileX := int((startX - float64(int(startX))) * 5)
 	startSubtileY := int((startY - float64(int(startY))) * 5)
 	startRegion := m.GetRegionAtTile(startTileX, startTileY)
+	if startRegion == nil {
+		return
+	}
 	startNode := &startRegion.walkableArea[startSubtileY+((startTileY-startRegion.tileRect.Top)*5)][startSubtileX+((startTileX-startRegion.tileRect.Left)*5)]
 
 	endTileX := int(math.Floor(endX))
 	endTileY := int(math.Floor(endY))
 	endSubtileX := int((endX - float64(int(endX))) * 5)
 	endSubtileY := int((endY - float64(int(endY))) * 5)
 	endRegion := m.GetRegionAtTile(endTileX, endTileY)
-	endNode := &endRegion.walkableArea[endSubtileY+((endTileY-endRegion.tileRect.Top)*5)][endSubtileX+((endTileX-endRegion.tileRect.Left)*5)]
+	if endRegion == nil {
+		return
+	}
+	endNodeY := endSubtileY + ((endTileY - endRegion.tileRect.Top) * 5)
+	endNodeX := endSubtileX + ((endTileX - endRegion.tileRect.Left) * 5)
+	if endNodeY < 0 || endNodeY >= len(endRegion.walkableArea) {
+		return
+	}
+	if endNodeX < 0 || endNodeX >= len(endRegion.walkableArea[endNodeY]) {
+		return
+	}
+	endNode := &endRegion.walkableArea[endNodeY][endNodeX]
 
 	path, distance, found = astar.Path(endNode, startNode)
 	if path != nil {

d2core/d2map/region.go

@@ -139,8 +139,8 @@ func loadRegion(seed int64, tileOffsetX, tileOffsetY int, levelType d2enum.Regio
 	region.tileRect = d2common.Rectangle{
 		Left:   tileOffsetX,
 		Top:    tileOffsetY,
-		Width:  int(region.ds1.Width),
-		Height: int(region.ds1.Height),
+		Width:  int(region.ds1.Width - 1),
+		Height: int(region.ds1.Height - 1),
 	}
 
 	entities := region.loadEntities()
@@ -155,10 +155,10 @@ func loadRegion(seed int64, tileOffsetX, tileOffsetY int, levelType d2enum.Regio
 
 func (mr *MapRegion) generateWalkableMatrix() {
 	mr.walkableArea = make([][]PathTile, mr.tileRect.Height*5)
-	for y := 0; y < (mr.tileRect.Height-1)*5; y++ {
+	for y := 0; y < mr.tileRect.Height*5; y++ {
 		mr.walkableArea[y] = make([]PathTile, mr.tileRect.Width*5)
 		ty := int(float64(y) / 5.0)
-		for x := 0; x < (mr.tileRect.Width-1)*5; x++ {
+		for x := 0; x < mr.tileRect.Width*5; x++ {
 			tx := int(float64(x) / 5.0)
 			tile := mr.GetTile(tx, ty)
 			isBlocked := false
@@ -188,8 +188,8 @@ func (mr *MapRegion) generateWalkableMatrix() {
 			}
 			mr.walkableArea[y][x] = PathTile{
 				Walkable: !isBlocked,
-				X:        float64(x) / 5.0,
-				Y:        float64(y) / 5.0,
+				X:        (float64(x) / 5.0) + float64(mr.tileRect.Left),
+				Y:        (float64(y) / 5.0) + float64(mr.tileRect.Top),
 			}
 			if !isBlocked && y > 0 && mr.walkableArea[y-1][x].Walkable {
 				mr.walkableArea[y][x].Up = &mr.walkableArea[y-1][x]
@@ -203,7 +203,7 @@ func (mr *MapRegion) generateWalkableMatrix() {
 				mr.walkableArea[y][x].UpLeft = &mr.walkableArea[y-1][x-1]
 				mr.walkableArea[y-1][x-1].DownRight = &mr.walkableArea[y][x]
 			}
-			if !isBlocked && y > 0 && x < (mr.tileRect.Width*5) && mr.walkableArea[y-1][x+1].Walkable {
+			if !isBlocked && y > 0 && x < (mr.tileRect.Width*5)-1 && mr.walkableArea[y-1][x+1].Walkable {
 				mr.walkableArea[y][x].UpRight = &mr.walkableArea[y-1][x+1]
 				mr.walkableArea[y-1][x+1].DownLeft = &mr.walkableArea[y][x]
 			}
@@ -231,7 +231,7 @@ func (mr *MapRegion) loadSpecials() {
 	for tileY := range mr.ds1.Tiles {
 		for tileX := range mr.ds1.Tiles[tileY] {
 			for _, wall := range mr.ds1.Tiles[tileY][tileX].Walls {
-				if wall.Type == 10 && wall.Style == 30 && wall.Sequence == 0 {
+				if wall.Type == 10 && wall.Style == 30 && wall.Sequence == 0 && mr.startX == 0 && mr.startY == 0 {
 					mr.startX, mr.startY = mr.getTileWorldPosition(tileX, tileY)
 					mr.startX += 0.5
 					mr.startY += 0.5

d2core/d2render/ebiten/ebiten_renderer.go

@@ -10,7 +10,21 @@ import (
 	"github.com/OpenDiablo2/OpenDiablo2/d2core/d2render"
 )
 
-type Renderer struct{}
+type Renderer struct {
+	renderCallback func(surface d2render.Surface) error
+}
+
+func (r *Renderer) Update(screen *ebiten.Image) error {
+	err := r.renderCallback(&ebitenSurface{image: screen})
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func (r *Renderer) Layout(outsideWidth, outsideHeight int) (screenWidth, screenHeight int) {
+	return 800, 600
+}
 
 func CreateRenderer() (*Renderer, error) {
 	result := &Renderer{}
@@ -42,15 +56,11 @@ func (r *Renderer) IsDrawingSkipped() bool {
 }
 
 func (r *Renderer) Run(f func(surface d2render.Surface) error, width, height int, title string) error {
-	config := d2config.Get()
-
-	return ebiten.Run(func(img *ebiten.Image) error {
-		err := f(&ebitenSurface{image: img})
-		if err != nil {
-			return err
-		}
-		return nil
-	}, width, height, config.Scale, title)
+	r.renderCallback = f
+	ebiten.SetWindowTitle(title)
+	ebiten.SetWindowResizable(true)
+	ebiten.SetWindowSize(width, height)
+	return ebiten.RunGame(r)
 }
 
 func (r *Renderer) CreateSurface(surface d2render.Surface) (d2render.Surface, error) {