From 41c1d8e87413fe23e046d0f6f19923ffa5fe1d0d Mon Sep 17 00:00:00 2001 From: gucio321 <73652197+gucio321@users.noreply.github.com> Date: Sat, 27 Mar 2021 21:09:53 +0100 Subject: [PATCH] bugfix: "insert" bug (#12) * remove magic 'et' file * ds1 refactor: test for InsertFloors; fixed inserting bug * ds1: global method for getting layers group; fixed Delete.. bug (group var in delete meghod wasn't pointer * ds1: lintfix * ds1: remove ds1.ds1Layers.Orientation * ds1: lintfix * ds1: addet getMaxGroupLen method * ds1: insert now returns if after inserting group will be greater than max number of ... * ds1: add common test for ds1Layers.Insert... Co-authored-by: M. Sz --- d2common/d2fileformats/d2ds1/ds1.go | 3 +- d2common/d2fileformats/d2ds1/ds1_layers.go | 210 ++++++------------ .../d2fileformats/d2ds1/ds1_layers_test.go | 80 +++++-- d2core/d2map/d2mapstamp/stamp.go | 6 - et | 73 ------ 5 files changed, 124 insertions(+), 248 deletions(-) delete mode 100644 et diff --git a/d2common/d2fileformats/d2ds1/ds1.go b/d2common/d2fileformats/d2ds1/ds1.go index 3cec1998..131e2d39 100644 --- a/d2common/d2fileformats/d2ds1/ds1.go +++ b/d2common/d2fileformats/d2ds1/ds1.go @@ -157,7 +157,6 @@ func (ds1 *DS1) loadBody(stream *d2datautils.StreamReader) error { for ; numWalls > 0; numWalls-- { ds1.PushWall(&layer{}) - ds1.PushOrientation(&layer{}) } for ; numShadows > 0; numShadows-- { @@ -241,8 +240,8 @@ func (ds1 *DS1) loadObjects(br *d2datautils.StreamReader) error { for objIdx := 0; objIdx < int(numObjects); objIdx++ { obj := Object{} - objType, err := br.ReadInt32() + objType, err := br.ReadInt32() if err != nil { return fmt.Errorf("reading object's %d type: %v", objIdx, err) } diff --git a/d2common/d2fileformats/d2ds1/ds1_layers.go b/d2common/d2fileformats/d2ds1/ds1_layers.go index 7b37d4ea..b1ea93ee 100644 --- a/d2common/d2fileformats/d2ds1/ds1_layers.go +++ b/d2common/d2fileformats/d2ds1/ds1_layers.go @@ -2,7 +2,6 @@ package d2ds1 const ( maxWallLayers = 4 - maxOrientationLayers = 4 maxFloorLayers = 2 maxShadowLayers = 1 maxSubstitutionLayers = 1 @@ -13,7 +12,6 @@ type layerGroupType int const ( floorLayerGroup layerGroupType = iota wallLayerGroup - orientationLayerGroup shadowLayerGroup substitutionLayerGroup ) @@ -24,7 +22,6 @@ type ds1Layers struct { width, height int Floors layerGroup Walls layerGroup - Orientations layerGroup Shadows layerGroup Substitutions layerGroup } @@ -38,10 +35,6 @@ func (l *ds1Layers) ensureInit() { l.Walls = make(layerGroup, 0) } - if l.Orientations == nil { - l.Orientations = make(layerGroup, 0) - } - if l.Shadows == nil { l.Shadows = make(layerGroup, 0) } @@ -55,27 +48,14 @@ func (l *ds1Layers) ensureInit() { func (l *ds1Layers) cull() { l.cullNilLayers(floorLayerGroup) l.cullNilLayers(wallLayerGroup) - l.cullNilLayers(orientationLayerGroup) l.cullNilLayers(shadowLayerGroup) l.cullNilLayers(substitutionLayerGroup) } // removes nil layers of given layer group type func (l *ds1Layers) cullNilLayers(t layerGroupType) { - var group *layerGroup - - switch t { - case floorLayerGroup: - group = &l.Floors - case wallLayerGroup: - group = &l.Walls - case orientationLayerGroup: - group = &l.Orientations - case shadowLayerGroup: - group = &l.Shadows - case substitutionLayerGroup: - group = &l.Substitutions - default: + group := l.getLayersGroup(t) + if group == nil { return } @@ -106,7 +86,6 @@ func (l *ds1Layers) SetSize(w, h int) { l.enforceSize(floorLayerGroup) l.enforceSize(wallLayerGroup) - l.enforceSize(orientationLayerGroup) l.enforceSize(shadowLayerGroup) l.enforceSize(substitutionLayerGroup) } @@ -115,20 +94,8 @@ func (l *ds1Layers) enforceSize(t layerGroupType) { l.ensureInit() l.cull() - var group *layerGroup - - switch t { - case floorLayerGroup: - group = &l.Floors - case wallLayerGroup: - group = &l.Walls - case orientationLayerGroup: - group = &l.Orientations - case shadowLayerGroup: - group = &l.Shadows - case substitutionLayerGroup: - group = &l.Substitutions - default: + group := l.getLayersGroup(t) + if group == nil { return } @@ -160,29 +127,9 @@ func (l *ds1Layers) push(t layerGroupType, layer *layer) { l.ensureInit() l.cull() - var group *layerGroup + group := l.getLayersGroup(t) - var max int - - switch t { - case floorLayerGroup: - group = &l.Floors - max = maxFloorLayers - case wallLayerGroup: - group = &l.Walls - max = maxWallLayers - case orientationLayerGroup: - group = &l.Orientations - max = maxOrientationLayers - case shadowLayerGroup: - group = &l.Shadows - max = maxShadowLayers - case substitutionLayerGroup: - group = &l.Substitutions - max = maxSubstitutionLayers - default: - return - } + max := getMaxGroupLen(t) if len(*group) < max { *group = append(*group, layer) @@ -194,25 +141,13 @@ func (l *ds1Layers) pop(t layerGroupType) *layer { l.ensureInit() l.cull() - var group *layerGroup - - var theLayer *layer - - switch t { - case floorLayerGroup: - group = &l.Floors - case wallLayerGroup: - group = &l.Walls - case orientationLayerGroup: - group = &l.Orientations - case shadowLayerGroup: - group = &l.Shadows - case substitutionLayerGroup: - group = &l.Substitutions - default: + group := l.getLayersGroup(t) + if group == nil { return nil } + var theLayer *layer + // remove last layer of slice and return it if len(*group) > 0 { lastIdx := len(*group) - 1 @@ -229,20 +164,8 @@ func (l *ds1Layers) get(t layerGroupType, idx int) *layer { l.ensureInit() l.cull() - var group *layerGroup - - switch t { - case floorLayerGroup: - group = &l.Floors - case wallLayerGroup: - group = &l.Walls - case orientationLayerGroup: - group = &l.Orientations - case shadowLayerGroup: - group = &l.Shadows - case substitutionLayerGroup: - group = &l.Substitutions - default: + group := l.getLayersGroup(t) + if group == nil { return nil } @@ -261,30 +184,22 @@ func (l *ds1Layers) insert(t layerGroupType, idx int, newLayer *layer) { return } - var group layerGroup - - switch t { - case floorLayerGroup: - group = l.Floors - case wallLayerGroup: - group = l.Walls - case orientationLayerGroup: - group = l.Orientations - case shadowLayerGroup: - group = l.Shadows - case substitutionLayerGroup: - group = l.Substitutions - default: + group := l.getLayersGroup(t) + if group == nil { return } - if len(group) == 0 { - group = append(group, newLayer) // nolint:staticcheck // we possibly use group later + if len(*group)+1 > getMaxGroupLen(t) { return } - if idx > len(group)-1 { - idx = len(group) - 1 + if len(*group) == 0 { + *group = append(*group, newLayer) // nolint:staticcheck // we possibly use group later + return + } + + if l := len(*group) - 1; idx > l { + idx = l } // example: @@ -292,36 +207,24 @@ func (l *ds1Layers) insert(t layerGroupType, idx int, newLayer *layer) { // idx=1 // newLayer=c // existing layerGroup is [a, b] - group = append(group, group[idx:]...) // [a, b] becomes [a, b, b] - group[idx] = newLayer // [a, b, b] becomes [a, c, b] + newGroup := append((*group)[:idx], append([]*layer{newLayer}, (*group)[idx:]...)...) + *group = newGroup } func (l *ds1Layers) delete(t layerGroupType, idx int) { l.ensureInit() l.cull() - var group layerGroup - - switch t { - case floorLayerGroup: - group = l.Floors - case wallLayerGroup: - group = l.Walls - case orientationLayerGroup: - group = l.Orientations - case shadowLayerGroup: - group = l.Shadows - case substitutionLayerGroup: - group = l.Substitutions - default: + group := l.getLayersGroup(t) + if group == nil { return } - if idx >= len(group) || idx < 0 { + if idx >= len(*group) || idx < 0 { return } - group[idx] = nil + (*group)[idx] = nil l.cull() } @@ -368,27 +271,6 @@ func (l *ds1Layers) DeleteWall(idx int) { l.delete(wallLayerGroup, idx) } -func (l *ds1Layers) GetOrientation(idx int) *layer { - return l.get(orientationLayerGroup, idx) -} - -func (l *ds1Layers) PushOrientation(orientation *layer) *ds1Layers { - l.push(orientationLayerGroup, orientation) - return l -} - -func (l *ds1Layers) PopOrientation() *layer { - return l.pop(orientationLayerGroup) -} - -func (l *ds1Layers) InsertOrientation(idx int, newOrientation *layer) { - l.insert(orientationLayerGroup, idx, newOrientation) -} - -func (l *ds1Layers) DeleteOrientation(idx int) { - l.delete(orientationLayerGroup, idx) -} - func (l *ds1Layers) GetShadow(idx int) *layer { return l.get(shadowLayerGroup, idx) } @@ -424,9 +306,43 @@ func (l *ds1Layers) PopSubstitution() *layer { } func (l *ds1Layers) InsertSubstitution(idx int, newSubstitution *layer) { - l.insert(shadowLayerGroup, idx, newSubstitution) + l.insert(substitutionLayerGroup, idx, newSubstitution) } func (l *ds1Layers) DeleteSubstitution(idx int) { l.delete(shadowLayerGroup, idx) } + +func (l *ds1Layers) getLayersGroup(t layerGroupType) (group *layerGroup) { + switch t { + case floorLayerGroup: + group = &l.Floors + case wallLayerGroup: + group = &l.Walls + case shadowLayerGroup: + group = &l.Shadows + case substitutionLayerGroup: + group = &l.Substitutions + default: + return nil + } + + return group +} + +func getMaxGroupLen(t layerGroupType) (max int) { + switch t { + case floorLayerGroup: + max = maxFloorLayers + case wallLayerGroup: + max = maxWallLayers + case shadowLayerGroup: + max = maxShadowLayers + case substitutionLayerGroup: + max = maxSubstitutionLayers + default: + return 0 + } + + return max +} diff --git a/d2common/d2fileformats/d2ds1/ds1_layers_test.go b/d2common/d2fileformats/d2ds1/ds1_layers_test.go index cd2c952d..e7e43d56 100644 --- a/d2common/d2fileformats/d2ds1/ds1_layers_test.go +++ b/d2common/d2fileformats/d2ds1/ds1_layers_test.go @@ -6,8 +6,6 @@ import ( func Test_ds1Layers_DeleteFloor(t *testing.T) {} -func Test_ds1Layers_DeleteOrientation(t *testing.T) {} - func Test_ds1Layers_DeleteShadow(t *testing.T) {} func Test_ds1Layers_DeleteSubstitution(t *testing.T) {} @@ -16,28 +14,79 @@ func Test_ds1Layers_DeleteWall(t *testing.T) {} func Test_ds1Layers_GetFloor(t *testing.T) {} -func Test_ds1Layers_GetOrientation(t *testing.T) {} - func Test_ds1Layers_GetShadow(t *testing.T) {} func Test_ds1Layers_GetSubstitution(t *testing.T) {} func Test_ds1Layers_GetWall(t *testing.T) {} -func Test_ds1Layers_InsertFloor(t *testing.T) {} +func Test_ds1Layers_Insert(t *testing.T) { + t.Run("Floors", func(t *testing.T) { + ds1LayersInsert(t, floorLayerGroup) + }) + t.Run("Walls", func(t *testing.T) { + ds1LayersInsert(t, wallLayerGroup) + }) + t.Run("Shadows", func(t *testing.T) { + ds1LayersInsert(t, shadowLayerGroup) + }) + t.Run("Substitution", func(t *testing.T) { + ds1LayersInsert(t, substitutionLayerGroup) + }) +} -func Test_ds1Layers_InsertOrientation(t *testing.T) {} +func ds1LayersInsert(t *testing.T, lt layerGroupType) { + ds1 := DS1{} -func Test_ds1Layers_InsertShadow(t *testing.T) {} + layers := make([]*layer, getMaxGroupLen(lt)+1) -func Test_ds1Layers_InsertSubstitution(t *testing.T) {} + for i := range layers { + i := i + layers[i] = &layer{} + layers[i].tiles = make(tileGrid, 1) + layers[i].tiles[0] = make(tileRow, 1) + layers[i].SetSize(3, 3) + layers[i].tiles[0][0].Prop1 = byte(i) + } -func Test_ds1Layers_InsertWall(t *testing.T) {} + ds1.ds1Layers = &ds1Layers{} + + var insert func(i int) + + group := ds1.getLayersGroup(lt) + + switch lt { + case floorLayerGroup: + insert = func(i int) { ds1.InsertFloor(0, layers[i]) } + case wallLayerGroup: + insert = func(i int) { ds1.InsertWall(0, layers[i]) } + case shadowLayerGroup: + insert = func(i int) { ds1.InsertShadow(0, layers[i]) } + case substitutionLayerGroup: + insert = func(i int) { ds1.InsertSubstitution(0, layers[i]) } + default: + t.Fatal("unknown layer type given") + } + + for i := range layers { + insert(i) + } + + if len(*group) != getMaxGroupLen(lt) { + t.Fatal("unexpected floor len after setting") + } + + idx := 0 + for i := len(layers) - 2; i > 0; i-- { + if (*group)[idx].tiles[0][0].Prop1 != byte(i) { + t.Fatal("unexpected tile inserted") + } + idx++ + } +} func Test_ds1Layers_PopFloor(t *testing.T) {} -func Test_ds1Layers_PopOrientation(t *testing.T) {} - func Test_ds1Layers_PopShadow(t *testing.T) {} func Test_ds1Layers_PopSubstitution(t *testing.T) {} @@ -53,10 +102,6 @@ func Test_ds1Layers_Push(t *testing.T) { ds1layerTest(wallLayerGroup, t) }) - t.Run("Orientation", func(t *testing.T) { - ds1layerTest(orientationLayerGroup, t) - }) - t.Run("Shadow", func(t *testing.T) { ds1layerTest(shadowLayerGroup, t) }) @@ -106,11 +151,6 @@ func ds1layerTest(lt layerGroupType, t *testing.T) { //nolint:funlen // no biggi get = layers.GetWall max = maxWallLayers group = &layers.Walls - case orientationLayerGroup: - push = func() { layers.PushOrientation(&layer{}) } - get = layers.GetOrientation - max = maxOrientationLayers - group = &layers.Orientations case shadowLayerGroup: push = func() { layers.PushShadow(&layer{}) } get = layers.GetShadow diff --git a/d2core/d2map/d2mapstamp/stamp.go b/d2core/d2map/d2mapstamp/stamp.go index 35237838..e9708536 100644 --- a/d2core/d2map/d2mapstamp/stamp.go +++ b/d2core/d2map/d2mapstamp/stamp.go @@ -68,7 +68,6 @@ type Tile struct { func (mr *Stamp) Tile(x, y int) *Tile { t := &Tile{ Walls: make([]d2ds1.Tile, len(mr.ds1.Walls)), - Orientations: make([]d2ds1.Tile, len(mr.ds1.Orientations)), Floors: make([]d2ds1.Tile, len(mr.ds1.Floors)), Shadows: make([]d2ds1.Tile, len(mr.ds1.Shadows)), Substitutions: make([]d2ds1.Tile, len(mr.ds1.Substitutions)), @@ -78,10 +77,6 @@ func (mr *Stamp) Tile(x, y int) *Tile { t.Walls[idx] = *mr.ds1.Walls[idx].Tile(x, y) } - for idx := range mr.ds1.Orientations { - t.Orientations[idx] = *mr.ds1.Orientations[idx].Tile(x, y) - } - for idx := range mr.ds1.Floors { t.Floors[idx] = *mr.ds1.Floors[idx].Tile(x, y) } @@ -147,7 +142,6 @@ func (mr *Stamp) Entities(tileOffsetX, tileOffsetY int) []d2interface.MapEntity // nolint:gomnd // constant entity, err := mr.entity.NewObject((tileOffsetX*5)+object.X, (tileOffsetY*5)+object.Y, objectRecord, d2resource.PaletteUnits) - if err != nil { panic(err) } diff --git a/et b/et deleted file mode 100644 index 3237be5c..00000000 --- a/et +++ /dev/null @@ -1,73 +0,0 @@ -diff --git a/d2common/d2fileformats/d2ds1/ds1_test.go b/d2common/d2fileformats/d2ds1/ds1_test.go -index 23035a50..d17527f0 100644 ---- a/d2common/d2fileformats/d2ds1/ds1_test.go -+++ b/d2common/d2fileformats/d2ds1/ds1_test.go -@@ -575,6 +575,24 @@ func TestDS1_SetNumberOfFloors(t *testing.T) { - if err := testIfRestorable(ds1, test); err != nil { - t.Errorf("unable to restore: %v", err) - } -+ -+ newNumber = 10 -+ -+ ds1.SetNumberOfFloorLayers(newNumber) -+ -+ test = func(ds1 *DS1) { -+ if len(ds1.tiles[0][0].Floors) != int(newNumber) { -+ t.Fatal("unexpected floors length set") -+ } -+ -+ if ds1.numberOfFloorLayers != newNumber { -+ t.Fatal("unexpected floors length set") -+ } -+ } -+ -+ if err := testIfRestorable(ds1, test); err != nil { -+ t.Errorf("unable to restore: %v", err) -+ } - } -  - func TestDS1_NumberOfShadowLayers(t *testing.T) { -diff --git a/d2common/d2fileformats/d2ds1/layers.go b/d2common/d2fileformats/d2ds1/layers.go -index f69ef7f1..b0488a34 100644 ---- a/d2common/d2fileformats/d2ds1/layers.go -+++ b/d2common/d2fileformats/d2ds1/layers.go -@@ -1 +1,39 @@ - package d2ds1 -+ -+const ( -+ maxWalls = 4 -+) -+ -+type WallLayer [][]*Wall -+type FloorLayer [][]*Floor -+type ShadowLayer [][]*Shadow -+ -+type layers struct { -+ Walls []WallLayer -+ Floors []FloorLayer -+ Shadows []ShadowLayer -+} -+ -+func (l *layers) PushWallLayer() { -+ -+} -+ -+func (l *layers) PopWallLayer() WallLayer { -+ -+} -+ -+func (l *layers) PushFloorLayer() { -+ -+} -+ -+func (l *layers) PopFloorLayer() FloorLayer { -+ -+} -+ -+func (l *layers) PushShadowLayer() { -+ -+} -+ -+func (l *layers) PopShadowLayer() ShadowLayer { -+ -+}