gravestench/OpenDiablo2
1
1
Fork 0
mirror of https://github.com/OpenDiablo2/OpenDiablo2 synced 2025-02-20 07:27:19 -05:00
Code Issues Releases Wiki Activity

Fixed map stamp offset issue (#403)

Browse Source
This commit is contained in:
Tim Sarbin 2020-06-22 19:33:12 -04:00 committed by GitHub
parent d17db5b1d1
commit 4dc4654750
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
4 changed files with 42 additions and 84 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
d2core/d2asset/archive_manager.go
View File

@ -40,7 +40,10 @@ func (am *archiveManager) loadArchiveForFile(filePath string) (*d2mpq.MPQ, error
for _, archiveEntry := range am.entries {
if archiveEntry.hashEntryMap.Contains(filePath) {
return am.loadArchive(archiveEntry.archivePath)
result, ok := am.loadArchive(archiveEntry.archivePath)
if ok == nil {
return result, nil
}
}
}

7
d2core/d2map/d2mapengine/engine.go
View File

@ -64,6 +64,7 @@ func (m *MapEngine) ResetMap(levelType d2enum.RegionIdType, width, height int) {
dt1, _ := d2dt1.LoadDT1(fileData)
m.dt1TileData = append(m.dt1TileData, dt1.Tiles...)
}
}
func (m *MapEngine) FindTile(style, sequence, tileType int32) d2dt1.Tile {
@ -106,13 +107,13 @@ func (m *MapEngine) PlaceStamp(stamp *d2mapstamp.Stamp, tileOffsetX, tileOffsetY
// Copy over the map tile data
for y := 0; y < stampSize.Height; y++ {
for x := 0; x < stampSize.Width; x++ {
mapTileIdx := x + tileOffsetX + ((y + tileOffsetY) * stampSize.Width)
mapTileIdx := x + tileOffsetX + ((y + tileOffsetY) * m.size.Width)
m.tiles[mapTileIdx] = *stamp.Tile(x, y)
}
}
// Copy over the entities
m.entities = append(m.entities, stamp.Entities()...)
m.entities = append(m.entities, stamp.Entities(tileOffsetX, tileOffsetY)...)
}
// Returns a reference to a map tile based on the specified tile X and Y coordinate
@ -199,7 +200,7 @@ func (m *MapEngine) TileExists(tileX, tileY int) bool {
}
func (m *MapEngine) GenerateMap(regionType d2enum.RegionIdType, levelPreset int, fileIndex int, cacheTiles bool) {
region := d2mapstamp.LoadStamp(m.seed, regionType, levelPreset, fileIndex)
region := d2mapstamp.LoadStamp(regionType, levelPreset, fileIndex)
regionSize := region.Size()
m.ResetMap(regionType, regionSize.Width, regionSize.Height)
m.PlaceStamp(region, 0, 0)

75
d2core/d2map/d2mapgen/act1_overworld.go
View File

@ -4,6 +4,8 @@ import (
"log"
"math/rand"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2fileformats/d2ds1"
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2enum"
"github.com/OpenDiablo2/OpenDiablo2/d2core/d2map/d2mapengine"
"github.com/OpenDiablo2/OpenDiablo2/d2core/d2map/d2mapstamp"
@ -12,63 +14,24 @@ import (
func GenerateAct1Overworld(mapEngine *d2mapengine.MapEngine) {
log.Printf("Map seed: %d", mapEngine.Seed())
rand.Seed(mapEngine.Seed())
townStamp := d2mapstamp.LoadStamp(mapEngine.Seed(), d2enum.RegionAct1Town, 1, -1)
townStamp := d2mapstamp.LoadStamp(d2enum.RegionAct1Town, 1, -1)
townSize := townStamp.Size()
mapEngine.ResetMap(d2enum.RegionAct1Town, townSize.Width, townSize.Height) // TODO: Mapgen - Needs levels.txt stuff
mapEngine.PlaceStamp(townStamp, 0, 0)
mapEngine.ResetMap(d2enum.RegionAct1Town, 100, 100) // TODO: Mapgen - Needs levels.txt stuff
wildernessGrass := d2ds1.FloorShadowRecord{
Prop1: 195,
Style: 0,
}
mapWidth := mapEngine.Size().Width
for y := 0; y < 100; y++ {
for x := 0; x < 100; x++ {
(*mapEngine.Tiles())[x+(y*mapWidth)].RegionType = d2enum.RegionAct1Wilderness
(*mapEngine.Tiles())[x+(y*mapWidth)].Floors = []d2ds1.FloorShadowRecord{wildernessGrass}
}
}
mapEngine.PlaceStamp(townStamp, 50-(townSize.Width/2), 50-(townSize.Height/2))
mapEngine.RegenerateWalkPaths()
//region, entities := LoadStamp(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 := LoadStamp(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") {
// region.tileRect.Height -= 1 // For some reason, this has a duplciate wall tile strip...
// mapWidthTiles := ((region.tileRect.Width - 18) / 9)
// yOffset := region.tileRect.Height
// waterXOffset := region.tileRect.Width - 17
// region, entities := LoadStamp(m.seed, 0, yOffset, d2enum.RegionAct1Town, 3, -1, cacheTiles)
// m.AppendRegion(region)
// m.entities.Add(entities...)
// yOffset += region.tileRect.Height
//
// var choices = [...]int{
// d2wilderness.StoneFill1,
// d2wilderness.StoneFill2,
// d2wilderness.SwampFill1,
// d2wilderness.Cottages1,
// d2wilderness.Cottages2,
// d2wilderness.Cottages3,
// d2wilderness.CorralFill,
// d2wilderness.FallenCamp1,
// d2wilderness.FallenCamp2,
// d2wilderness.Pond,
// }
//
// for i := 0; i < 6; i++ {
// // West Border
// region, entities = LoadStamp(m.seed, 0, yOffset, d2enum.RegionAct1Wilderness, d2wilderness.TreeBorderWest, 0, cacheTiles)
// m.AppendRegion(region)
// m.entities.Add(entities...)
//
// // East Border
// region, entities = LoadStamp(m.seed, waterXOffset, yOffset, d2enum.RegionAct1Wilderness, d2wilderness.WaterBorderEast, 0, cacheTiles)
// m.AppendRegion(region)
// m.entities.Add(entities...)
//
// // Grass
// for ix := 0; ix < mapWidthTiles; ix++ {
// region, entities = LoadStamp(m.seed, ((ix)*9)+7, yOffset, d2enum.RegionAct1Wilderness, choices[rand.Intn(len(choices))], 0, cacheTiles)
// m.AppendRegion(region)
// m.entities.Add(entities...)
// }
//
// yOffset += 9
// }
//
//}
}

39
d2core/d2map/d2mapstamp/stamp.go
View File

@ -26,7 +26,7 @@ type Stamp struct {
}
// Loads a stamp based on the supplied parameters
func LoadStamp(seed int64, levelType d2enum.RegionIdType, levelPreset int, fileIndex int) *Stamp {
func LoadStamp(levelType d2enum.RegionIdType, levelPreset int, fileIndex int) *Stamp {
stamp := &Stamp{
levelType: d2datadict.LevelTypes[levelType],
levelPreset: d2datadict.LevelPresets[levelPreset],
@ -77,9 +77,6 @@ func LoadStamp(seed int64, levelType d2enum.RegionIdType, levelPreset int, fileI
}
}
//entities := stamp.loadEntities()
//stamp.loadSpecials()
return stamp
}
@ -118,7 +115,7 @@ func (mr *Stamp) TileData(style int32, sequence int32, tileType d2enum.TileType)
return nil
}
func (mr *Stamp) Entities() []d2mapentity.MapEntity {
func (mr *Stamp) Entities(tileOffsetX, tileOffsetY int) []d2mapentity.MapEntity {
entities := make([]d2mapentity.MapEntity, 0)
for _, object := range mr.ds1.Objects {
@ -126,13 +123,13 @@ func (mr *Stamp) Entities() []d2mapentity.MapEntity {
switch object.Lookup.Type {
case d2datadict.ObjectTypeCharacter:
if object.Lookup.Base != "" && object.Lookup.Token != "" && object.Lookup.TR != "" {
npc := d2mapentity.CreateNPC(object.X, object.Y, object.Lookup, 0)
npc.SetPaths(object.Paths)
npc := d2mapentity.CreateNPC((tileOffsetX*5)+object.X, (tileOffsetY*5)+object.Y, object.Lookup, 0)
npc.SetPaths(convertPaths(tileOffsetX, tileOffsetY, object.Paths))
entities = append(entities, npc)
}
case d2datadict.ObjectTypeItem:
if object.ObjectInfo != nil && object.ObjectInfo.Draw && object.Lookup.Base != "" && object.Lookup.Token != "" {
entity, err := d2mapentity.CreateAnimatedComposite(object.X, object.Y, object.Lookup, d2resource.PaletteUnits)
entity, err := d2mapentity.CreateAnimatedComposite((tileOffsetX*5)+object.X, (tileOffsetY*5)+object.Y, object.Lookup, d2resource.PaletteUnits)
if err != nil {
panic(err)
}
@ -145,19 +142,13 @@ func (mr *Stamp) Entities() []d2mapentity.MapEntity {
return entities
}
//
//func (mr *Stamp) 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 && mr.startX == 0 && mr.startY == 0 {
// mr.startX, mr.startY = mr.getTileWorldPosition(tileX, tileY)
// mr.startX += 0.5
// mr.startY += 0.5
// return
// }
// }
// }
// }
//}
//
func convertPaths(tileOffsetX, tileOffsetY int, paths []d2common.Path) []d2common.Path {
result := make([]d2common.Path, len(paths))
for i := 0; i < len(paths); i++ {
result[i].Action = paths[i].Action
result[i].X = paths[i].X + (tileOffsetX * 5)
result[i].Y = paths[i].Y + (tileOffsetY * 5)
}
return result
}